Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
50 most recent check-ins
|
2026-08-30
| ||
| 17:17 | 2070 follow-on + three defects the review found: help/docs, the editor's save, the pane wipe, and the .SP1/.SP2 name split THE EDITOR WAS CORRUPTING EVERY FILE IT SAVED, and it is the same shared- window aliasing as the tranche-6 p1c find, in a path that sweep missed. On a PSRAM store fsys.data_ptr RE-READS the slot into ONE hub window on every get_ptr call, and the save path was `ed.pack(fs.get_ptr(i))` followed by slot_save's `fs.put(name, fs.get_ptr(i), n)` - the second call restaged over the text just packed, so the OLD file was stored at the NEW length: old bytes plus a tail of pack's leftovers. Reduced to one experiment on silicon: cp COUNT.SPI (103 B, LF) -> cc OK (obj 36) -> ed, ^S, ^Q with NOTHING TYPED -> 112 B -> cc "error line 10 top-level junk (-11)". The phantom line 10 is the 9-byte fragment `n a + 2\r\n`. blink.sp1's duplicated three-line block with the mangled indent is an older instance of the same thing. fs.put_at(i, n) commits the window without re-reading it; slot_save uses it and refuses out loud rather than storing short. SECOND HALF, ^R: the editor's buffer IS the tool arena (editor.arena, 1165 - "idle at the REPL, and load() rebuilds it every time the editor opens"), and cmd_compile runs a 68 KB blob through it, then ED_K_RUN went straight back to editing. ^T reloads after a nested editor for exactly this reason; ^R never did. Proof: ^R then ^S wrote 216 bytes - 103 good ones followed by compiler binary. It reloads from the slot now and restores the cursor row. THIRD: pack_to always wrote CRLF, so every LF file on the drive was rewritten on open+save. load_from remembers the file's own terminator and whether it ended on one; pack is bounded (max) and answers -1 rather than cutting, and a line wider than the row is now a REFUSAL to open, not a silent truncation. PROVEN: 103 -> 103 byte-identical and compiling, both plain ^S and after ^R. PANES NO LONGER WIPE ON A FOCUS CHANGE, and the fix removes the destruction rather than adding a recovery. gfxcon.tile_frame fills the pane interior with C_BG; repaint_dirty then re-renders C_ED from the editor buffer, C_FAP from the app's rows, C_APP from the scene, C_WID by remaking the widget - and C_CON from NOTHING, because gfxcon keeps no character grid (glyphs go straight into the frame buffer; scr_len is a rightmost-column-per-row for scrolling). tile_focus marked both panes FULL for a change in which edge is lit, so every ^W n blanked the console pane. pn_dirty is a LEVEL now (0 clean, 1 chrome, 2 full); tile_reframe/pane_reframe paint the edge and the tab strip and leave the body; a focus change marks chrome-only and every structural path stays full. The re-render calls moved under the FULL branch where they belong as recovery from the fill - a focus change no longer refills a body, remakes a widget, repaints an editor or re-runs an app's scene. Safe because focus_next and focus_dir skip non-visible leaves and tile_cycle (which does change a stack's front) calls desk_paint. Owner confirmed on the VGA tiles: panes hold. .SPIN AND .SPIN2 NO LONGER SHARE A DISK NAME (owner). The driver's 3-char truncation folded both to .SPI - one name for two languages, which is why the P1 examples needed a directory of their own and why a P1 blink and a P2 blink could not be told apart. One extension each: .spin <-> .SP1, .spin2 <-> .SP2. disk_name (new) and disk_to_ram are the one inverse pair and every filter goes through them - the /INSPIN mirror, cp both ways, rm's mirror delete, name_83 (which now accepts .spin, since it round-trips), p1c's find_file (.sp1), spin2c's OBJ loader (.sp2), provision.py's to83/SPLIT, goldp1.py. .SPI is still READ and never written, so a stick provisioned before the split works. cp usb:->ram: stopped keeping the fold too: BLINK.SP1 lands as blink.spin, so an OBJ child pulled in as KID.SPI is findable by both compilers again. TWO THINGS THE BENCH THEN EXPOSED: the migration left .SPI twins in /INSPIN (14 entries, the same file twice), so persist_slot deletes the pre-split name after a successful write - verified 14 -> 9, all new names. And SV_MAX was 8 against a 32-slot ramdisk: boot restored at most eight files from /INSPIN in silence. 24 now, and the overflow SAYS how many it left behind (1540). THE HELP SYSTEM, the 2070 review the rest of this came out of. The DOCS pager had almost no markdown left: `#` and `>` at column 0 and nothing else, where the retired md_line had six classes. Fences and fenced bodies are styled and the parity threads across rows AND pages (pgfen restores it on `p`); a wrapped line no longer DROPS the byte at the wrap column (it was read before the quit and never emitted); the last page no longer keeps the previous page's tail (rows[] was never cleared); a wrapped row is no longer re-classified as a heading. The shelf says LIST CUT AT 40 instead of silently showing 40 of /REF's ~490 cards, and a document opened by path backs off to its parent so `b` lands on the siblings and n/p walk them. TAB COMPLETES THE SECOND WORD against a DRIVE shelf: /APPS for `app` (.BIN and .EAV both), /BOOKS for `book`, /REF for `ref`, case-folded with the completion rewritten in the drive's own spelling (`app do` -> `app DOCS `). cregd declares the kind; complete_drive has complete_cmd's manners. HELP WAS UNREACHABLE ON A FRESH STICK: provision.py never deployed DOCS.BIN at all (only *.EAV and BARS.BIN), and help.md is seeded into the RAMDISK while the app reads /INSPIN/HELP.MD. Both ends fixed - the six framework apps and the manual are in the manifest, and cmd_help_md mirrors the seeded copy itself on first use, falling back to the terse `h` table with no drive. Eight messages still sent the operator to commands the 2000 cut removed (see streams / see chans / uscan / sbaud) - they name `io` now. The seeded manual was documenting a machine that no longer exists: the whole USB section was the deleted u* family, Screens taught chans/streams, and the debug and P1 sections taught seven LABCMDS-fenced commands. Rewritten against the shipped build. AND provision.py called main() UNGUARDED at module level - an `import provision` to inspect the manifest opened the port and started pushing files at the board. Guarded. docs/GUIDE.md gets the pass the review earned it (+294/-162): sections 3, 4, 5, 7, 7a, 8, 9, 10 and 11 rewritten against `h`, the apps replacing the resident lab tiers, `io` and the one storage namespace, the repaint model, and a Spin1-is-not-Spin2 paragraph. BUILD.md's naming rule and the drive table carry the sp1/sp2 split; help.md too. BENCHED, all on silicon: ed round trip byte-identical and compiling, plain and after ^R; app/book/ref TAB completion; help opening DOCS on the manual with the apps provisioned; /INSPIN carrying .SP2 names with the .SPI twins gone; and the P1 LED BLINKING - app P1LAB BLINK.SPI, d -> res 1 (Propeller 1, version 1), l -> res 1 (loaded and running), owner watched pin 16 at 2 Hz. Four configs green; LABCMDS=1 rebuilds (10,464). Daily vga free 23,692 (from 27,528), flashed. NOTED, not fixed: docs/GETTING-STARTED.md not audited; the DOCS pager still cannot ink a `code span` or **bold** because fap paints one styled run per row - that wants a multi-run row in the contract, not an app fix. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GUhEfw2E5L5p2Ty34pK4ky leaf check-in: b1e85f20ec user: ben tags: trunk | |
| 07:38 | NextEffort agrees with fossil: 2070 Fixed, daily at 27,528 free check-in: 25c571023c user: ben tags: trunk | |
| 07:38 | 2070 CLOSES: help migrates onto DOCS - the last resident doc surface cmd_help_md delegates to the DOCS app on INSPIN/HELP.MD (the seeded manual's drive mirror), exactly as read/book/ref already do; with no video or no drive the terse h table still answers and cat help.md prints the manual raw. With the pager's last caller gone, the whole 1210 remnant leaves: page_md/page_key/timed_key, md_line's link-numbering branch (md_islink/md_link), and the nine dead bk_* VARs (bk_dir/cur/ stk/sp/view had NO references since the 1210 deletion; bk_links alone was 456 B). md_line stays as the editor's markdown painter. Benched on the flashed daily: help opens DOCS on the manual (styled heading/fences, 'INSPIN/HELP.MD pg 1' on the strip - screenshot), eval LOOPS.SPI halt steps=2824 err=0 after. Four configs green; LABCMDS=1 rebuilds (14,292). Daily vga free 27,528 (from 25,904), flashed. NOTED, not fixed here: the seeded help.md text still says 'five-slot ramdisk' - content drift for the 1800 sweep. check-in: c8e7fda6a2 user: ben tags: trunk | |
| 07:24 | 2060 docs agree with fossil: the ledger CLOSES LABCMDS.md: every tranche marked FENCED (1-6 + L5), the keeps ruled (hex/unhex/obj/sym/lang/features), the tranche-6 root-cause lesson recorded (the 1760 stale-window aliasing, the 8-entry table overflow, the .SPI/.SPN folds, the verb-6 stack gap), hub ledger at 25,904/12,668. FAP.md: verb 6 documents the 4 KB stack-headroom gap. NextEffort.md: the 2060 tail replaced by its completion record; harness notes (paced keys, one-write ESC-ESC, cp-not-upull) carried for the next cold start. check-in: 1e61336e6f user: ben tags: trunk | |
| 07:23 | 2060 L4 tranche 6: the P1 monitor family leaves the image - and the REAL blocker was never p1c's OBJ link THE ROOT CAUSE, found by silicon: since 1760 the ramdisk lives in PSRAM and fs.get_ptr restages every read through ONE shared hub window - so the p1c file table built from it (cmd_p1c and fap_p1mb both) aliased every entry AND the source to the LAST file staged. The blob compiled whatever landed there: help.md once ('expected CON VAR PUB or PRI, token 56' - 56 is TK_HASH, markdown's first byte), a sibling source another time. That is the whole 'montest compiles to 0 bytes with no error' mystery: the compile was real, the SOURCE was not. The blobs were never guilty. Both paths now stage the set (fs.stage_begin/stage_file, the cc pattern); verb 18 hands out a staged pointer too. THREE MORE REAL DEFECTS ON THE SAME TRAIL: - p1ft held 8 files, cc_ft held 8 files, and both walks visit all 32 ramdisk slots UNBOUNDED - a 9th file overflowed into adjacent VARs silently. Both tables now hold 32 (fsys NFILE). - find_file tried only NAME and NAME.spin - but upull became cp and cp keeps the drive's 8.3 fold, so OBJ 'kid' could never reach KID.SPI. It matches .spi/.spn folds now ('p1 error ... name kid' proved this half loud on PAR.SPI). - verb 6 loaded the tool at exactly fap_extent - the first byte past the app's 2 KB stack. The first REAL deep compile through the app (montest +inspmon, unlocked by the stage fix) punched its recursion through the stack into the loaded blob's code and wedged the machine. The tool loads 4 KB above the extent now; the gap is stack headroom. ALSO: p1c's 2 s wall-clock watchdog was too tight for a real 4.4 KB OBJ child - 10 s now (blob_run's cogstop is the hang backstop since 1165; P1_WAIT_MS 12000 so the compiler's named refusal wins). inspmon.spin gained _clkmode/_xinfreq: bitt=694 is 115200 AT 80 MHZ, so a STANDALONE inspmon booted RCFAST and answered at ~17k baud - alive but unreadable; that was the 'silent monitor cog'. goldp1.py speaks cp + 8.3 names. PROOF, all on silicon: 13/13 P1 gold byte-identical INCLUDING montest (612 B) and inspmon (568 B). The monitor family positive on the real P1: p1mon @P1MON, p1v ticks/slow live, p1peek ticks climbing 837->850, p1poke slow 200 read back, p1r 264, p1stop 0 froze ticks at 2780 with the monitor still answering. P1LAB app parity: peek [0264]=00000ADC = the same frozen 2780 (screenshot); then on the FLASHED DAILY end-to-end: the app compiled MONTEST.SPI to the gold-exact 612 bytes on its own cog, loaded the P1, and peeked [0264]=00000D91 climbing (screenshot). FENCED (hand-placed, depth 0, four configs green): p1mon p1v p1peek p1poke p1r p1w p1stop p1load p1hex - the p1v/p1peek name tier was already dead weight on the daily (its table comes only from the fenced cmd_p1c). unhex STAYS (ruled: general hex-to-bytes). mon_ask/mon_read/ hex_into stay resident - verb 8 rides them. Daily vga free 25,904 (from 24,292), flashed; LABCMDS=1 rebuilds (12,668); eval gold 2824/0 after; tpasm/p1v unknown at the prompt. check-in: 623db0849c user: ben tags: trunk | |
| 06:13 | 2060 L4 tranche 5: tpasm/tblob leave the image - TARGET ~pasm/~blob The last two target-lab commands fence behind LABCMDS after hardware parity. TARGET.BIN gains ~pasm FILE (verb 18 hands the ramdisk slot's hub pointer, verb 6 preps /TOOLS/pasm2.bin above the app, the call runs on the app's own cog, the longs ship down the tx ring as the monitor's P payload) and ~blob FILE (the hex file streamed straight from the slot's memory, no copy). The stub's load_blob blocks on rx with no timeout, so the ~10 ms ring cadence is safe; PMAX=496 (the stub's PASMMAX) bounds the out buffer and over-budget sources refuse inside the assembler. VERB 18 (ramdisk stat) is new and additive: [7]=name -> [8]=length or -1, [9]=the slot's hub POINTER - a slot is static memory, so an app reads the whole 16 KB in place where verb 15's copy caps at its callers' promised 8 KB. FAP.md now carries verbs 13-18. PARITY, both halves on silicon against the same files (EX/COUNT.PAS, EX/COUNTER.HEX, hello.spin2 cc'd + ~go+/tload armed): app - shipped 6 longs @OK, X -> @C 2, R 0 -> @V 321 then @V 642 climbing, ~blob @OK (screenshot SHOT41); resident LABCMDS=1 oracle - assembled 6 longs OK, tcog C 2, tpar 0 V 10 then V 19 climbing, tblob OK (6 longs). Same wire, same fields, same cog. Fences hand-placed inside HAS_TARGET, depth traced to 0, all four check configs green; LABCMDS=1 rebuilds (13,528 free). Daily vga free 24,292 (from 23,328), flashed; tpasm/tblob unknown at the prompt, eval LOOPS.SPI halt steps=2824 err=0 after. TWO FINDS ON THE WAY: con_hook carried a dead paste of fap verbs 15/16/17 (CON_ selectors stop at 14) - removed; and the app key FIFO's 16-deep cap makes a dropped mid-burst key read exactly like a missing file, so the ~pasm/~blob refusal now NAMES the file it looked for (the 1540 rule). Harness keys must be paced ~40 ms apart. check-in: ba7da92bca user: ben tags: trunk | |
| 06:13 | docs/RESTART.md -> docs/NextEffort.md - record the owner's on-disk rename The cold-resume document was renamed on disk without a fossil mv; this records it. Content unchanged. check-in: 6206fed3c3 user: ben tags: trunk | |
| 05:05 | docs/RESTART.md - the cold-resume document The one file to read first after a context reset: where the framework work stands (23,328 free from ~13K), the governing owner decisions, the document map, the concrete architecture (cog 0 / UI cog / fap), the six apps and their proofs, the full verb list, the build+bench+screenshot cookbook, every hard-won trap, the honest backlog (interface unification 1990/2000/2010 not started; the 2060 lab tail with the P1-monitor blocker; the defects 2080/2090 + stub pstr), and four clean next moves. Point-in-time at commit 4fb86353bd. check-in: 24d2b8636d user: ben tags: trunk | |
| 04:58 | 2060 L4 tranche 4: the PROVEN P1 trio leaves the image - LED-confirmed p1/p1c/p1run fenced behind LABCMDS after VISUAL hardware proof: the owner watched a pin-17 blink compiled by P1LAB (the l key = verb 7's p1c-mailbox composition + verb 8 op 2's load/ram_ack) run on the physical P1 - the LED blinking is the parity bench no screenshot could give. detect (d = verb 8 op 1) was gold-benched in L2; compile (c) and compile+load (l) are now confirmed on silicon. +1,152 hub (22,176 -> 23,328 free). LABCMDS=1 rebuilds exact (13,492). The shared helpers stay resident - p1_addr/p1_open (the verbs and mon_ask ride them), the P1VT_MAX CON (the p1vt VAR needs it - the same CON that caused the dev breakage two rolls ago, kept clear of every fence), pick_file, p1_show. Hand-placed fences, depth-verified, HAS_TARGET still closes at 765, all four configs green. HELD (correctly): the P1 MONITOR family (p1r/p1w/p1stop/p1mon/p1v/ p1peek/p1poke) and p1load/p1hex. The monitor needs a live inspmon, which montest's OBJ-link can't provide (p1c compiles it to 0 bytes - a p1c OBJ-resolution issue affecting resident and app equally, NOT a P1LAB bug: the file tables are byte-identical) and standalone inspmon loads (568 B) but its cognew'd monitor cog does not answer over the wire. The monitor VERB round-trip is proven (m reports correctly); the positive peek waits on a properly-linked inspmon. Flashed daily. check-in: 4fb86353bd user: ben tags: trunk | |
| 04:19 | 2060 L4 tranche 4 (P1 monitor): verb 8 extended + P1LAB keys - additive Verb 8 grows ops 3/4/5/6: inspmon banner, hub-long read, write, cog stop - each calls mon_ask/mon_read host-side (the P1 has its OWN FTDI port, which mon_ask opens itself, so no wire generalization was needed). P1LAB gains m (banner) and p (peek, with an inline hex-address entry on the status row) keys. HELD BACK, honestly: the FENCE of p1r/p1w/p1stop/p1mon is NOT taken this roll. The parity rule is gated on a screenshot bench, and the m/p keys' live-inspmon run did not capture cleanly here - the P1LAB 'l' (compile montest+inspmon, load P1) left the console mid-xmit and the shots were phantom matches on stale buffer. Rather than fence resident commands on an unproven bench, the capability lands additive: the verbs and keys exist and gate green (all four configs), the resident commands STAY until a clean m/p parity screenshot. Daily unchanged at 22,176 free; montest.spin/inspmon.spin staged on the drive for that bench. Discipline note: the four-config gate + the screenshot-parity rule are exactly what keep a 'go go go' burst from shipping unproven deletions - this is the rule working, not failing. check-in: 291def4e7f user: ben tags: trunk | |
| 03:15 | 2060 L4 tranches 2+3 + the ^D seam + chunked recv - three rolls ^D SEAM CLOSED: on Ctrl-D the editor marks its own C_ED pane empty and focuses it, so DBG.BIN REUSES that pane instead of splitting it - the debugger lands in the editor's exact spot (screenshot: hello.spin2, print(n) marked at line 7). The edit->debug handoff is seamless. CHUNKED RECV: recv streams into a 16 KB window and fs_writes each through the drive handles - ANY size, the ~72 KB arena cap gone. Proven: a 212,540-byte image (3x the old cap) streamed to the drive. This is what lets timg retire. TRANCHE 2 (+412 B): tcog/tpar/tstopc - monitor-letter commands the armed terminal reaches raw. TRANCHE 3 (+~900 B): timg/timgrx - ~load covers drive images at any size now, and chunked recv removed their reason to exist. Daily: 22,304 free (from 13K). LABCMDS=1 rebuilds all exactly. THE FENCING TRAP, THIRD SIGHTING, now understood: the auto-fencer's block-end detection crosses preprocessor #endif boundaries - tranche 2's first attempt swallowed HAS_TARGET's own #endif into a LABCMDS block, so with LABCMDS off HAS_TARGET never closed and the P1 CONs (P1VT_MAX) fell inside it - dev (TARGET=0) failed with 'undefined symbol'. Reverted tools_target to the L5 commit and re-fenced BY HAND, wrapping only contiguous runs that stay clear of the HAS_TARGET/HAS_P1 boundary. Balance verified: HAS_TARGET(421) closes at 765, final depth 0, all four check configs green. RULE: never auto-fence across a preprocessor boundary - place the pair by hand and trace the depth. Flashed as the daily. check-in: d061949799 user: ben tags: trunk | |
| 02:34 | 2060 L5: the ^D render seam closed - the debugger takes the editor's pane On Ctrl-D the editor now marks its OWN C_ED pane empty and focuses it before launching DBG.BIN, so fap_pane REUSES that pane instead of splitting the still-editor pane and landing half-drawn beside the file. Screenshot: ed hello.spin2, ^D, and the debugger occupies the exact editor spot - print(n) marked at line 7, steps 3. The edit->debug handoff is now seamless. L5 fully closed. check-in: 8384ef3b8e user: ben tags: trunk | |
|
2026-08-29
| ||
| 23:40 | 2060 L5 COMPLETE: the dbg family leaves the image - the marquee payback The editor seam is rerouted and the fence goes through. ^D (ED_K_DEBUG) no longer calls the modal cmd_dbg: it compiles the file while the arena is free, then launches /APPS/DBG.BIN on it and exits the editor into the app pane. With that last caller gone, the 13 debugger commands (dbg step next cont reset break blist bdel regs stack locals vars dis) and their helpers (ensure_dbg, show_at) fence behind LABCMDS - +2,948 bytes on the daily (17,832 -> 20,780 free), verified to rebuild exactly at LABCMDS=1. Verb 16 op 0 no longer compiles (the spin2c-can't-share-the-arena arithmetic, same as ~go): the caller compiles, the app vm.resets onto cc_code. This CLOSED a false-positive from the prior roll - DBG.BIN's self-arm had looked to work only because a console oracle had armed the VM first; now the compile-first contract is explicit and correct. Proven on hardware: dbg/regs/step unknown at the prompt; LABCMDS=1 brings them back to the byte; ^D compiles (it caught a REAL pre-existing error in loops.spin2 - line 158, broken string literal - and reported it cleanly) and on a clean file launches+arms+steps DBG (valid snapshot pointer, the mark walking). check green; flashed as the daily. KNOWN FOLLOW-UP: a DBG pane launched via ^D can land unrendered (the editor's full-screen exit vs the pane split); desk_paint before the launch helps but the render seam wants one more look. app dbg NAME from the prompt renders correctly (prior screenshot). Not blocking - the payback and the fence are real and on the bar. check-in: 3fafc02d6c user: ben tags: trunk | |
| 20:15 | 2060 L5: DBG.BIN - the VM source debugger is an app Verbs 16/17 serve VM introspection: 16 arms the debugger on a ramdisk source (its OWN compile - dbg debugs THIS machine's programs, separate from the target cc), steps, continues-to-break, resets; 17 reads the packed register snapshot (ip/sp/fp/halt/err/steps/line) and the stack/ locals/vars by index. The VM lives on cog 0 under XBYTE, so only the host may touch it - DBG.BIN on a worker asks through the mailbox. DBG.BIN (tools/dbg_app.spin2, 8.2 KB): TDBG's twin - app dbg SRC reads the source (verb 15), arms the VM on it (verb 16 op 0), and shows it with the executing line marked; s steps and the mark walks, resolved through the cc line map in the snapshot. Benched against the resident oracle: regs said ip=17->18 across a step; the app's pane marks line 8 after 5 steps, steps 5 on the strip - screenshot-proven. NOT fenced yet: the resident dbg family has a load-bearing caller - the EDITOR's ^D-to-debug entry calls cmd_dbg directly. Fencing it needs the editor's debug hook rerouted to DBG.BIN first (its own small roll); the family stays resident until then, so this is additive - the app exists, the deletion waits on the editor seam. Verbs 16/17 add ~500 B; net daily 17,832 free. check green; flashed as the daily. check-in: 353aeb9eb7 user: ben tags: trunk | |
| 19:45 | 2040 EXECUTED: demos yanked from source, not fenced (owner order) The sprite demo leaves entirely: eight HAS_DEMOS blocks across console/ gfxcon/inspin (the image/img command, gx.image, the sprite machinery) and the 32 KB balls32_8.def asset - deleted, with the DEMOS flag and its build.sh plumbing. CADDEMO proved already-dead: no live code behind the flag, just the flag and two orphaned defs (cad2d/cad3d, never fossil-tracked - removed from disk). The band renderer (HAS_VBAND) is untouched: it left the demo's shadow in 1880 and draws panes and plots for the platform. The daily's hub does not move (defaults already excluded them); what leaves is the OPTION and the source weight. check-in: 3cd2361793 user: ben tags: trunk | |
| 18:35 | docs: LABCMDS explained - the three layers, the ledger, the picture LABCMDS.md: engines (load-bearing platform, never leave - why the original TARGET=0 L4 is superseded) / commands (the deletable layer, one growing fence, tranche-gated on parity benches) / apps (zero hub). The full command ledger with per-item state, blocker and payback - including the one the tranche lists kept omitting: the 16-command dbg family awaiting L5's VM-introspection verbs, the largest remaining payback. The honest hub ledger: deletions to date vs the 8-10K the framework machinery itself cost. arch_labcmds draws it; LABS-PORT's L4 section rewritten to match reality. check-in: 1068cd82fe user: ben tags: trunk | |
| 18:18 | 2060 L4 TRANCHE 1: the app-covered lab commands leave the daily image probe, load, tload, t, td and tdbg - every one screenshot-benched as an app (PROBE; TARGET's tilde-load/tilde-go/tilde-go-plus and the pretty t family; TDBG with stepping and breakpoints) - now build only under LABCMDS=1. The flag is PERMANENT (owner decision 5): LABCMDS=1 verified to rebuild the resident set exactly. The protocol ENGINES stay regardless - ld, send_hex, tgt_ask/tgt_field (tcog/tpar/tstopc still use them), the cc line maps, p1link - the fap verbs ride them. HUB PAYBACK: +4,156 bytes on the daily (14,156 -> 18,312 free). The fencer crossed one preprocessor nest (cmd_tgt's block ends against a HAS_TARGET #else whose stub then leaked as a duplicate method - the compile named it; the endif now closes before the else). Smoke on hardware: probe/t/tdbg unknown at the prompt, hex alive, the PROBE app probing. check green; flashed as the daily. REMAINING for later tranches: tpasm tblob tcog tpar tstopc (no app parity yet), timg timgrx (deploy tooling until chunked recv), the P1 extras family. check-in: b01371b977 user: ben tags: trunk | |
| 17:58 | 2060 L3: TDBG - the source-level target debugger is an app The long pole is up. TDBG.BIN (8.6 KB): cc SRC at the console, app tdbg SRC - the app loads the target ARMED (verb 12 dbg=1), reads its source off the ramdisk (NEW verb 15), and shows it with the EXECUTING LINE amber-marked, resolved through the line-map verb on every @S. s steps and the mark walks; j/k (or a click) moves a bright cursor; b sets a breakpoint at the cursor line (verb 14 -> the monitor's b addr, gutter star); c continues and STOPS AT THE BREAK - the bench froze it at line 6 with the gutter showing the combined break+exec mark and steps 6 on the strip, screenshot-proven. r resets, g refreshes, q quits; a failed launch parks in a zombie that still answers q. Traps four and five of the name war: brk is a PASM mnemonic and nbrk IS the CON NBRK. And an off-by-one worth recording: the digit composer returns style-offset coordinates - callers treating them as text coordinates left a NUL mid-row and every line truncated after its first number (rows 5/10 and the status strip died at the digits; the screenshot named it instantly). The 2060 parity ladder is now: wire, P1 lab, terminal, raw+compiled loads plain and armed, the t family pretty, the PASM tier, and the source debugger - ALL apps. Remaining before L4: the small-command sweep (tpasm/tblob/tcog/tpar/tstopc rulings) and the deletion plan. check green; flashed as the daily. check-in: d3af733499 user: ben tags: trunk | |
| 17:31 | 2060 L3: the PASM tier's @D pretty view; the armed-run ladder proven TARGET pretty-prints @D (td_show's exact shape: cog N running/stopped, pc, C/Z, pa/pb/ptra in hex) - no host verb needed, the fields are literal. The full armed ladder benched: tilde-go-plus parks the program at the monitor (g = STATUS, not go - the stub header's lesson), D arms PASM debug, c CONTINUES - and the program's ticks stream into the pane (screenshot: 40..69 rolling). Bench lessons paid: cc is guarded while ANY app owns the arena - the order is app off, cc, relaunch, tilde-go-plus (two false benches read the bar's obj 0 as a compile); and the ramdisk boot-restore skipped TPRINT.SP2 (as it had BLINK.SPN) - cp it back each boot, cause unfound, noted. The pstr mystery is CLOSED as pre-existing: tgtvm wires no console hook, so string prints drop while emit chars pass - identical under resident load, parity unbroken, a stub gap for its own ticket. check-in: 31b4bf40fd user: ben tags: trunk | |
| 17:08 | 2060 L3: t-family parity - the pretty monitor and source-line breakpoints Verbs 13/14 serve the cc line map both ways (addr->line, line->addr). TARGET pretty-prints the monitor's @S replies - ip N line L sp S fp F [HALTED] [err E] steps T, ok-green, warn on halt, alarm on err - the line resolved through verb 13 (an @S seen mid-drain defers to loop level: the ask needs the mailbox). tilde-b N looks the source line up through verb 14 and speaks the monitor's own b ADDR down the wire. BENCHED, screenshot: the pane answers g with 'ip 17 line 4 sp 0 fp 0 steps 0' - resident t's words verbatim; tilde-b 6 sent 'b 32' and the monitor said @OK. The t family (g/s/c/r pretty, k/v raw, b LINE) is app-complete; td/tdbg and the pstr curiosity remain before L4. check green; flashed as the daily. check-in: 3f06a4ca47 user: ben tags: trunk | |
| 16:45 | 2060 L3: the armed monitor speaks in the app - tilde-go-plus Verb 12 gains the dbg flag ([9]) - patch_stub arms the target monitor exactly as tload does. TARGET grows tilde-go-plus: stub armed + the console's last compile; then the monitor's OWN protocol is typed raw in the terminal - g/s/c/r, k N, v N - and its @-replies scroll in the pane. BENCHED against the resident oracle, screenshot-proven: tload TPRINT + t g answered 'target ip 17 line 4 sp 0 fp 0 steps 0'; the app's pane after tilde-go-plus shows the same conversation raw: '@S 17 0 0 0 0 0' to the typed g and r - field-for-field the reply resident t parses. The whole t-family conversation is REACHABLE from the app; the parsed pretty-view, b-LINE (needs the cc line map as a verb), and td/tdbg's panes remain as the parity polish before L4 may delete anything. check green; flashed as the daily. check-in: b369cda529 user: ben tags: trunk | |
| 16:31 | COGS.md: the UI cog joins the map - the post-P2 idle loop and the fap seams in the cross-cog table check-in: 5e9bc9cc64 user: ben tags: trunk | |
| 16:31 | docs: FAP.md - the app contract; COGS.md and FRAMEWORK.md catch up FAP.md is the authoritative how-to-write-an-app: the 12-slot mailbox, the row format and operator palette, every service verb (1-12) with its request/result shape, the paid-for rules (heartbeat-in-every-wait, the case-insensitive identifier trap struck three times, redeploy-with-host, the tool region's ownership, ESC vs q), and the shared skeleton (probe_app is the smallest complete example). COGS.md gains the UI cog row, the post-P2 idle-loop truth, and the fap seams in the cross-cog table. FRAMEWORK.md phasing gets its status stamp: P1/P2A/2020/2030/P3 done, the 2060 ladder at L3, what remains named. check-in: 55b981ae58 user: ben tags: trunk | |
| 14:48 | 2060 L3: the load path closes - tilde-go, and the arithmetic that shaped it THE MEASUREMENT THAT DECIDED THE DESIGN: spin2c is 72 KB of object+VAR - needs 74,240 of the 75,776-byte arena ALONE (1.5 KB headroom). No resident app can ever share the arena with a Spin2 compile; the two-tenant compile verb died honest. The workflow does not need it: cc output (cc_code) is a hub VAR that SURVIVES app launch, so compile at the console (the IDE keeps cc resident per 2050 regardless), then tilde-go in the TARGET app = verb 12: tgtvm off the drive into the tool region, the last compile patched in (patch_stub embeds bytecode at the INSP magic), Prop_Chk, one gap-free hex. TWO REAL BUGS fixed en route: (1) blob_prep seeded its result with the first-pub bits EARLY, so every late refusal returned a nonzero garbage method pointer - the caller crashed calling it (now held aside in fpb; this also protected the transient blob path). (2) A host/app contract change benched against the STALE deployed blob wedged the machine - the sequencing rule is now paid for: redeploy the app with the host, always. PROVEN, screenshot: cc TPRINT.SP2 at the console (64-byte object), app target, tilde-go - stub+program hex-loaded (40,656 bytes), the program's half-second counter streaming into the pane that loaded it. check green; flashed as the daily. check-in: b58e4d9b8b user: ben tags: trunk | |
| 13:26 | 2060 L3: verb 10 works - and the two bugs it took to get there The target stayed silent after a verb-10 load twice, look_ver passing and every byte sent, before the real causes surfaced: 1. A drive read between hex parts leaves tens-of-ms gaps and the ROM abandons the load mid-hex - the timg lesson relearned: STAGE FIRST (drive -> PSRAM at TIMG_PS, chunked through the tool region), STREAM SECOND (PSRAM -> hex, gap-free). 2. send_hex_part hex-encodes INTO scratch, so feeding it scratch-staged bytes SELF-CLOBBERS the chunk as it encodes (writes outrun reads 3:1 - garbage after the first five bytes of every chunk). The bounce buffer is now the tool region above the app, never scratch. PROVEN, screenshot: app target, tilde-load /MSP.BIN, and the pane fills with the loaded probe's own output every 2 s (MSPROBE, msd=2000, its uptime climbing) - an image loaded from the drive to the target BY an app that then watches it run. Resident timg was the oracle that split image-bad from path-bad; a fresh-app relaunch split load-bad from relay-bad. check green; flashed as the daily. check-in: 15606c9c1e user: ben tags: trunk | |
| 12:56 | 2060 L3: ~load (verb 10) + the app shelf listing Verb 10: stream a DRIVE image to the target through the ROM's Prop_Hex - reset, handshake, chunked hex off the drive (the proxied read handles), the run tilde. No arena involved: this is the no-compile half of load parity; ~40 s for a big image with the UI cog paused (an explicit act, said in the pane). TARGET's terminal grows '~load PATH' and reports bytes-sent or the failure by name. Discoverability (owner: 'I don't see how to run p1lab'): bare lists usb:/APPS plus a one-line key legend per app; the help line says so. (First cut listed the RAMDISK - line_set2's first slot is the path, not a command word.) check-in: ae6b3f4052 user: ben tags: trunk | |
| 06:57 | 2060 L3 v1: TARGET - the ring terminal; the input FIFO every app needed TARGET.BIN (tools/target_app.spin2, 7.5 KB): the conversation foundation the t/td monitor work rides on. Claims the wire (verb 4), a NON-MODAL terminal in the pane - typed keys echo on the input row, Enter sends the line down the tx ring, replies scroll above with ANSI color stripped, ~ alone pulses the audited reset. Unlike resident term, the shell stays fully alive around it. THE FIX EVERY APP NEEDED: mb[4] is one deep and apps poll at 20 ms, so raw key forwarding DROPPED most of a typed burst (the bench pane read '> ~ss_' - three survivors from three lines). The host now queues input in a 16-deep FIFO (keys AND clicks) that the UI cog drains into mb[4]. BENCHED, screenshot-proven: reset pulse -> the target's own boot banner through the rings ('CANgaru ready... boot config loaded from flash'), then show status and the full facts table rendered in the pane. check green; flashed as the daily. check-in: 4a4d2d1b2c user: ben tags: trunk | |
| 06:14 | 2060 L2: P1LAB - the P1 lab lives on the framework, gold-exact RUN-TOOL-BLOB (owner answer 3) is real: blob_prep splits out of blob_run_core with a BASE offset (a second arena tenant loads above the app - fap_extent records the app's footprint) and answers the entry METHOD POINTER without taking a cog; the app CALLS the tool synchronously on its own cog and 6 KB stack, because the cog arithmetic leaves no ninth cog while an app runs. Cross-image method-pointer dispatch PROVEN on hardware. (Trap #3 of its kind: VAR nb_stack vs CON NB_STACK - case-insensitive identifiers again.) New service verbs: 6 = prep tool [7]=name -> mp; 7 = compose the p1c mailbox for ramdisk file [7] (source/file-table/scratch pointers are host business) -> the mailbox ptr; 8 = the P1 wire ([7] 1 detect -> version, 2 load scratch image [9] bytes -> ack), riding p1link's proven handshake host-side. Verbs 6/8 grant the heartbeat 15 s grace - a synchronous compile silences the app's beat. P1LAB.BIN (tools/p1lab_app.spin2, 7.6 KB): d detect, c compile, l compile+load, q - the operator's seat; the protocol engines stay host services, so nothing the labs could do is lost (owner constraint). PARITY ON HARDWARE, screenshot-proven: resident p1c BLINK.SPN = 60 bytes (gold-exact) and p1run = loaded and running; the APP's pane: '60 bytes compiled' + 'loaded and running' - the physical P1 blinking from a framework app's work. check green; flashed as the daily. check-in: ddfa0b1ed2 user: ben tags: trunk | |
| 05:43 | 2060 L1: THE WIRE HOLDS - Prop_Ver G through the framework rings fap verbs 4/5: claim the target port ([7] -> {@rxring,@txring}, the CANGARU ring layout verbatim; the branch's srf_claim lifted - reuse an open K_TARGET port, else the PropPlug through ustor's own handle) and port control (release / flush / the audited reset-pulse+settle - the one thing bytes cannot do). The relay (the branch's sa_pump with its read-only-what-fits backpressure) joins the UI cog's loop. PROBE.BIN (tools/probe_app.spin2, 7.4 KB): claims the wire, resets the target, speaks the ROM's own '> Prop_Chk 0 0 0 0' down the tx ring, gathers the reply off the rx ring, scans the literal Prop_Ver. PARITY PASSED ON HARDWARE: resident probe said Prop_Ver G; the app's pane says Prop_Ver G, screenshot-proven. r reprobes, q quits, a click reprobes. Plus the repaint debt every framework app needed: a desk repaint that wipes a C_FAP pane now sets fap_repaint and the UI cog re-renders the rows - a focus change once left every app pane EMPTY (the PROBE bench caught it; DOCS had always been screenshotted while still focused). L1 gate passed; L2 (P1LAB.BIN) is next. check green; flashed as daily. check-in: 270ad8f015 user: ben tags: trunk | |
| 05:18 | 2060: the three answers taken - two apps, dbg moves out (L5 via VM-introspection verbs), run-tool-blob is a service verb check-in: 041871b4c3 user: ben tags: trunk | |
| 05:04 | 2060: the labs-port design - docs/LABS-PORT.md How the P2/P1 labs and debuggers become framework apps without sacrificing an ounce of build/debug capability (owner decision 5 rules the document). The one missing piece is THE WIRE: fap verbs 4/5 - claim the target port with CANGARU's ring layout verbatim (the relay joins the UI cog loop with the branch's backpressure lessons), and a port- control verb that owns baud/flush/RESET including the audited DTR rule. Phases L1 (a PROBE app proving byte-identical handshake output) -> L2 (P1LAB.BIN) -> L3 (TARGET.BIN incl td/tdbg in the text grid) -> L4 (TARGET=0/P1=0 default, suites leave the image, the program's largest hub payback - with the build flags kept so a resident lab can always come back). Splits ruled: term/mon/exp stay (seats), eval/compile stay (the IDE), dbg-vs-tdbg split drafted (VM debugger = IDE, target = lab). Three owner questions listed, none blocking L1. check-in: 6fa7b5a88f user: ben tags: trunk | |
| 05:03 | P3: clicks join keys in the app mailbox A click inside a framework app's content posts to mb[4] with bit 31 set (000_0000 + col<<12 + row, pane-relative content cells - keys can never carry bit 31). The tab strip keeps its stack behavior; focus still follows the click. DOCS: a shelf click selects AND opens its row in one; a document click acts as n (page, or the next chapter). Benched via the mouse command's injection path: shelf click descended (gen 2), chapter click opened the doc (gen 3), doc click paged (gen 4). Bench note: a content click FOCUSES the app pane, so wire benches must ESC-ESC before typing commands - the probe sequence itself proved the focus-follow. Flashed as the daily. check-in: 328cfb334e user: ben tags: trunk | |
| 04:08 | 2070: read/book/ref ride the framework; the 1210 resident reader retires The trio delegate to DOCS now: read PATH pages any drive .md; book [NAME] opens the shelf at /BOOKS[/NAME]; ref [NAME] opens /REF or the lowercased card - each composes a path, line_set2's it onto 'docs', and calls cmd_run. The resident reader dies with them: show_md (the link stack), md_path, book_shelf, bk_pick/bk_step and their string helpers are DELETED (+1.4 KB hub, 15,056 -> 16,416); page_md + the md_ line renderer stay only for the embedded help manual until help itself moves. (Trap: a CON block - the STY_ text style bits - was interleaved inside the deleted range and had to be re-landed; the compile named it.) DOCS v3: an ARGUMENT THAT LISTS AS A DIRECTORY OPENS AS A SHELF, else as a document - which is what makes book/ref delegation natural. And CHAPTERS WALK: n at [end] opens the next file on the shelf, p at page 1 the previous - book reading is shelf-order file chaining. Benched on hardware: ref waitx drew its card (app st gen 1); book SPIN2 -> Enter -> six n presses -> the screenshot strip reads BOOKS/SPIN2/ 01.MD pg 5: paged through chapter 00, chained into 01, kept paging. check gate green; flashed as the daily. check-in: b2f0840d24 user: ben tags: trunk | |
| 03:23 | 2070: DOCS becomes the shelf - browse, open, page, all on the framework The host grows verb 3 (list a directory into the app's buffer: 'D|F NAME SIZE' lines, dot entries skipped, 2 KB contract cap) on new proxied entry_attr (FAT $10 = directory), plus - the mailbox vitals diagnostic that was missing when the first empty-pane hunt had nothing to read - and fap_defocus says '(console)' so a wire bench can SEE focus move. DOCS v2 (8.3 KB): SHELF mode from /BOOKS - j/k or arrows move a highlighted cursor, Enter descends a directory or opens a document, u goes up (floored at the start dir), b returns from a document, q quits; the pager WRAPS long lines across rows now instead of truncating. Row composition rebuilt on a clean cursor (rowz/rsty/rcat/ rcatn/rdig). THE KEY FINDING: the fap key-forward gate sat BELOW read_line's CR handler, so Enter always completed the REPL line and could never reach the app - the shelf cursor moved but nothing ever opened. The gate now sits ABOVE the CR check; control keys still fall through to the chords. Benched by the machine's own screenshots: the /BOOKS shelf (cursor highlight, accent dirs, footer keys), then shelf -> SPIN2 -> chapter 01.MD open at pg 1 with wrapped text - the complete browse-open-page path through the mailbox, painted by the UI cog. check gate green; flashed as the daily. check-in: 6b092e4399 user: ben tags: trunk | |
| 02:39 | P3: the framework app host + DOCS, the first app carried on it THE HOST (fap): a code blob from /APPS runs persistent on a borrowed worker (blob_run_in split into blob_run_core + blob_launch_in, the branch shape). The app owns no pixels, no panes, no files: it fills 84-byte styled text rows, bumps a generation, and the mailbox carries keys in and file requests out. The UI COG paints the rows (positioned B_RUN/B_CLR through the LOCKED blit queue - gx.run_style/clear_cells, the operator palette: text/bright/ok/warn/alarm/accent) and serves file reads (proxied chunked handles); COG 0 keeps the wm half: teardown when the pane dies, key forwarding from read_line while the pane has focus (ESC hands focus back - over the wire that is ESC-ESC: a bare serial ESC is swallowed by parse_key's sequence wait, found on the bench). C_FAP joins wm; app NAME [ARG] launches /APPS/NAME.BIN first and falls back to the EAV path; app off / q / a lost heartbeat / a closed pane all tear down fully. cc and recv refuse while an app owns the arena. DOCS (tools/docs_app.spin2 -> /APPS/DOCS.BIN, 7.9 KB): the pager - opens a drive doc through the file service, pages with n/p, q quits, #-headings bright, an accent status strip. The 2070 seed. BENCHED END TO END ON HARDWARE, judged by the machine's own screenshots: intro rendered in-palette beside the console; a real book page (BOOKS/ SPIN2/00.MD pg 2 via the n key); q-quit teardown; Ctrl-P screenshot WHILE the app runs (cmd_shot now stages in scratch when an app owns the arena - the first cut staged in the arena and scribbled the running blob, the gui branch's haunting repeated and fixed the same day). Traps paid for: d_clr takes CELLS not pixels (the pixel-args first cut fill4'd megabytes past the framebuffer - the total wedge); blit rows index from the framebuffer top (TOPCELLS above the desk grid); a stale corrupt blob on the drive dies at cogspin (the launch now probes cogchk after 300 ms and says so). check-in: 402eda0046 user: ben tags: trunk | |
| 01:40 | 2030 complete: probes fenced (PROBES=1 to build), Ctrl-P shoots too bench, bars/htest, vcdump, fbcell, vband, scene, vtext and curs now build only under PROBES=1 (registrations AND handlers; default off) - the diagnosis pattern DEMOS/CADDEMO set. Hub giveback measured: +3,324 bytes on the daily (14,564 -> 17,888 free). shot is NOT a probe and stays always, now with a second trigger: Ctrl-P at the REPL (owner, 2026-08-28) - which also gives the SERIAL seat a screenshot key that a Print Screen keypress could never reach. Benched live: bench/scene unknown on the daily, shot fires from Ctrl-P (SHOT04.BMP). check gate green; flashed as the daily. check-in: 21f46e3fdd user: ben tags: trunk | |
| 01:15 | 2020: ONE face - Parallax everywhere, DEJAVU retired font_cand answers PARALLAX for every slot (the bake race is over); build.sh stops generating DEJAVU.VFN and the file leaves the manifest (provision ships tools/*.VFN = PARALLAX only). The compiled-in bitmap cell remains the no-drive fallback. Chrome and app text already rode the loaded vector face, so one load now serves console cells, chrome and applications alike - the literal one-font decision (owner, 3). JUDGED BY SCREENSHOT (the new eye): the full command roster at the Parallax-baked 8x16 cell, pulled to the PC and read - legible, clean, and incidentally the first visual proof of the P1 table cut (no u* names, cp/cd/mkdir/vol/sync/io/shot/xmit present). check-in: f531dfe7df user: ben tags: trunk | |
| 01:02 | 2030: shot + Print Screen key, and xmit - the eye and the wire shot: the whole framebuffer to usb:/SHOTnn.BMP (24bpp bottom-up, first-free name, streamed 6 rows at a time through NEW proxied chunked writes - ustor/uproxy grow fs_create/fs_write/fs_close following the write_file pattern; the image is 1.4 MB and never fits hub). The Print Screen key (HID usage $46, K_PRTSC 264 mapped in ustor's hid_special) fires it from the REPL. Refused while the editor owns the arena. xmit [usb:]PATH: recv's mirror - streams a drive file raw to the PC ('@XMIT go LEN' then bytes), through NEW proxied chunked reads (fs_openr/fs_read/fs_size) and console.txn (raw serial bytes that never touch the graphics console's glyph interpretation). PROVEN END TO END ON HARDWARE: shot -> SHOT01.BMP (1,440,054 bytes, byte-exact) -> xmit -> PC -> rendered. The first actual look at this machine's screen the project has ever had: bar, tab, border, prompt all correct, colors in the right order. The visual verification gap that let every render bug hide is CLOSED. Traps: ustor has a MEMBER VAR named 'got' (m230 result-name collision); ./build.sh check leaves the SERIAL binary as inspin.bin (a RAM load after check loads a no-gfx image - rebuild vga first). check-in: 11f83afe4a user: ben tags: trunk | |
| 00:07 | P2 stage A: the UI cog - pointer, status bar and data pumps leave cog 0 A claimed worker (owner decision 1) runs ui_loop: pointer motion + sprite (never gated on cog 0), the status bar, chan/fft pumps. Clicks queue through an SPSC ring (ui cog writes, cog 0 pops) because the wm tree and desk_paint stay COG 0 ONLY this stage - a click during a compile applies after it, the latency clicks always had; the POINTER no longer freezes. Data pumps pause under ui_hold while cog 0 runs a command or a ^W chord - exactly the stall they always had, no new shared-state races opened. mon_drain stays on cog 0 (it prints into the scrolling console, cog 0's surface). Headless and claim-failed builds fall back to the old cog-0 chain. The roster names the cog. THE P2 GATE PASSES ON HARDWARE: six status-bar repaints landed during the 12 s an eval owned cog 0 (the bar only repaints from the UI cog) - the pointer rides the same loop. Compile beside the claimed cog works (spin2c found the remaining worker). check gate green; flashed as the daily. Remaining P2: widget-paint migration, wm ownership, the 2020 one-font pass (blocked on the 1850 half-em cell metric for PARALLAX). check-in: 26cd15f2a6 user: ben tags: trunk | |
|
2026-08-28
| ||
| 23:25 | P1 (1990+2000): ONE storage namespace, ONE streams front - the hard cut Storage (1990): paths carry the volume. ls/cat/rm take usb: (and ram:) paths and route to the proven drive cores; cp SRC DST replaces upull/ upush (one ram: side, one usb: side; names keep the source's, the underlying contract); cd/mkdir take usb:/DIR; vol [N|fs|desc] replaces udrive/ufs/udesc; sync save|load replaces usave/urestore. The u* family is GONE from the table (owner: hard cut, no alias period): uls ucat ucd upull uget upush uput urm umkdir usave urestore udrive udesc ufs. Streams (2000): io fronts the system data streams - bare io lists ports + channels + usb roster in one breath; io open/close/baud (were sopen/ sclose/sbaud), io bind/range (were bind/range/chans), io scan/reset/usb/ off/on (were uscan+aliases/ureset/usb+ports). 13 more names gone. Mechanics: take_arg re-reads line[] on every call, so the new fronts inspect the first argument and rewrite line[] in place (arg_strip_scheme / sub_shift / line_set2) before delegating - the proven handlers survive untouched as volume/stream cores. The exec() re-entrancy guard follows the rename (cp/sync refused, cat only in its usb: form). Table: 27 names out, 6 in - net -21. Benched on hardware (RAM load): ls / ls usb: / ls usb:/TOOLS, cat usb:, cp both directions, vol roster, sync save mirroring, io combined listing, old names properly unknown. check gate green. Flashed as the daily. check-in: 59a72ca331 user: ben tags: trunk | |
| 23:06 | 1980: the five P0 decisions taken by the owner 1 UI cog takes a worker (for the moment). 2 hard-cut the old names, no alias period. 3 Parallax as the only font. 4 screenshot on the actual Print Screen key, BMP. 5 one-app-at-a-time is subordinate: build/debug of P2 and P1 code on a target MUST NOT BE SACRIFICED - the framework schedules around the labs, never the reverse. Trunk flashed as the daily. P1 (res:/io: unification, 1990+2000) begins. check-in: bc4564d11a user: ben tags: trunk | |
| 21:20 | 1980: the framework design proposal - docs/FRAMEWORK.md The P0 deliverable for owner review: a UI cog (one claimed worker while video is up) owning input consumption, all pumps, and all pane painting at one owned cadence, freeing cog 0 to be purely the interaction brain; four interfaces applications program against (res: one-namespace storage, io: one-descriptor streams, ui: one-language/one-font display with an operator palette, app: guest lifecycle with events through the mailbox); eval's exec() becomes a posted-line peer of the REPL instead of cog 0's owner. Maps every owner ruling (labs out 2060, demos 2040, probes fence + screenshot key 2030, IDE keeps local Spin2 2050, Docs first app 2070) and phases P0-P5 with hardware-bench gates. Five decisions reserved to the owner at the end. check-in: 5b914ba919 user: ben tags: trunk | |
| 21:18 | store.spin2 reaches trunk at last; mem carries the 2080 timebase probe TRUNK DID NOT BUILD: inspin.spin2 has referenced sto:'store' since the 1930 store-cursor work, but store.spin2 was only ever fossil-added on the gui-private branch - the unmanaged-file trap at trunk scale (the file sat on disk, every build found it, no manifest carried it; the branch add made it vanish from trunk checkouts). Recovered verbatim from the branch. mem now prints getms beside the scaled raw counter (ms/ctms) - the 2080 probe. First measurements with it: a standalone pnut-ts program at 300 MHz shows getms EXACT (msd=2000 across waitms(2000), repeatedly), and this trunk image at the REPL shows getms EXACT against wall time (13976/14000, 14001/14000 ms). The branch-era ~1% observation did not reproduce; the probe stays so any recurrence is measurable in seconds. check-in: 0308601bf6 user: ben tags: trunk | |
|
2026-08-27
| ||
| 22:33 | 1620: provision carries FONTS and APPS - the manifest gap the fresh stick found Tickets (the record): 1620 UPDATE. provision.py never included /FONTS or /APPS - both post-date it (1710, 1940) and were always hand-deployed via recv, so a from-scratch provision landed without them. On fresh drive H the missing dirs read as a driver root-walk bug and survived two wrong theories until a root-directory hexdump settled it: five entries, a clean 0x00 end marker, the P2 reporting the disk exactly - the driver honest, the manifest short. manifest() adds FONTS (tools/*.VFN), APPS (tools/*.EAV + bars.bin as BARS.BIN). Lesson on the ticket: when PC and P2 disagree about a disk, dump sectors before theorising. src/usb_* stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: 246bb2dfc1 user: ben tags: trunk | |
| 18:40 | 1900 FIXED: VGA boots 800x600 - the standard beside HDMI's 800x480 Tickets (the record): 1900 FIXED on the owner's call ('standardize on the 800x600 vga to more align with the 800x480 HDMI... more consistency in expectations'). vsel boots 1; 1024x768 stays one ^V away. Regression at the default: scene 22/22, eval loops 2824 err=0, 100x36 layout. The scanout drops from ~189 MB/s to ~113 of the ~280 ceiling - drawing gets the difference. Flashed as the daily. src/usb_* stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: bd679cde2f user: ben tags: trunk | |
| 17:16 | 1150: flashimg + timg_send - burn the target's flash through timgrx Tickets (the record): 1150 UPDATE. tools/flashimg.py wraps a raw P2 image in pnut-term-ts's own flash loader (496 B at 0, app long-padded behind, debug NOP at +8, negative long-sum checksum at +4 - the image sums to zero, the loader's own integrity rule, insertP2FlashLoader mirrored exactly); tools/timg_send.py streams any image to timgrx and prints the handshake and the launched image's first output. Bench: a 186,852-byte foreign image wrapped, streamed, BURNED and launched; the honest reset test - a host reboot pulses target DTR with no serial traffic - brought the engine back on its own from flash. Trap recorded: probe right after reset captures a serial-first ROM into its loader and flash never boots; reset silently and listen. src/usb_app.spin2, src/usb_exfat_fs.spin2 and src/usb_host.spin2 stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: d5d3bf46b0 user: ben tags: trunk | |
| 07:41 | 1150: timg + timgrx - boot the target from a raw whole image, drive or no drive Tickets (the record): 1150 UPDATE. send_hex split into open/part/close so an image larger than any hub buffer can stream; timg PREFIX N stages 16 KB drive chunks into PSRAM at TIMG_PS ($050_0000, above the scene copy, under the snaps) BEFORE the ROM handshake so the hex stream never waits on a GC-crawling thumb; timgrx LEN skips the drive entirely - raw bytes over the operator console (recv's manners) into the same staging, then cmd_load's handshake and the same stream, ~5 s of the launched image's first output echoed verbatim. timgrx BENCH-PROVEN with a 186,852-byte foreign image: received 16.2 s, Prop_Ver G, 12 chunks, target launched, banner captured; sopen + term 0 then held a full interactive session with the loaded firmware. timg's drive path is compile-proven only - the 1630 write wedge ate its test chunks: twelve recv'd 16 KB files all acked ok, fs wedged to -85, and after ureset the tree was intact but ALL TWELVE FILES had never landed - evidence appended to 1630. vga hub free 23,864; ./build.sh check green on all four configs. src/usb_app.spin2 and src/usb_exfat_fs.spin2 stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: c4862b23bb user: ben tags: trunk | |
| 05:52 | 1960+1610 FIXED: fix and gate - dev/serial compile again, and ./build.sh check keeps it that way Tickets (the record): 1960 and 1610 FIXED on the owner's call ('option 1 - fix and gate is what should happen. there is still need for those'). The fix: str_dec0 moved from tools_target's HAS_TARGET fence to tools_shared beside take_arg - sixteen unconditional callers had grown against it (the ticket was filed at one); and the 1160 td block (cmd_td/td_show/td_line/ td_regs) got the HAS_TARGET fence it landed without, found by the gate's first run. The gate: ./build.sh check - compile-only, vga+hdmi+dev+serial in one command, fails loudly naming the config; FIRST RUN GREEN on all four. The #ifdef-rots-for-months class (1760, 1610, 1960) now has a two-minute tripwire to run before a flash. RESTART.md: session block for the morning - 1740 closed on the owner's hands, the 1780/1800 agent landings, the fix-and-gate, the PropPlug audit (every wire path here is pinned to P97gfytf by-id; the whacker is ModemManager's ID_MM_CANDIDATE probe pulsing DTR - udev ignore rule staged for the owner's sudo) and the muldiv64 correction. src/usb_app.spin2 and src/usb_exfat_fs.spin2 stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: 4adbb24195 user: ben tags: trunk | |
| 05:51 | 1800 FIXED: the features list audited against the compiler - two lies corrected Tickets (the record): 1800 FIXED - the last item (features/lang staleness) closes on a source-level audit by a subagent, verified and extended on the bench here. Two claims of LESS than the machine does: ^alias.struct_t has worked since 2026-08-21 (take_ptr_code -> take_struct_type; examples/objdemo.spin2:21 declares ^a.info_t as a local - a rung that ran err=0 in this session's own regression) - features and GUIDE section 2 corrected, NOT SUPPORTED now carries only plain-var bitfields, which is confirmed real. And muldiv64 is fully wired (HUB_MULDIV64 / vm.spin2 do_md64) and BENCH-PROVEN: muldiv64(1M, 3M, 2M) = 1500000 on the flashed image - features gained the line; RESTART.md's 'no muldiv64, fold 2^16' doctrine was wrong (book ch11 needed no fix: its fold is for a 2^32 multiplier no long argument can carry). Everything else in features checked true against compile.spin2/lex.spin2/vm.spin2. The drift-check design (goldfeatures: claims from cmd_lang's own strings matched to check() labels in example rungs via bookrun; NOT SUPPORTED lines grepped against the dispatch tables so a stale negative fails by construction) is on the ticket. On-device bench: features prints the corrected claims, scene 22/22 after. src/usb_app.spin2 and src/usb_exfat_fs.spin2 stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: 985988fc3b user: ben tags: trunk | |
| 05:51 | 1780 FIXED: one seat binding - gx - and the doubled router is gone Tickets (the record): 1780 FIXED, drafted by a subagent, reviewed and benched here. The same OBJ name under both #ifdef branches binds ONE gfxcon instance gx at compile time - legal because dual-head is retired (2026-08-21) and exactly one of HAS_VGAFB/HAS_HDMIFB exists per build; the ticket's run-time method-pointer set was not needed. 69 doubled PUB pairs collapsed onto gx_live() (THE one video_on-vs-hdmi_on choice); 17 mirror-gated pairs keep their real difference as a nested one-line #ifdef HAS_HDMIFB / if mirror_on gate - only the HDMI surface mirrors console output; set_out()'s dead both-heads block (needed VGA and HDMI defined together, which build.sh refuses) is deleted; fb_addr()/set_out() keep two branches where the seats genuinely differ. 'g' was unusable - case-insensitive clash with a gc_peek parameter (pnut m220). No PUB changed name or signature; nothing else dots into the children. console.spin2 1917 -> 1534 lines. vga hub free 25,268 / hdmi 81,996 (~340 B: gx_live() is a real call at ~85 sites - the price of the forgotten-second-half hazard's removal, and 1760's class cannot recur here). Bench on the RAM image: scene 22/22, loops 2824 / objdemo 2243 err=0, app blockly + (from psram), vband A0/00/00, mouse, tiles. src/usb_app.spin2 and src/usb_exfat_fs.spin2 stay uncommitted on purpose - the Shannon USB session's live WIP through the symlink. check-in: 79debeb179 user: ben tags: trunk | |