gander: preserve row 196 human boundary build for rebase

BUILD-LOG.md

@@ -5174,3 +5174,13 @@ Before: managed project/thread verbs had no Console conversation area. After: fi
 2026-10-20 04:44:54 UTC | Row 178 round 2 preparation | Before: Dewey C1 five render guards lacked killing tests. Added independent refusal fixtures, a temporary uid+1 id stub with cleanup, and empty loopback proof case; activation ordering recorded in r2 BUILD. Product unchanged; syntax/text preflight only, no test or mutant execution. Pending row 181 rebase and Sage slot.
 
 2026-10-20 05:10:34 UTC | Row 178 #1676 round 2 verified | Before: C1 render refusals lacked killing tests and row 181 base was pending. Rebased onto 931651f2d, kept all COUNTED/count code and tests, appended T178 tail; added independent owner/collision/absolute/charset/header and empty-loopback proof tests. Four files singly 156/156, all 24 mutants killed, metadata and sandbox fixture probes pass; scratch sweep empty. Packet agents/rocko/work/queue-178/r2/, candidate 9300a670, inventory d0dcde7b (59/59), scan 58 files no findings; in-review revs 2166-2167, expected no-token request failure. No live actions or commits.
+
+2026-10-20 19:09:44 UTC | Gander row 196 #1694 design phase | Before: tester TCP reaches every local uid and human proofs do not bind the socket peer. After: design draft at agents/gander/work/queue-196/DESIGN.md inventories listeners, proposes private tester HTTP and SO_PEERCRED binding, aligns the per-request principal contract with Morgana and Gizmoduck, and lists migration, tests, mutants and same-uid limits. Python versus other credential options and Console provenance require Duckworth ruling. Documentation only. No product code, suite, live probe, secret access or deployment.
+
+2026-10-20 19:16:20 UTC | Gander row 196 #1694 design r2 | Before: Duckworth r1 requested concurrent helper-fd evidence (B1) and selected O1 with interpreter, proof-only and image conditions. After: design adds eight concurrent genuine proof processes plus a racing copier, M20 swapped socket and post-helper socket survival, root-owned system ELF pinning and activation evidence, safe gid validation, cap traffic without helpers, and unchanged P19 R2 text. Mos accepted socket-only tester access (mos-1015 via sage-1363); any authenticated browser relay is a separate row. Documentation coverage checks passed. No product code, suites or live action.
+
+2026-10-20 19:21:19 UTC | Gander row 196 #1694 design approval and N5 | Before: Duckworth approved r2 (duckworth-0009, cb6d840df) with a nonblocking interpreter-upgrade note. After: r3 chooses startup safety revalidation, appends actual interpreter identity to bus/peercred-starts.jsonl and retains old activation evidence. Operator re-pin uses the next reviewed copy, respecting already-active refusal. Added task-by-task PLAN.md for inline implementation and independent manifest review. Documentation checks passed. No product code, suites or live action.
+
+2026-10-20 19:34:28 UTC | Gander row 196 build paused at design mismatch | Before: approved design promised Unix tester cleanup only for the owned inode. After: scratch test shows Node/libuv close unlinks a replacement inode before JS close handlers. Evidence agents/gander/work/queue-196/evidence/tester-cleanup-blocker.txt. Sent Sage/Duckworth gander-0016/0017, recommending explicit same-uid residual with private 0700 parent retained. Interpreter, concurrent peer, principal, human, peer-transport, transport, tester and process single files passed. Partial code uncommitted, tester transport not wired. No suites, mutant batches or live actions.
+
+2026-10-21 18:45 UTC | Gander row 196 preservation before rebase | Sage-2051, Mos order mos-1193, explicitly authorizes commit and fast-forward push of the current build before deferred full verification. Product and evidence preserved together; prior focused checks and stopped gates are recorded in the row196 packet, with no claim of full acceptance. Next: rebase onto a36523713 on new gander/row196-r2, report range-diff/patch-id/conflicts, then await Sage's clear for M1-M29 and all requested suites. No live action, force push, branch deletion or tests during hold.

agents/README.md

@@ -20,11 +20,6 @@ not fleet seats. Keep changes in `/mnt/storage/src/mosaic-stack`; do not modify
 | Morgana | Builder, MVP T1 row 193 (human users and RBAC) | T3 session (Claude, Opus 5.5), started by Sage under mos-0974/0977 | none, T3 only |
 | Honker | Builder, MVP T1 row 194 (agent lifecycle) | T3 session (Claude, Opus 5.5), started by Sage under mos-0974/0977 | none, T3 only |
 | Gander | Builder, the human boundary across uids (P19 333, #1694) | T3 session (Codex, gpt-6.1-sol), started by Sage under mos-0977 | none, T3 only |
-| Herb | Builder, a second gate lane (#1695) | T3 session (Codex, gpt-6.1-sol), started by Sage under mos-0977 | none, T3 only |
-| Bushroot | Builder, retire the control board writer on 7331 (#1696) | T3 session (Claude, claude-haiku-5-5), started by Sage under mos-1008 | none, T3 only |
-| Megavolt | Builder, MVP T1 item 6 (agent credentials and git identity, #1697) | T3 session (Claude, Opus 5.5), started by Sage under mos-0974/0977 | none, T3 only |
-| Quackerjack | Builder, federation R5 and R2 (#414) | T3 session (Claude, claude-haiku-5-5), started by Sage under mos-1023 | none, T3 only |
-| Gizmoduck | Federation design (#414) and builder of FED R1 | T3 session (Claude, Opus 5.5, thread 9312a896) | none, T3 only |
 | Webby | Reviewer: Case 2 designs, rows 192 and 194 | T3 session (Claude, Opus 5.5, thread 03086006), started by Mos (mos-0981) | none, T3 only |
 | Duckworth | Reviewer: federation designs, row 193 | T3 session (Claude, Opus 5.5, thread ffceafec), started by Mos (mos-0977) | none, T3 only |
 | Sage | Project lead: coordination, review, integration; earlier DYOR strategy records retained | T3 session (Claude Code); Pi launcher `zai/glm-5.3:high` retained | `agents/sage/launch.sh` |

agents/bushroot/README.md

@@ -1,8 +0,0 @@
-# Bushroot
-
-Builder seat, Claude Haiku 5.5, started by Sage under mos-1008 item 2 (a low-level model under Q177) for the row
-that retires the control board writer on 7331 (#1696).
-
-No launcher in this directory. The seat runs as a T3 thread and works in its own worktree. It has no
-credentials of its own; until the credentials row settles per-agent identity, it pushes only its own `bushroot/*`
-branches through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

agents/gander/work/queue-196/BUILD.md

@@ -0,0 +1,100 @@
+# Row 196 build evidence
+
+Base 4d26003f7. Build authorized sage-1371, design approved duckworth-0009/0015.
+No live units, live ports, credentials, real second uid or live state touched.
+Single test files only so far. Suites and mutant batches require Sage's slot.
+
+## Cleanup ruling, sage-1382 (2026-10-20T19:39:30Z)
+
+The first scratch test proved Node/libuv unlinks a final-path replacement before
+JavaScript close callbacks. Evidence: evidence/tester-cleanup-blocker.txt.
+Duckworth's option 1 (523a6bddf) was then verified in a standalone scratch test:
+bind temporary.sock, record dev/ino, rename to tester.sock, connect successfully,
+replace final inode, close. Temporary name absent and replacement survived.
+
+Sage chose option 1. The code binds a unique temporary name in the checked 0700
+parent, chmods/verifies the socket, records its dev/ino and renames to tester.sock.
+The temporary basename has the same length as tester.sock. libuv remembers the
+removed temporary name. The close callback lstat/checks the final dev/ino before
+unlink. The final-path replacement test was RED with direct bind and GREEN after
+rename. It also asserts no temporary entry after bind or close. M24 will bind the
+final path directly and must fail this test.
+
+Residual: a hostile same-uid process can replace a path between lstat and unlink
+(or between the final-path check and rename), or recreate the temporary name
+before libuv closes it. The checked private parent excludes other uids, not the
+instance's own uid. These same-uid races are outside this row's guarantees.
+
+## Development checks
+
+Evidence files retain the red/green and diagnostic output. The initial concurrent
+peer test exposed that Node pauses a Socket passed through spawn stdio. The caller
+now resumes it after helper exit, with bidirectional post-helper traffic asserted.
+No product commits until applicable suites pass. Final candidate and counts follow
+after implementation and authorized verification.
+
+## Gate stop, 2026-10-20T19:57:01Z
+
+Gate run 1 stopped at bus 463 pass/1 failure. The row164 reviewed byte pins needed
+the intentional row196 human-walk/nonce and Console initial-spawn nonce changes.
+Only those two pins were updated, retaining human-cli and CLI transport pins,
+literal path recovery and channel plug-in import bans. Focused test passed.
+
+Run 2: bus 464 pass/0 fail. WebUI stopped at two failures in tester-browser.test.mjs:
+it still formed TCP URLs from the now-Unix listener address. Script counted 269
+passing top-level cases before interruption and 2 failures. No final WebUI summary.
+CLI and mutants did not run. Node24 peer 3/3 and principal 4/4 passed separately.
+Sage received clear (gander-0023). The failures are fixture migration omissions,
+not timing failures from Launchpad's overlapping single T56 run. No product commit.
+
+Focused repairs: the browser fixture fulfills synthetic-origin requests through
+CDP from the scratch Unix listener, with no TCP listener, proxy or product relay.
+The two tester browser tests pass. Self-review also found a FIFO receipt could
+block open before fstat; O_NONBLOCK now makes it refuse promptly (RED timeout,
+then interpreter 5/5 GREEN). Missing/non-regular helper now refuses construction
+before opening broker.sock (RED missing refusal, then peer reader 4/4 GREEN).
+Renewed slot requested in gander-0024; no suite or mutant rerun yet.
+
+## Manifest preparation while the slot is occupied
+
+sage-1409 accepts the CDP fixture repair and startup refusals. MANIFEST.md gives
+each its own item, including the old/new human.mjs and WebUI bus.mjs sha256 values
+and rationale for the row164 re-pin. PRODUCT-FILES.json records current product,
+test and operator-document hashes, explicitly as an uncommitted draft.
+
+Self-review also found helper shutdown returned before child close. The focused
+test was RED (evidence/peer-shutdown-red.txt), then GREEN after reader.close awaits
+all killed helper close events and server.close awaits reader.close. M27 removes
+the wait. M25 removes FIFO nonblocking open and M26 removes helper preflight.
+All three are prepared but unexecuted, reported to Sage in gander-0025.
+
+After this change, individual Node 24 files pass: peercred 5/5 and principal 4/4.
+Node 26 peer-transport is 3/3. Their logs retain the full results. No suite or
+mutant batch ran during the hold. sage-1416 puts Gander after Launchpad, Darkwing,
+Rocko and row 192; Sage must send go before the renewed batch starts.
+
+The consumer audit found one additional conversion defect in the files already
+changed: proof insertion stopped at --tester-port but not --tester-socket.
+Pointer argv therefore differed from rendered unit argv when conversion also
+supplied a proof pair. The extended row196 release case reproduced the exact
+order mismatch, then passed after adding the socket flag to that insertion
+boundary. The proof-file no-read check still passes. M28 restores the defect.
+No batch ran. Shell syntax and diff whitespace checks pass. Final prepared
+mutant count is 28, pending Sage's go.
+
+## Static review completion, sage-1425
+
+The changed verifier path now has a real Client refusal test. A completed proof
+refusal reaches the client as human-required; helper failure is peercred-required.
+No broker request dispatches. peer-transport is 4/4. Client code is unchanged:
+an abrupt close, timeout or transport error without a response is outcome-unknown.
+The scratch base/candidate comparison returns human-required for both. It does
+not reproduce Quackerjack's exact failing instance; the manifest names this limit.
+
+Review also found release did not check tester path length until after service
+stop. The focused long-path activation fixture reproduced it, then passed with
+the new preflight. Existing unsafe parent type/uid/mode checks also precede stop;
+the fixture verifies no start/stop calls for unsafe mode. M29 removes the check.
+Legacy tester-port-invalid wording is restored to avoid an unrelated contract
+change. Review covered all changed trust paths and consumers; no further code
+changes are planned before the batch. M1-M29 remain prepared and unexecuted.

agents/gander/work/queue-196/DESIGN.md

@@ -0,0 +1,332 @@
+# Row 196: the human boundary across uids and humans
+
+Gander, 2026-10-20. Revision 3, recording approved r2 and N5. Gitea #1694, P19 333.
+Base: `96f243faf`, branch `gander/row196`. Design approval latest-by 2026-10-22, landing
+latest-by 2026-10-24 and before federation R3. This document authorizes no live action.
+
+## 1. Outcome and authority
+
+Other Linux users must not reach the tester's data or writes. A bus human proof must describe
+the process that actually connected. Console user calls must also pass the human walk and
+come directly from this bus tree's Console. Row 193 and federation R3 use that one verifier.
+
+This is not isolation from a hostile process on the instance's own uid. Keeping the human
+terminal CLI means that an unmarked process on that uid still has the owner's authority.
+Process ancestry cannot prove that a process was never an agent. Sections 4 and 8 state this
+limit without treating it as an enforcement guarantee.
+
+Inputs: COMMON at `53bb59462`, the row brief at `96f243faf`, Q175 sections 1, 6 and 8,
+federation r2 at `60b9b112a` section 3.6, Duckworth's B1-B5 at `b402197ff`, row 190's
+DESIGN.md and the row 190b brief. Q175-Q178 and the MVP plan set the order. Row 190b is on
+hold pending the host decision. This row does not assume that a separate uid is already live.
+
+Sage's `sage-1343` accepts the design direction and requires Duckworth to rule on the peer
+credential implementation. `sage-1345` keeps the control board inventory-only. Morgana's
+`morgana-0003` supplies the principal contract in section 4. Sage registers this session.
+Mos accepted removal of direct tester browser access in mos-1015, relayed by sage-1363.
+Agents test through the private socket. Any later browser view is an authenticated relay
+behind SSO, designed and reviewed in its own row. This row adds no relay.
+
+## 2. Inventory from code, not a live probe
+
+"Same uid" includes untrusted local processes. "Other uid" excludes root, which is outside
+this boundary. SSO below means Q175 is active on that instance, not merely installed.
+
+| Entry | Same uid today | Other uid today | Effect of SSO and this row |
+|---|---|---|---|
+| Main Console, default 7332, bare serve default 7330 | Loopback reads. With preview/send, matching Host, header and origin can write as owner | Same TCP reach and header forgery | Q175 SSO verifies login and refuses non-public Host except GET /healthz. This row does not change public ingress |
+| Tester TCP, default installation 7333, optional per instance | Reads and the tester instance, route, name and chat writes | Identical reach, no uid check | Q175 deliberately leaves tester separate. This row replaces TCP with a private filesystem Unix socket |
+| `<dataRoot>/bus/broker.sock` | Connects, then needs cap or proof. Claimed human PID is not the socket peer | Normally refused by bus/ 0700 and socket 0600 | SSO changes nothing. Add peer uid and PID binding, retain file checks |
+| Human wrapper to tree's human-cli.mjs | Owner if CLI path, nonce and ancestry pass. Agent ancestors refuse | Cannot connect to protected socket, and proof uid refuses | Preserve terminal owner path, add peer binding. SSO does not authenticate terminal users |
+| Tester CLI to broker.sock | Tester if its proof passes and bus.tester is exactly true. T3 agents are allowed, managed runs are not | Filesystem modes normally refuse | Same tester policy, plus peer binding. No owner/user upgrade |
+| `<dataRoot>/bus-host/launch.sock` | Requires run cap and launcher checks | bus-host/ 0700, socket 0600 | No human proof endpoint. Unchanged |
+| `<dataRoot>/bus-host/git.sock` | Git capability protocol and broker authorization | bus-host/ 0700, socket 0600 | No human proof endpoint. Unchanged |
+| Discord connector | Outbound Discord gateway/REST, no inbound local listener. Local process could tamper with same-uid files/process | No local port to call. File separation depends on uid and modes | Existing guild, user, channel, bot and webhook checks remain. Discord is not a new bus human transport |
+| Row 190 additions | Separate configs, roots, unit names, wrappers and Console ports, on one uid | Console/tester TCP still reachable | Adds no new class of listener. Row 196 derives its socket per dataRoot. Row 190 alone supplies no hostile-process isolation |
+| Control board, default 7331 | Unauthenticated transcript/board reads, POST /api/reply and /api/seen after request checks | Same loopback reach. A local client can supply matching request headers | Independent development service, outside instance SSO. Inventory only per sage-1345. Its fix needs another row |
+
+Evidence: `packages/webui/src/{cli,serve,bus}.mjs`, `packages/bus/src/{server,runtime,human,
+tester,store}.mjs`, `packages/cli/src/{launcher,git-socket,transport}.mjs`,
+`packages/discord/src/{gateway,authorize}.mjs`, `packages/control-board/src/serve.mjs`.
+Store checks bus/ with `safe(directory,true)`, including owner, symlink and mode checks.
+The dataRoot check itself does not require 0700 today. Do not describe that as a checked mode.
+
+## 3. D1: private tester HTTP socket
+
+Add `serve --tester-socket`, a boolean selecting `<dataRoot>/console/tester.sock`. No arbitrary
+path or new system config field. Create console/ as 0700. Refuse a symlink, wrong owner,
+non-directory or any group/other bits on an existing console/. Refuse a pre-existing socket
+or other entry rather than deleting it blindly. A stale socket needs an operator's diagnosis.
+Refuse a path longer than Linux's 107-byte pathname capacity before binding.
+
+Bind HTTP on the Unix path, set socket mode 0600, then verify type, owner and mode before
+declaring ready. The private parent covers the bind-to-chmod interval. Cleanup only the owned
+device/inode, as broker.sock does. Never open a TCP compatibility bridge or an abstract socket.
+Readiness failure closes the main listener too, rather than leaving a partially started Console.
+
+The tester handler keeps its fixed principal, header/cookie refusals and exact write list.
+Use a fixed logical origin `http://mosaic-tester.invalid` for URL and same-origin checks. It
+does not resolve that name. Clients send that Host and Origin plus the existing Fetch Metadata
+when required. A Host string is not authentication. Unix socket access supplies that boundary.
+The main listener still refuses x-mosaic-tester. No tester /auth route exists.
+
+`bus.tester` remains Jason's switch. Socket reach never enables tester authority by itself.
+Turning it off must refuse every tester bus call. This row adds no user or owner capability
+to the tester. Tester reads retain today's scope, including any local Console reads that are
+not bus calls. This row does not turn bus.tester into a separate HTTP read switch.
+
+### Consumers and migration paths
+
+| Consumer of 7333 | New path |
+|---|---|
+| Agent tester HTTP tools and curl probes in authorized window packets | `curl --unix-socket <dataRoot>/console/tester.sock http://mosaic-tester.invalid/...`, with the fixed Origin for writes. Add one repository helper for bounded tester HTTP requests so callers do not copy path/origin logic |
+| `scripts/mosaic ... --tester` | Already uses TESTER_CLI and broker.sock, not TCP. Keep its verbs, output and switch |
+| Browser tester page in row 176 and later window checks | Ordinary browsers cannot navigate a Unix HTTP socket. Replace automated tester HTTP checks with the socket helper. Browser visual QA uses scratch fixtures only. No local TCP relay is added |
+| `webui-service.sh` render/install and installed unit | Carry --tester-socket for new copies. Refuse a target without support. Units running old copies retain their old flags until a window |
+| `stack-release.sh` activate, plan, rehearsal and rollback | Add --tester-socket. Replace inherited --tester-port N only when explicitly requested. Refuse incompatible inherited flags before stopping units. Plan names the transport and every dropped pair. Rehearsal uses a scratch socket |
+| Gate/window Console checks, including agents' console-check scripts | Extend checks to use scratch Unix HTTP and expect no tester TCP bind. Sage owns live packet updates, including Q175 phase 2's old --tester-port 7333 instructions |
+| `docs/TOOLS.md`, webui/cli/bus READMEs and examples | Document socket invocation, fixed origin, loss of direct browser navigation and per-instance path. Historical window receipts stay unchanged |
+
+Repository search found no non-test hardcoded 7333 caller in tools/ or the harness code. The
+active windows and external seat commands still need Sage's consumer audit before re-pin.
+The build manifest will record the full search, rather than treating this draft as that audit.
+
+## 4. D2: one verified principal per bus request
+
+Internal interface: `verifyPrincipal(request, connection) -> {kind,business,id}` or refusal.
+Kinds are owner, user and tester. The connection metadata is supplied by the trusted server,
+never deserialized from JSON. No role or authority is returned. The broker looks up live policy.
+
+1. Read and validate the bounded envelope first. For human, tester and user proofs, read Linux
+   SO_PEERCRED on that accepted Unix connection before dispatch. Require a valid peer PID
+   and the bus uid. Refuse unavailable credentials, unsupported platform and errors. Cap
+   traffic keeps its capability protocol behind the validated 0700 directory and 0600 socket.
+2. Require exactly one cap, human, tester or future user envelope. Human/tester/user proof.pid
+   must equal the kernel peer PID. Verify startTime, nonce and CLI path against that process.
+   Keep the second process read after the walk. Missing, changed or exited processes refuse.
+3. Owner terminal: run the full existing human walk. Map the business to businesses[b].human.
+   No supplied human id, role or uid selects the principal. Keep today's terminal invocation.
+4. Tester: run verifyTester, retaining its deliberate difference from the human walk. An agent
+   seat may be tester. A managed-run marker or registered managed ancestor refuses. Then check
+   bus.tester. The full human walk must never be weakened to admit a session user.
+5. Session user: use the full human walk with the path-bound user-cli entry and its own nonce
+   variable, MOSAIC_BUS_USER_NONCE. Parameterize the nonce reader without admitting a human
+   or tester nonce as a user proof. Require its immediate parent to be the same tree's resolved webui/src/cli.mjs,
+   argv[2] `serve`. Check parent uid, startTime and ppid again before binding. Both child and
+   parent remain alive for the call. A different checkout or wrapper parent refuses.
+6. For user calls, the Console puts its mapped access-file user id in the verified proof's
+   user field, as federation 3.6 specifies. The id comes only from claims Q175 verified for
+   this request's live session, never from an identity cached past that session. It never
+   takes that id from a form field or verb
+   args. Return kind user, proof.business and proof.user as id only after the provenance
+   checks. R3 then validates that mapping and the live grant. Bad access.json denies users,
+   not the terminal owner. The verifier does not implement access-file policy.
+7. Owner Console calls keep the verified Q175 owner subject path. Under SSO only a subject
+   in console.sso.subjects reaches owner bus calls. They use human-cli and the same peer/walk
+   checks. A terminal owner still needs no SSO token. No anonymous main-listener fallback.
+
+The bus verifies which process supplied the session identity. It relies on that Console's
+Q175 implementation to have verified OIDC. It does not independently verify an ID token in
+this option. A provider/sub field alone, from another process, is not enough.
+
+The Console must spawn user-cli directly with its nonce already in the launch environment.
+It must not use human-cli's existing self-respawn pattern, which makes the CLI's parent a CLI.
+Apply the same initial-nonce spawn to Console human calls for consistent tests. Terminal
+human-cli can retain its self-respawn since no Console-parent condition applies there.
+Never strip agent markers from inherited environments to make a walk pass.
+
+The server binds an internal cap for this request, dispatches, and disconnects in every
+success/error/timeout path, including asynchronous task and web calls. It never returns the
+cap or a reusable principal handle. A proof copied by another process has a different kernel
+peer PID and fails. One verified CLI may make only its one request on its one connection.
+The session may hold s.user for that request. No PID or principal cache survives the connection.
+
+### Fit with rows 193 and R3
+
+Row 196 owns peer metadata, proof/walk verification and the internal principal interface.
+It supplies the Console provenance verifier and tests before R3 adds user-cli and user sessions.
+R3 owns access.json mapping and the bindUser integration, using this interface. It must not
+add a second ancestry implementation. Row 193 adds viewer and share policy to the same live
+grant check. An owner id is the business human. A user id is the access-file id, with stored
+owner string `user:<id>`. Neither row takes role from the proof.
+
+No live grant, unknown subject, duplicate owner/user mapping and invalid access file all
+deny user binding through R3's policy. Per-request authorization, access.reload and the
+30-second recheck remain R3's responsibility. Share visibility uses that check in row 193.
+Binding provenance is not a grant and never widens one. R3's user dispatch must run before
+names falls through to #agent. R3 must not land before this contract and its tests are green.
+Gizmoduck's gizmoduck-0015 and Gander's gander-0007 agree on this split. R3 keeps the reserved
+user-name mutant. Row 196 tests kind separation even if a user id resembles the owner name.
+
+### OIDC alternative
+
+The bus could verify the signed ID token itself and map its issuer/sub. That reduces reliance
+on the Console's subject assertion, but requires JWKS/provider handling, nonce or challenge
+binding, replay handling, login and logout/session lifetimes in the bus. Reusing an ID token
+on every request either creates a replay credential or expires a Console session with the
+token. A bus-issued session needs a separate lifecycle design. It also leaves the terminal
+owner and hostile same-uid limit intact. Recommend the Console provenance contract for this
+slice. Duckworth approved this option in duckworth-0006, with the live-session condition above
+and the requirement to carry section 8 R2 into P19 333 word for word.
+
+## 5. D3: obtaining kernel credentials, O1 approved with conditions
+
+All options must bind the accepted connection, not a PID a caller picked. None gets a silent
+fallback to the current proof. Sage required this comparison. Duckworth selected O1 in
+duckworth-0006, with the interpreter, proof-only and image conditions below. O4 remains the
+fallback if Python is unavailable, and needs a revised build manifest before use.
+
+| Option | What it proves and costs | Recommendation |
+|---|---|---|
+| O1 Python stdlib helper on inherited accepted socket | Node passes the accepted net.Socket as fd 3 using documented spawn stdio stream passing. Python socket(fileno=3) reads SO_PEERCRED and returns only pid,uid,gid on stdout. No socket reads, no shell, no credential values. Adds Python to bus hosts and any future bus image, with a process per admitted proof connection. Copies carry the helper and depend on the system interpreter | Selected by Duckworth, with conditions below |
+| O2 /proc/net/unix plus inode and /proc/PID/fd scans | The table identifies Unix socket entries, not an authenticated peer PID for each accepted connection. Finding a process holding an inode is racy, may have several holders and can be unreadable. The server endpoint's inode is not the client's inode | Reject as a replacement for SO_PEERCRED. No claimed proof PID may choose the scan target |
+| O3 plain Node fd passing or abstract sockets | A private inherited IPC channel can authenticate a child that this parent spawned. The bus did not spawn the independently started Console or terminal CLI. Moving the bus into the Console's child tree changes lifecycle and ownership. An abstract name supplies no filesystem mode boundary and no peer uid check by itself. Node's public net API supplies no SO_PEERCRED accessor | Reject as a drop-in. A larger bus-spawned transport design could use fd capabilities, but is outside this slice |
+| O4 small compiled helper or Node-API addon | Calls getsockopt directly, with no Python runtime. A helper can use the same inherited fd. Adds compiler/build closure and platform artifacts to stack-copy and containers. An addon also needs a supported way to obtain the accepted socket fd and Node version coverage | Viable alternative if Python is refused. Prefer a small helper over undocumented Node handles |
+
+For O1, pin the system interpreter `/usr/bin/python3`, resolving its system symlink to an
+absolute ELF binary. Require root ownership and no group/other write on that executable and
+its path components. Refuse scripts, PATH shims and any resolved path under an OS account's
+home, including /home and /root. A pyenv shim can choose an interpreter before -I -S applies.
+No PATH lookup, caller-selected interpreter or helper. Invoke the resolved binary with
+`-I -S`, a minimal environment and the absolute helper path in the same pinned copy.
+
+Activation preflight records the interpreter's resolved path, version and file identity/hash
+in its gate evidence. The bus validates and pins the resolved executable at each startup
+before opening broker.sock. The activation gate must report the same interpreter used by
+that bus. Missing, unsafe or changed resolution during that activation refuses it, never
+falling back to PATH. No secret values are recorded. Test system-owned interpreter checks
+through injected metadata.
+
+N5 decision: a later bus restart repeats the safety/version/support checks and accepts a
+safe system interpreter installed by an OS upgrade. It does not compare against an old
+activation hash. Before opening the listener, append a startup receipt with timestamp,
+copy path, resolved interpreter path, version and file identity/hash to
+`<dataRoot>/bus/peercred-starts.jsonl` (0600 in the checked 0700 bus directory). Refuse an
+unsafe receipt file or failed append. Never edit the old activation evidence. The startup
+receipt identifies the binary now in use, so the old receipt remains a historical fact.
+If an upgraded interpreter fails the checks, startup fails closed until a safe supported
+system interpreter is restored by the operator. There is no shim or O4 auto-fallback.
+
+Operator re-pin after an interpreter change: in the next authorized window, prepare the
+next reviewed copy with `scripts/stack-copy.sh copy NEW`, then run
+`scripts/stack-release.sh activate NEW BUSINESS --tester-socket` with that instance's existing
+flags and selector, first with --plan. NEW must differ from the active copy because activate
+refuses already-active. Record the interpreter in the new activation evidence and compare it
+with the bus startup receipt. A routine OS update alone does not authorize a re-pin or unit
+restart. A bus restart does not rewrite config, pointer or activation history.
+
+Preflight helper and SO_PEERCRED support too. The helper lives under packages/bus/src so
+stack-copy's closure includes it. Copies remain immutable. Document Python >=3.10 on bus
+hosts. Today's Containerfile builds the worker image and runs run-agent.sh, not the bus.
+It needs no Python change for this row. A future bus-host image must explicitly include
+the pinned system Python or use reviewed O4. No install through the node_modules symlink.
+
+Pause each proof connection while reading credentials. Limit outstanding helpers
+to 16, timeout to one second, output to one strict JSON record of at most 256 bytes. Refuse
+nonzero exit, extra output, malformed integers, missing fd and timeout. Validate pid, uid and
+gid as safe integers, pid >=2 and uid/gid >=0. Only pid and uid select the principal. gid is
+validated but grants no authority. Kill and reap helpers on shutdown. Cap envelopes never
+spawn this helper. Reading the proof envelope first is sound because SO_PEERCRED describes
+the peer at connect time. Keep the accepted Socket object owned by its connection closure,
+not a shared current-fd variable. Only the helper's duplicate fd is closed when it exits.
+
+References: [Node stdio stream passing](https://nodejs.org/api/child_process.html#optionsstdio),
+[Node Unix socket support](https://nodejs.org/api/net.html#ipc-support),
+[Python socket and getsockopt](https://docs.python.org/3/library/socket.html),
+[Linux Unix credentials and permissions](https://man7.org/linux/man-pages/man7/unix.7.html),
+[Linux proc network table fields](https://man7.org/linux/man-pages/man5/proc_pid_net.5.html).
+These support the APIs. The connection-binding behavior still needs T2 on supported Node versions.
+
+## 6. Migration and rollback
+
+No config schema or store schema changes. Old copies and units keep working until each
+instance re-pins. No new verifier is loaded into a running old broker. Do not pair a new
+Console with an old bus and call it protected. Same-tree paths intentionally refuse mixtures.
+
+The authorized window must pin bus, Console and human wrapper to one candidate. New tools
+offer `activate ID BUSINESS --tester-socket`. Plan must show the old tester-port pair removed
+and the new socket flag added, and tell Jason that direct tester browser navigation is lost.
+Mos accepted that change in mos-1015 (sage-1363). Agents test through the socket. A later
+authenticated browser relay behind SSO belongs to its own row. Without the explicit
+conversion, a candidate that no longer
+serves tester TCP refuses inherited --tester-port before stopping anything. New serve refuses
+--tester-port with a migration error. It never silently changes that flag's meaning.
+
+Rollback to a copy lacking --tester-socket drops tester enablement and reports it, as today's
+tools drop unsupported flags. It does not turn the socket back into TCP. The old main Console
+and owner CLI can run with their known old limits. A failed activation's recovery may restore
+the old saved unit, including its TCP listener. Report that recovery as restoration of the old
+security state, never as a hardened deployment. After rollback, R3 and second-human access are
+not accepted until prerequisites are restored. Older operator tools cannot manage the new
+flag safely. The window must use the reviewed candidate tool blob for rollback as well.
+
+The Q173 window supplies real uid-denial evidence and the final consumer audit. No second uid,
+live socket, unit, config or secret is touched in this row's tests. Row 190b or a separate host
+still owns cross-instance file isolation. It is not replaced by SSO or this socket change.
+
+## 7. Acceptance tests and mutants
+
+All fixtures use scratch roots and ephemeral sockets, no live 7332/7333, public origin or
+provider. No real second uid. Foreign uid checks use injected metadata and name that limit.
+Use short TMPDIR paths so the longest Unix socket path stays under 108 bytes.
+
+| Test | Required evidence | Mutant killed |
+|---|---|---|
+| T1 private tester | HTTP over scratch socket reads and writes as tester only. parent 0700, socket 0600. No tester TCP listen. Wrong Host/origin and auth cookies refuse | M1 bind loopback TCP as well, M2 remove socket mode check, M3 accept owner cookie |
+| T2 real peer binding | At least 8 concurrent proof connections from distinct scratch client processes, each with its own live proof, plus a copier racing one live CLI. Barrier the helpers so connections overlap. Each genuine call must bind its own peer PID and pass, the copier must refuse. Repeat on Node 24 and 26. A lower-level helper fixture exchanges bytes both ways on the accepted socket after the helper exits, and each real bus call receives its response after helper exit. Helper failure cases all refuse | M4 use proof.pid as peer PID, M5 continue after helper error, M20 give the helper another pending connection's socket |
+| T3 uid/path refusal | Inject foreign peer uid, wrong file owner/modes, symlink parent, existing socket and long path. Inject interpreter script, user-owned ELF, home path, writable ancestor and missing executable. Refuse before dispatch, no repaired paths. Unsafe pid/uid/gid and extra helper output refuse | M6 ignore uid, M7 accept unsafe parent |
+| T4 ancestry | Agent env, binary and registered launch above owner/user refuse. Missing/reused PID, changed parent and cycles refuse. Clean terminal owner works | M8 omit walk, M9 omit identity re-read |
+| T5 Console parent | Direct CLI child from exact tree Console fixture works. Same CLI under shell, other copy, wrapper, agent ancestor or CLI respawn refuses | M10 remove direct-parent check, M11 accept any Console basename |
+| T6 principal shape | No human id or role from request body. Exactly one proof. No returned cap. Disconnect on synchronous and async failure, timeout and close. Tester agent allowed, managed tester refused | M12 accept extra identity, M13 omit disconnect, M14 use tester walk for user |
+| T7 consumer migration | Render/plan/activate/rehearse fixture carries socket flag in unit and pointer. Explicit conversion removes port. Unsupported/inherited mismatch refuses before unit calls. Rollback disables unsupported tester, never opens TCP | M15 keep inherited tester port, M16 restore TCP on downgrade |
+| T8 gates and identity | bus.tester false refuses tester calls. SSO owner/user wiring uses only claims verified for that request's live session. Expired/logged-out or replaced session cannot reuse an earlier mapped id. User kind never becomes owner from its id. R3 integration maps subject, denies missing/invalid grants and owner overlap, broken access file leaves terminal owner working | M17 bypass tester switch, M18 turn user kind into owner by id |
+| T9 isolation limits | Two scratch instances have different sockets and matching tree paths. Foreign-uid stand-in refuses. Record that no real uid boundary was exercised | M19 choose default instance socket |
+| T10 interpreter and cap path | Activation evidence records the same pinned root-owned system ELF that the bus uses. Scripts, home paths and unsafe owners/modes refuse. Simulated OS replacement followed by startup accepts a safe replacement and appends its actual identity without changing the old receipt, refuses an unsafe replacement or unsafe/unwritable receipt. Cap calls complete without invoking the helper, proven with a helper spy that fails if called | M21 bypass interpreter safety, M22 invoke helper for cap traffic, M23 retain stale interpreter identity after restart |
+
+Tests for new policy stay in the bus, WebUI and CLI packages. R3 provides the real user/grant
+half of T8 in its candidate, with its own gate. This row tests the shared verifier's user
+provenance without shipping placeholder user access. Mutants run on scratch copies,
+restore the original bytes and verify hashes. Two failures in a gate run stop and are reported.
+Single test files run freely. Ask Sage for the slot before any suite. Final acceptance is
+Duckworth's approved manifest plus Sage's bus, WebUI, CLI and scripts/test-*.sh gate.
+
+## 8. Closure, limits and review decisions
+
+R1. Same uid remains trusted OS authority. A hostile process may detach, clear its markers,
+modify argv, read same-uid pipes or capabilities, edit policy files, or interfere with the
+Console where host policy permits. SO_PEERCRED proves the connecting process identity at
+connection time. It does not prove human intent, protect memory, or track a socket passed to
+another process. Ordinary agent children fail the walk. Hostile detached agents are not
+claimed contained. Separate uids narrow cross-instance reach, not reach within one instance.
+
+R2. The Console provenance option trusts verified code and process metadata, not an independent
+bus-side OIDC exchange. That trade must be approved, not hidden behind the phrase zero trust.
+
+R3. A Unix tester endpoint removes direct browser navigation. No bridge is in this design.
+The 7331 development board remains a separately reported reachability and impersonation risk.
+
+P19 333 can record the following after the implementation gate and authorized re-pin:
+"Tester ingress is private to the instance uid. Bus human proofs are tied to the actual
+Unix peer and retain the human walk. Session-user calls require the same-tree Console as
+direct parent. Q175 phase 2 separately protects main Console ingress with verified OIDC.
+Hostile processes on the instance uid, root, and the independent development control board
+remain outside these guarantees. Cross-instance file isolation requires the uid/host gate."
+
+Duckworth requires that P19 333 also carry R2 word for word:
+"The Console provenance option trusts verified code and process metadata, not an independent
+bus-side OIDC exchange. That trade must be approved, not hidden behind the phrase zero trust."
+
+Do not mark the historical task fully closed on a design or commit. Closure needs live
+Q175 phase 2, this row's re-pin and the recorded residual accepted through Mos. A promise of
+hostile same-uid isolation would require separate OS authority for agents and a new design.
+
+Review receipt: duckworth-0006, notes at `86be181a2:agents/duckworth/work/row196/REVIEW.md`.
+Q1 selects O1 with the conditions incorporated in section 5. Q2 approves Console provenance
+with the live-session and unchanged P19 R2 conditions. B1 adds concurrent T2, M20 and socket
+survival checks. N2's detached-Console limit remains in R1. N3's gid validation and N4's
+operator window warning are included. Mos's tester-access ruling is recorded above. No
+product code begins before design approval.
+Duckworth approved revision 2 in duckworth-0009, review at
+`cb6d840df:agents/duckworth/work/row196/REVIEW-r2.md`. N5 permits either restart policy.
+Revision 3 selects safety revalidation with a new append-only startup receipt, and gives the
+operator a re-pin path that respects the existing already-active refusal.

agents/gander/work/queue-196/MANIFEST.md

@@ -0,0 +1,121 @@
+# Row 196 review manifest
+
+Status: draft, not an acceptance claim. Candidate product files are uncommitted.
+Base: 4d26003f731a6eec439df6a48cacc3ef482a59c8. Design r3 approved by
+duckworth-0009/0015 and sage-1371. No merge, deployment or live re-pin requested.
+Current path hashes are in PRODUCT-FILES.json, marked as an uncommitted draft.
+Final candidate commit, exact changed-file hashes and gate totals follow after
+the renewed suite slot. Sage owns that slot and the final gate. Duckworth reviews
+this manifest before Sage's gate.
+
+## Review items
+
+| Item | Change and acceptance evidence | Mutants |
+|---|---|---|
+| Kernel peer proof | `bus/src/peercred.py` obtains SO_PEERCRED from inherited fd 3. `peercred.mjs` owns the accepted Socket in each connection closure, bounds helpers and validates all three safe integers. `peercred.test.mjs` overlaps eight distinct callers plus a copier and checks traffic after helper exit. | M4, M5, M20 |
+| Interpreter trust | `bus/src/interpreter.mjs` resolves fixed system Python, checks root ownership, safe ancestors, ELF and version, and refuses home paths or shims. Startup appends actual identity; activation compares the fresh receipt. `interpreter.test.mjs` covers safe replacement and unchanged older receipt. | M21, M23 |
+| Startup FIFO refusal | Receipt opens include O_NONBLOCK before fstat, avoiding an indefinite FIFO open. `interpreter.test.mjs`, `non-regular startup receipt refuses promptly without waiting on a FIFO peer`, was RED by timeout, then GREEN. Evidence: `evidence/interpreter-fifo-red.txt`, `evidence/interpreter-green.txt`. No live receipt was used. | M25 removes O_NONBLOCK |
+| Missing helper refusal | Reader construction refuses missing, symlink or non-regular peer helper before opening the broker socket. `peercred.test.mjs`, `missing or non-regular peer helper refuses at construction before opening the bus`, was RED, then GREEN. Evidence: `evidence/peer-helper-red.txt`, `evidence/peercred-green.txt`. | M26 removes helper preflight |
+| Helper shutdown | Reader close kills and awaits helper close events; server close awaits it. `peercred.test.mjs`, `shutdown waits for killed helper close before returning`, was RED, then GREEN. Evidence: `evidence/peer-shutdown-red.txt`, `evidence/peercred-green.txt`. | M27 returns without waiting |
+| Shared principal | `bus/src/principal.mjs` checks kernel uid/PID, retains the human walk, separates nonce kinds and requires the exact same-tree Console serve direct parent for users. `principal.test.mjs` supplies process-table refusals. User id is provenance only; R3 owns mapping, grants and user dispatch. | M6, M8-M12, M14, M18 |
+| Request lifetime | `bus/src/server.mjs` runs the helper only for proof envelopes and releases transient caps for sync/async success, refusal, timeout and close. `peer-transport.test.mjs` tests cleanup and fails if a cap request invokes the helper. | M13, M22 |
+| Private tester ingress | `webui/src/tester-socket.mjs` owns 0700 console directory and 0600 socket; `serve.mjs` preserves tester policy and refuses sign-in headers/cookies. `tester-socket.test.mjs` covers unsafe paths, origin/Host, instance separation and HTTP access. | M1-M3, M7, M19 |
+| Owned inode cleanup | sage-1382 selects temporary bind, rename to final, conditional final dev/ino cleanup. `tester-socket.test.mjs` asserts temporary name absent after bind/close and replacement final inode survives close. Scratch proof and remaining same-uid race are in BUILD.md. | M24 binds final directly |
+| Tester policy | `bus.tester` remains Jason's switch. Existing `tester.test.mjs` verifies refusals. No user widening, new browser relay or control-board change. | M17 |
+| Consumer migration | WebUI CLI, service rendering, release plan/activation/rehearsal and CLI Unix HTTP helper carry explicit --tester-socket. Inherited TCP on a new target refuses before stop without explicit conversion. Unsupported rollback disables tester and reports it. Focused service/release/tester HTTP files cover these paths. | M15, M16 |
+| Proof pair ordering | Conversion plus an explicit proof pair keeps pointer and unit argv in the same order: preview, proof pair, tester socket. The focused row196 release test was RED with the old insertion scan, then GREEN after including --tester-socket in its stop list. The proof-file no-read check also passes. Evidence: `evidence/release-proof-order-red.txt` and `evidence/release-proof-order-green.txt`. | M28 omits socket from the insertion boundary |
+| Path preflight before stop | Activation checks the final Unix pathname byte length and any existing parent directory's type, owner and mode before stopping units. The row196 release case reproduces a too-long path reaching service stops, then verifies length and unsafe-parent refusals leave start/stop calls unchanged. Evidence: `evidence/release-path-red.txt` and `evidence/release-path-green.txt`. | M29 removes the preflight |
+| Browser fixture migration | Test-only CDP interception fulfills synthetic-origin requests from the scratch Unix listener. No TCP listener or product relay. `tester-browser.test.mjs` is 2/2 after the fixture repair, accepted in sage-1409. Evidence: `evidence/tester-browser-focused.txt`. | Product transport removal is covered by M1; browser fixture itself is tested by its two cases. |
+
+All package paths above are under `packages/`. Mutants are prepared in
+`mutants.mjs` but none have run as of this draft. Their kill and restoration
+receipts must be attached before acceptance. M25-M29 supplement design M1-M24.
+
+## Separate row164 proof baseline update
+
+Duckworth should review this hunk separately, as requested in sage-1409.
+Only two baselines in `packages/bus/tests/channel-proof.test.mjs` change.
+
+| File | Previous sha256 | Candidate sha256 | Why |
+|---|---|---|---|
+| `packages/bus/src/human.mjs` | `b995fc5cff3af8ade4c990d0e3bebf9d83829e00f034ebc9c3dcfd05f252b573` | `0c6d96abe4607cba0b02b0638a2fc217ff8135bac9a47761a0ef015fbe9d3079` | Read the distinct user nonce and parameterize the existing path-bound human walk for the shared verifier. |
+| `packages/webui/src/bus.mjs` | `76a1b57858c4aa41071746713a196299264851c18322a6f9869d553f0362d421` | `934ab2f9b6bde72aafe7814758550c283eb25a4f3a23b284021b13718d67178f` | Supply the initial owner CLI nonce at spawn and map peercred-required to HTTP refusal. |
+
+The human-cli and CLI transport hashes stay fixed. Literal shim path recovery,
+forged-proof refusal and the channel plug-in proof-caller import ban remain tested.
+Focused evidence: `evidence/channel-proof.txt`. These hashes must be checked again
+against the final candidate before review.
+
+## Consumer inventory and window
+
+Tester tools use `packages/cli/src/tester-http.mjs` and the selected instance's
+console/tester.sock. WebUI tester test fixtures and browser fixtures use scratch
+Unix sockets. The stack-release gate and rehearsal carry --tester-socket and
+compare the bus startup interpreter receipt. Package READMEs and docs/TOOLS.md
+show the Unix path and explicit migration. Direct browser access is lost by
+Mos's accepted ruling mos-1015; a future SSO relay needs its own row. Name that
+loss to Jason in the authorized window. No candidate is live from this work.
+
+The 7331 development control board is inventory only. Its reads, /api/reply
+writes and reachability remain the separate boundary described in DESIGN.md.
+Row 190b remains on hold; this work does not isolate hostile same-uid processes.
+
+## Gate history and remaining evidence
+
+Run 1: bus 463 pass, one byte-baseline failure. Run 2: bus 464 pass; WebUI
+stopped at its second fixture migration failure, with 269 observed top-level
+passes and no final summary. CLI and mutants did not start. Sage received clear
+in gander-0023. No timing failures were attributed to Launchpad's T56 overlap.
+The two browser failures were repaired and verified in a single file.
+
+sage-1416 delays the renewed slot until Launchpad, Darkwing, Rocko and row 192
+finish. No suite or mutant batch starts before Sage's go. Remaining: final
+bus/WebUI/CLI suites, M1-M29 receipts, final changed-file hashes,
+verified candidate commit/push, Duckworth
+manifest review and Sage's gate. No approval is implied by this draft.
+
+Node 24 focused reruns after the shutdown change are complete: peercred 5/5 and
+principal 4/4. Node 26 peer-transport now passes 4/4, including client-visible
+refusal codes. Full logs are in evidence/.
+
+## Refused caller behavior and static review
+
+The verifier path is changed by this row. A completed proof refusal returns an
+explicit protocol error before closing the connection: `human-required` for a
+rejected human proof and `peercred-required` for helper failure. The real Client
+receives those codes in `peer-transport.test.mjs`, without broker dispatch. No
+client code is changed. Abrupt close, transport error or timeout without a valid
+response still reports `outcome-unknown`; this row does not convert that case.
+
+Quackerjack's reported failed-proof close was not reproduced against this branch's
+base. A scratch comparison loads HEAD's server and the candidate with the same
+refusing authenticator and unchanged Client. Both return `human-required`.
+Evidence: `evidence/refusal-baseline-comparison.txt`. This comparison does not
+claim to reproduce Quackerjack's exact process ancestry or instance. The manifest
+therefore claims the explicit codes only for the paths verified here.
+
+Static review covered peer reader and shutdown, runtime startup and failure
+cleanup, principal/walk dispatch, tester bind/close, Console spawn, Unix client,
+release conversion/recovery/preflight, unit rendering and test fixture changes.
+It found the shutdown, proof ordering and preflight defects recorded above.
+Each has a focused test and prepared mutant. An unrelated change to legacy
+tester-port-invalid text was also removed to preserve the existing contract.
+No further implementation changes are planned before the authorized batch.
+
+## Limits carried to acceptance
+
+No real second uid or live instance is exercised. Foreign uid metadata is a
+stand-in. The authorized window still owns real uid-denial and consumer audit.
+Python is a new bus-host dependency; the worker Containerfile is unchanged.
+Restarts validate the current interpreter and append a receipt; old receipts
+are preserved. Interpreter changes use the next reviewed copy and preserve
+the already-active refusal.
+
+Hostile same-uid processes can read or alter same-uid state, detach or interfere
+with pathname checks and Console provenance. Separate uids narrow cross-instance
+reach, not reach within one instance. R3 must source the proof id only from
+claims verified for that request's live session and reread grants per request.
+P19 333 must retain this text unchanged:
+
+The Console provenance option trusts verified code and process metadata, not an independent
+bus-side OIDC exchange. That trade must be approved, not hidden behind the phrase zero trust.

agents/gander/work/queue-196/PLAN.md

@@ -0,0 +1,121 @@
+# Row 196 Human Boundary Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox syntax for tracking.
+
+**Goal:** Bind human proofs to their actual Unix peers and make tester HTTP private to the instance uid.
+
+**Architecture:** The bus reads kernel credentials through a pinned system Python helper only for proof envelopes. One principal verifier keeps the human walk and supplies Console provenance for federation R3. Tester HTTP moves to a private filesystem socket. Release tools migrate the flags explicitly.
+
+**Tech Stack:** Linux, Node 24 and 26, Python >=3.10 standard library, existing Node test runner and shell release tools.
+
+**Spec:** `agents/gander/work/queue-196/DESIGN.md`, approved r2 at 5fe259f16, with N5 restart policy added in r3.
+
+## Global Constraints
+
+- Work in the existing gander/row196 worktree. Plain node_modules symlink. No new package dependency.
+- No live files, credentials, listeners, units, second uid or external authentication service.
+- Helpers: proof envelopes only, at most 16 concurrent, one second timeout, 256-byte strict output.
+- Root-owned system Python ELF at resolved /usr/bin/python3, never PATH or a home/shim path.
+- console/ 0700, tester.sock 0600, Unix pathname at most 107 bytes.
+- One principal and transient cap per request. R3 owns user access policy and user-cli integration.
+- Mos accepted socket-only tester access. No TCP relay or control-board change.
+- Single test files run freely. Ask Sage before any suite. Stop and report two failures in a gate run.
+- Commit code only after applicable suites pass. Sage owns the final gate and manifest queue moves.
+
+## Review Focus
+
+- Connection overlap and disconnect: helpers must retain the correct Socket object and release capacity on every exit.
+- OS interpreter replacement: restart records the actual safe binary, while old receipts remain unchanged.
+- Long or unsafe instance paths: refuse before binding or stopping any service.
+- Rollback/recovery: distinguish intentional tester disablement from restoration of an old saved TCP unit.
+- CLI nonce respawn and session expiry: direct-parent provenance must survive correct Console spawning and refuse stale identity.
+
+## Task 1: kernel credentials and interpreter evidence
+
+Files: create `packages/bus/src/peercred.mjs`, `packages/bus/src/peercred.py`,
+`packages/bus/src/interpreter.mjs`; tests in `packages/bus/tests/peercred.test.mjs` and
+`packages/bus/tests/interpreter.test.mjs`, with subprocess fixtures under `packages/bus/fixtures/`.
+
+Interfaces: `inspectInterpreter()` returns a validated immutable record of path, version,
+device, inode and sha256. `recordInterpreterStart(directory, record)` appends the actual startup
+identity safely. `createPeerReader({interpreter})` returns `{read(socket),close()}`. read resolves
+to `{pid,uid,gid}` from that exact socket, or refuses. Test-only injected OS/process operations
+do not become product flags or environment overrides.
+
+- [ ] Write interpreter safety, receipt replacement and cap-independent helper tests (T3/T10).
+- [ ] Run each new test file alone and record the expected missing-module failures.
+- [ ] Implement system interpreter validation and startup receipt append with no-follow, owner/type/mode checks.
+- [ ] Write T2's eight-process barrier plus racing copier, wrong-fd case and post-helper socket exchange.
+- [ ] Implement fd-3 helper, strict result validation, bounded async reader and helper shutdown.
+- [ ] Run `node --test packages/bus/tests/interpreter.test.mjs` and separately `node --test packages/bus/tests/peercred.test.mjs`.
+- [ ] Confirm process/socket cleanup, eight distinct kernel PIDs, copier refusal and original receipt preservation.
+
+## Task 2: principal provenance and bus dispatch
+
+Files: modify `packages/bus/src/{human,tester,server,runtime}.mjs`, create
+`packages/bus/src/principal.mjs`, add `packages/bus/tests/principal.test.mjs`, and extend
+`packages/bus/tests/human.test.mjs`. Extend server/runtime test files after inspecting their fixtures.
+
+Interfaces: `verifyPrincipal(request, {peer,...trustedPathsAndProcessReaders})` returns
+`{kind,business,id}`. Human maps to the business human, tester to tester, user to its verified
+Console proof id. No roles or grants. Server obtains peer metadata from Task 1 only after
+envelope validation and only for proofs. Existing cap dispatch never invokes the helper.
+Future user binding stays refused without R3's trusted integration.
+
+- [ ] Write T4/T5/T6/T8 process-table tests, including changed ancestry, distinct nonce namespaces and kind confusion.
+- [ ] Run the focused new file and confirm expected failure before implementing the verifier.
+- [ ] Parameterize the nonce/path portion of the existing human walk and retain all marker/binary/launch checks.
+- [ ] Wire peer metadata, interpreter startup receipt and one-request cleanup into runtime/server.
+- [ ] Test cap requests with a failing helper spy (M22), and test async refusal/close cleanup.
+- [ ] Run each affected bus test file alone. Record any base fixture changes needed for real peer identity.
+
+## Task 3: tester Unix HTTP and Console nonce spawning
+
+Files: modify `packages/webui/src/{cli,serve,bus}.mjs`, create
+`packages/webui/src/tester-socket.mjs` and `packages/cli/src/tester-http.mjs`; add focused
+`packages/webui/tests/tester-socket.test.mjs` and `packages/cli/tests/tester-http.test.mjs`.
+Extend existing WebUI transport tests.
+
+Interfaces: `startTesterSocket({dataRoot,...handlerOptions})` owns the private listener and
+cleanup. `testerRequest({dataRoot,method,path,body})` uses the fixed logical origin and bounded
+Unix HTTP. Console human child spawning supplies its initial nonce, preserving agent markers.
+R3 reuses that spawn pattern for its user-cli.
+
+- [ ] Write T1/T3/T9 socket permission, unsafe-path, wrong-origin and instance separation tests.
+- [ ] Confirm the new focused files fail, then implement --tester-socket and refusal of --tester-port.
+- [ ] Keep tester principal, write allowlist and cookie/header refusals intact. Add no browser relay.
+- [ ] Write and implement the initial-nonce Console spawn test and the helper request timeout test.
+- [ ] Run each new or changed test file alone, verifying cleanup and no tester TCP bind.
+
+## Task 4: release migration and operator evidence
+
+Files: modify `scripts/{webui-service,stack-release}.sh`, inspect
+`scripts/stack-copy.sh` closure, extend `packages/cli/tests/stack-release.test.mjs` and its
+render fixtures. Update `docs/TOOLS.md` and package READMEs with the implementation.
+
+Interfaces: `activate ID BUSINESS --tester-socket` explicitly replaces inherited tester-port
+flags. Pointer and unit argv agree. Candidate support and interpreter preflight run before
+any unit stop. Activation gate evidence records the same interpreter as the bus startup receipt.
+
+- [ ] Write T7 explicit conversion, inherited mismatch and unsupported-target refusal fixtures.
+- [ ] Run only the affected test file, then implement flag rendering, plan output and rollback disabling unsupported tester.
+- [ ] Preserve old-copy recovery behavior and report restored old security state accurately.
+- [ ] Add rehearsal scratch socket and T10 interpreter gate identity comparison.
+- [ ] Verify same-copy activation refusal is preserved. Document N5's next-reviewed-copy re-pin path.
+- [ ] Run the affected file alone, shell syntax checks, and inspect remaining tester-port references by purpose.
+
+## Task 5: mutants, approved suites and manifest
+
+Files: add the row's mutation runner and receipts under `agents/gander/work/queue-196/`.
+Append BUILD-LOG phase receipts. No SESSIONS or queue file edits.
+
+- [ ] Exercise M1-M23 against isolated scratch copies. Record killer test, restored hash and cleanup for each.
+- [ ] Run focused tests on Node 24 and 26, including the concurrent T2 case and socket lifetime checks.
+- [ ] Send Sage the scope and estimated duration, obtain the suite slot, then run approved bus/WebUI/CLI suites.
+- [ ] Let Sage own the scripts/test-*.sh gate. Stop on the repository's two-failure rule.
+- [ ] Build the exact changed-path manifest with acceptance evidence, search results, limits and consumer audit.
+- [ ] Commit/push the verified candidate only after applicable suites pass. Send Duckworth and Sage path, commit and hashes for manifest review.
+
+Execution stays with Gander in this worktree. No new agent delegation. Duckworth reviews
+the manifest independently. Push is only to gander/row196. No merge, re-pin or deployment
+is authorized by this plan.

agents/gander/work/queue-196/PRODUCT-FILES.json

@@ -0,0 +1,186 @@
+{
+  "status": "uncommitted draft; regenerate after final tests",
+  "base": "4d26003f731a6eec439df6a48cacc3ef482a59c8",
+  "files": [
+    {
+      "path": "docs/TOOLS.md",
+      "baselineSha256": "5bd1bc697cd56e57b00e60c0e80be72cd1043a55a6d2fc0b9e2ccdd0c5cf9802",
+      "candidateSha256": "7eba3f1ac2e5a159c9c764f1c3e4f6fdfaf06d2904cdc36338723d5ddd9044c8"
+    },
+    {
+      "path": "packages/bus/README.md",
+      "baselineSha256": "4377cc32aed37fa1bb645c0bbc3340eed4ec01740e67327449949474e35d3fdb",
+      "candidateSha256": "becff52b647f28079d2756b26a7e46e28f14b695f57b2dede779e7cb43af3d96"
+    },
+    {
+      "path": "packages/bus/fixtures/peer-client.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "60720461a7994011a9a30594715eb2c992be699cd61c656e77cbd609ad05328e"
+    },
+    {
+      "path": "packages/bus/src/human.mjs",
+      "baselineSha256": "b995fc5cff3af8ade4c990d0e3bebf9d83829e00f034ebc9c3dcfd05f252b573",
+      "candidateSha256": "0c6d96abe4607cba0b02b0638a2fc217ff8135bac9a47761a0ef015fbe9d3079"
+    },
+    {
+      "path": "packages/bus/src/interpreter.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "d5d98a9133a1b449acc48143fd559d890a470c6ea210b30b9b70e491e6cd855a"
+    },
+    {
+      "path": "packages/bus/src/peercred.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "29c88655e8b9aed8db604573c9213fd9f3c40ef35ff04f4eda8fbe8f1b8a32d7"
+    },
+    {
+      "path": "packages/bus/src/peercred.py",
+      "baselineSha256": null,
+      "candidateSha256": "d1536a8f472fa5b3773adb10555529ed049ad63b647c0b44c00ce5f25ce09f85"
+    },
+    {
+      "path": "packages/bus/src/principal.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "32ef39d80b523bdd586c29620d7a752c309c8e1aa70befc1414125468f3411dd"
+    },
+    {
+      "path": "packages/bus/src/runtime.mjs",
+      "baselineSha256": "fe70f4b6568fbfec85e58d34f3cb8c3624daba65487d73ad24e981f2121cb27a",
+      "candidateSha256": "e001bdba127fc6e7a6e95ef1864e661b2842f3c797169ab0a6ccaa5e2cd7da00"
+    },
+    {
+      "path": "packages/bus/src/server.mjs",
+      "baselineSha256": "8a1b8eac60a5885bbfd36f939b63443de303ed298bf9e1ff653a5a7bcbae76d2",
+      "candidateSha256": "a5788c0a0b2b78de5eb2111a47c475e100cbb0e2eca4b601e7f027cac2c56d7e"
+    },
+    {
+      "path": "packages/bus/tests/channel-proof.test.mjs",
+      "baselineSha256": "98f12f509f0e292fa0b0e3924834f9d0f285c08ea5c4d22057566c49e2bd6c68",
+      "candidateSha256": "e99133c3c957a1e856e404343721add2430e4a0d8c75452517aef04942af56ab"
+    },
+    {
+      "path": "packages/bus/tests/interpreter.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "d19779b97e80ed3d62f58d0e798df46c23f45fa02b14fb4ac7a2ff4690a734e2"
+    },
+    {
+      "path": "packages/bus/tests/peer-transport.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "a39af877a2d9143cc8d0584af0d603ca7ab651db8787e5816579762f17295887"
+    },
+    {
+      "path": "packages/bus/tests/peercred.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "2c4c0bed41e546ce94535d8c4547b1cf5552a181183525dd1d52e2af1d64ccb6"
+    },
+    {
+      "path": "packages/bus/tests/principal.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "cefbc0688d823c69196d94bb71467884acd639070721286d7e8e4e986c8240c1"
+    },
+    {
+      "path": "packages/cli/README.md",
+      "baselineSha256": "2c9f8fe7143aa80e59826ab53bd046de2b5e0a8f3e81fe4e3df77726bb54d50b",
+      "candidateSha256": "23f4c767a67b358025f0d035d2a676e14e335478c480bc44a5c303066c40709c"
+    },
+    {
+      "path": "packages/cli/src/tester-http.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "4bd7bdf0898844684ebf9444b110d2c5b6fa874b2681183e54f1f62f97823192"
+    },
+    {
+      "path": "packages/cli/tests/stack-release.test.mjs",
+      "baselineSha256": "b01ff656962c6fdb5bc3554cfbb13645b7f25adae5f6cd9608af8de6d6091c6c",
+      "candidateSha256": "4c92b7cc7c4b942a1bbb9a9e24c7c1ef10e23d3f9d166bee98ed1b7f6b8de4b0"
+    },
+    {
+      "path": "packages/cli/tests/tester-http.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "fbaa36e64129aee324341364bde831c379c098b97932cceadb7fcaa7909d4b20"
+    },
+    {
+      "path": "packages/webui/README.md",
+      "baselineSha256": "78c7b60d23cf20863a1cb66e16af2f9363d08acc79c5b4a344cd8af4fbe5bd44",
+      "candidateSha256": "8bf41140a0c013a3d77757b66e442d46c278cf8eb0f54ac26b4e477e8265279b"
+    },
+    {
+      "path": "packages/webui/src/bus.mjs",
+      "baselineSha256": "76a1b57858c4aa41071746713a196299264851c18322a6f9869d553f0362d421",
+      "candidateSha256": "934ab2f9b6bde72aafe7814758550c283eb25a4f3a23b284021b13718d67178f"
+    },
+    {
+      "path": "packages/webui/src/cli.mjs",
+      "baselineSha256": "4f988333ec6af225a023323dda85a159b81a77f408a8dd7bff798fe9a1f4b24b",
+      "candidateSha256": "fbe9db9352300fb969aa889e40323c61b1a51d01f63434964be0a8c530240e50"
+    },
+    {
+      "path": "packages/webui/src/serve.mjs",
+      "baselineSha256": "ba7d3e35b225cb4e17a4d2530a0f34d0a3734641e3982229a38207a36b3cd433",
+      "candidateSha256": "894bdb260af418bef7ca9dac5dd19541ca898d6f946ed12fa832bc3475234709"
+    },
+    {
+      "path": "packages/webui/src/tester-socket.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "1c1fe0c795adac97f28502564a75f26d5666d9be5ae51169f7dd5bb7741fad16"
+    },
+    {
+      "path": "packages/webui/tests/browser.mjs",
+      "baselineSha256": "1e70a0175f1d660f6b71449a1423ece83fbe8332108960fa9aff6f7a5e48022a",
+      "candidateSha256": "2f3ea92cbe1ca115301ee1e3b8fc55a206842606237446b700881ee57a1b18cb"
+    },
+    {
+      "path": "packages/webui/tests/proof-cli.test.mjs",
+      "baselineSha256": "c23975b140ed977f3b98dbbec5de289e9f930cc42089193c4aa7c106338a68ba",
+      "candidateSha256": "105cf4936db0498d0c0025698c7ee33ddce9530b43f6c829b77afdbcb3075207"
+    },
+    {
+      "path": "packages/webui/tests/proof.test.mjs",
+      "baselineSha256": "c06a1e673ef6f3df8f0473692c828aeba853369d2b668e821f1d41e6340b6503",
+      "candidateSha256": "5f34d699a1bce6f46f286def1a93fdd4d863d06bec6839677fae1041be7153dd"
+    },
+    {
+      "path": "packages/webui/tests/service.test.mjs",
+      "baselineSha256": "424be2837a18a41eab56b0deb576e35b460ac16b8c371762ad44896ffc3aad7d",
+      "candidateSha256": "2304ced2473c25b0369b4bb9b1433c1be3ee9ab8a6f75c971487abcd48cb1d1b"
+    },
+    {
+      "path": "packages/webui/tests/tester-browser-fixture.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "9215ff92df774ba1e83819b87f758b53c8f3d19c2824c916490165914f1cb9e8"
+    },
+    {
+      "path": "packages/webui/tests/tester-browser.test.mjs",
+      "baselineSha256": "3cc6def0c8cfb6cf7bb91a52df6e57f18071549588b35394e0083f7dc938dacf",
+      "candidateSha256": "89ffc5cbed1630a523080e8561d3678c1f781fb657199a5cd6cdb8189f082c73"
+    },
+    {
+      "path": "packages/webui/tests/tester-cli.test.mjs",
+      "baselineSha256": "dd74517b336e1670a5910481920ba875ffb004d52d8c6bee7cc5efc81e43215d",
+      "candidateSha256": "a5c6c95dbda75dce37d38d3ce4761d3ad576babd9304a046e9a62b1b5dc2fdfd"
+    },
+    {
+      "path": "packages/webui/tests/tester-fixture.mjs",
+      "baselineSha256": "2169803c50815d214cab120eaa9d1542aa3b96bfe4738d68307eb0b92c1213f3",
+      "candidateSha256": "7d4f3a59d21675807b1bfb92d40b7378134df450590bc6d42fa4103ab1343348"
+    },
+    {
+      "path": "packages/webui/tests/tester-listener.test.mjs",
+      "baselineSha256": "aed4cec37401bc7953b1a872349ed77c70210fcfb75ebf6d4e881a393f92c7e9",
+      "candidateSha256": "7f0fc2daead11048cb86e0a74b6a223314785b1740a2927461d012b876a69f18"
+    },
+    {
+      "path": "packages/webui/tests/tester-socket.test.mjs",
+      "baselineSha256": null,
+      "candidateSha256": "c01a942da1ad66a08a4e7c92d3c7e64f517530acfe5517f1e9895767d5ea3c0b"
+    },
+    {
+      "path": "scripts/stack-release.sh",
+      "baselineSha256": "5bb3ac40102ce515f1acdcbc5670feb161ce40a193e94e2f8b104ebf98eddc38",
+      "candidateSha256": "59b39d63feb77f22abb4b7152c18feff53715cf3a10dde6374c69615329868c7"
+    },
+    {
+      "path": "scripts/webui-service.sh",
+      "baselineSha256": "d514caf757c03e5d02ef39b19359669bd2476dca1877f5d237c65bd62c33d2bf",
+      "candidateSha256": "67cc347231d4410acf0fd845bde58aeabf099d1d6cf3e36efda4db66c5438c10"
+    }
+  ]
+}

agents/gander/work/queue-196/PROGRESS.md

@@ -0,0 +1,20 @@
+# Row 196 execution ledger
+Plan: agents/gander/work/queue-196/PLAN.md
+Base: 4d26003f7. Build authorized by sage-1371, mos-1021 item 2 and mos-1023 item 3.
+Pre-flight: Task 1 supplies peer reader and interpreter evidence to Task 2 and release gate in Task 4. Task 2 supplies principal provenance; R3 supplies user policy. Task 3 supplies tester transport to Task 4. Interfaces match approved design.
+Ruling: retain this repository packet as the ledger instead of adding a root .superpowers directory, honoring bootstrap-only root. No code commits before applicable suites pass; Duckworth is the independent manifest reviewer. Suites and mutant batches require Sage slot.
+Task 1: in progress.
+Task 1: interpreter tests RED missing module -> GREEN 3/3; peer reader RED missing module -> timeout diagnosed: Node spawn stdio pauses Socket -> explicit caller resume -> GREEN 3/3. Concurrency test observed nine distinct peers, eight accepted, copier refused, post-helper bidirectional traffic. No suite/commit yet.
+Task 2: principal RED missing module -> GREEN 3/3; existing human 4/4, peer-transport RED -> GREEN 2/2, transport 5/5, tester 14/14, process 8/8, all individual files. Runtime records interpreter and supplies kernel peer to shared verifier; cap traffic does not spawn helper.
+Task 3: BLOCKED by design contradiction, reported gander-0016/0017 at 2026-10-20T19:34:28Z. Node/libuv closes Unix listener by unlinking its pathname even after replacement inode. Scratch cleanup assertion reproduces; conditional JavaScript cleanup is too late. Tester module not wired into serve. Recommend explicitly accepting same-uid pathname replacement as residual under private-parent boundary. No product commit, suite or mutant batch.
+Task 3 resumed: sage-1382 selected Duckworth option 1. Temporary bind -> rename -> conditional final inode cleanup implemented. Replacement survival and absence of temporary name RED -> GREEN. M24 is bind-final-directly. Remaining same-uid lstat/unlink race recorded in BUILD.md. No design weakening.
+Gate run 1 bus: 463 pass, 1 fail, no other packages started. Failure was row164 byte baseline, which already records intentional re-pins in later rows. Ruling: update only human.mjs and webui bus.mjs pins because their approved row196 changes are intentional, preserving the other two pins, literal entry-path tests and plug-in import ban. This does not bypass a policy refusal or weaken the proof walk.
+Gate run 2: bus 464/464 pass. WebUI stopped on second failure: tester-browser.test.mjs still constructed TCP URLs using Unix address().port. 269 top-level passing cases observed, 2 failed, final suite summary unavailable due interruption. CLI and M1-M24 not started. Not timing failures. Sage notified clear in gander-0023. Node24 peer 3/3 and principal 4/4 passed. No suite/mutant rerun without renewed slot. Next: migrate scratch browser fixture without adding a product relay.
+Focused repair after gate stop: tester-browser 2/2 GREEN using CDP request interception and real scratch Unix HTTP, no TCP listener or product relay. Self-review added FIFO startup-receipt refusal (RED timeout -> GREEN) and helper file preflight (RED no refusal -> GREEN). interpreter 5/5 and peer 4/4. Renewed slot requested gander-0024; suites and mutant batch still stopped.
+sage-1409 accepts the fixture repair and requires separate manifest items for the row164 hashes and startup refusals, each with tests and mutants. sage-1416 delays the slot about an hour; no suite or mutant batch before go. Draft MANIFEST.md and PRODUCT-FILES.json prepared. M25 FIFO, M26 helper preflight and M27 helper shutdown are prepared, not executed. Gander-0025 reports the planned M1-M27 batch.
+Focused shutdown check: peer reader now awaits killed helper close events and server close awaits the reader. peer-shutdown-red.txt records the failing assertion, peercred-green.txt the 5/5 result. Final focused Node24 reruns: peercred 5/5, principal 4/4. Node26 peer-transport 3/3 after async reader close. git diff --check clean. These are single-file checks, not renewed suite acceptance.
+Consumer audit found proof insertion missed the new socket flag, making pointer and rendered unit argument order disagree. Focused row196 release fixture extended with preview + explicit proof: RED exact-order mismatch -> GREEN 1/1 after adding --tester-socket to the insertion boundary. Existing proof-file no-read check passes. Evidence release-proof-order-{red,green}.txt. M28 prepared for that boundary. Final planned mutant batch M1-M28; none executed. Shell syntax and diff whitespace checks pass.
+sage-1425: complete static self-review before slot, document refused caller outcome. Real Client test now verifies human-required for proof refusal and peercred-required for helper failure, without dispatch; peer-transport 4/4. Scratch HEAD-vs-candidate comparison returns human-required in both. Quackerjack's exact failing instance is not reproduced; client.mjs unchanged and abrupt close still outcome-unknown. Manifest states the limit.
+Static review complete: peer/helper lifecycle, runtime, verifier walk, tester socket, Console spawn, Unix client, release/recovery/preflight and fixtures inspected. Found release path preflight missing before stop: long-path fixture RED -> GREEN with preflight; unsafe parent also refuses before any stop. release-path-{red,green}.txt. M29 prepared. Restored unchanged legacy tester-port-invalid wording. Prepared batch now M1-M29, still unexecuted. No further implementation changes planned before Sage's go.
+sage-1464 (2026-10-20T20:40Z): renewed bus/WebUI/CLI and M1-M29 slot is fifth, after rows 192, 201, 204 and 200. Continue holding until Sage's go. Fleet notice #426(a), mos-1086, live 20:32:55Z: no branch deletion; any rebase must use a new branch name; leave pr-merge.sh -d off. No rebase or deletion is planned for this row.
+sage-2051 / mos-1193 (2026-10-21T18:45Z) explicitly orders committing and fast-forward pushing the current row196 build before its deferred full verification, then rebasing onto a36523713 on new gander/row196-r2. This supersedes the earlier no-product-commit-before-suite gate for this preservation commit only. Full acceptance remains pending. No tests until Sage says clear. Subsequent batch order: M1-M29, bus, WebUI, CLI, every whole scripts/test-*.sh; TMPDIR must be created with mktemp under /mnt/storage/scratch/tmp, never /tmp. Preserve the old branch. Row252 design may proceed while waiting; no row252 code before Webby approves.

agents/gander/work/queue-196/evidence/channel-proof.txt

@@ -0,0 +1,10 @@
+✔ channel conversion preserves the four proof/transport byte baselines and modules cannot import a proof caller (0.85226ms)
+✔ channel recovery still requires the same shim path and rejects an absent or forged proof (308.49278ms)
+ℹ tests 2
+ℹ suites 0
+ℹ pass 2
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 389.108211

agents/gander/work/queue-196/evidence/human.txt

@@ -0,0 +1,12 @@
+✔ human proof binds CLI entry, process start and nonce; agents and incomplete ancestry refuse (2.430093ms)
+✔ process reader gets own kernel identity without exposing environment values (0.499236ms)
+✔ EACCES ancestor environments skip only markers; commands and registered launches still refuse (0.651712ms)
+✔ real pid 1 remains inspectable when its environment is protected (0.268904ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 4
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 60.373844

agents/gander/work/queue-196/evidence/interpreter-fifo-red.txt

@@ -0,0 +1,28 @@
+✖ non-regular startup receipt refuses promptly without waiting on a FIFO peer (1008.229518ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 1059.700302
+
+✖ failing tests:
+
+test at packages/bus/tests/interpreter.test.mjs:69:1
+✖ non-regular startup receipt refuses promptly without waiting on a FIFO peer (1008.229518ms)
+  AssertionError [ERR_ASSERTION]: unsafe FIFO must refuse without blocking startup
+  
+  null !== 0
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/interpreter.test.mjs:75:9)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: null,
+    expected: 0,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/interpreter-gate-red.txt

@@ -0,0 +1,21 @@
+✔ system Python is a resolved root-owned ELF, never a shim or home interpreter (1.874163ms)
+✔ real system interpreter is available and safely inspected (16.54588ms)
+✔ restart receipt appends actual replacement identity and refuses unsafe files (3.340596ms)
+✖ activation gate compares fresh startup receipt to the current interpreter identity (1.116553ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 3
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 70.983973
+
+✖ failing tests:
+
+test at packages/bus/tests/interpreter.test.mjs:59:1
+✖ activation gate compares fresh startup receipt to the current interpreter identity (1.116553ms)
+  TypeError: verifyInterpreterReceipt is not a function
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/interpreter.test.mjs:64:15)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async Test.processPendingSubtests (node:internal/test_runner/test:974:7)

agents/gander/work/queue-196/evidence/interpreter-green.txt

@@ -0,0 +1,13 @@
+✔ system Python is a resolved root-owned ELF, never a shim or home interpreter (1.992922ms)
+✔ real system interpreter is available and safely inspected (18.869225ms)
+✔ restart receipt appends actual replacement identity and refuses unsafe files (3.111417ms)
+✔ activation gate compares fresh startup receipt to the current interpreter identity (1.357978ms)
+✔ non-regular startup receipt refuses promptly without waiting on a FIFO peer (32.332597ms)
+ℹ tests 5
+ℹ suites 0
+ℹ pass 5
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 105.511835

agents/gander/work/queue-196/evidence/interpreter-red.txt

@@ -0,0 +1,35 @@
+node:internal/modules/esm/resolve:272
+    throw new ERR_MODULE_NOT_FOUND(
+          ^
+
+Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/interpreter.mjs' imported from /home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/interpreter.test.mjs
+    at finalizeResolution (node:internal/modules/esm/resolve:272:11)
+    at moduleResolve (node:internal/modules/esm/resolve:879:10)
+    at defaultResolve (node:internal/modules/esm/resolve:1006:11)
+    at #cachedDefaultResolve (node:internal/modules/esm/loader:708:20)
+    at #resolveAndMaybeBlockOnLoaderThread (node:internal/modules/esm/loader:728:38)
+    at ModuleLoader.resolveSync (node:internal/modules/esm/loader:766:56)
+    at #resolve (node:internal/modules/esm/loader:690:17)
+    at ModuleLoader.getOrCreateModuleJob (node:internal/modules/esm/loader:610:35)
+    at ModuleJob.syncLink (node:internal/modules/esm/module_job:277:33)
+    at ModuleJob.link (node:internal/modules/esm/module_job:389:17) {
+  code: 'ERR_MODULE_NOT_FOUND',
+  url: 'file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/interpreter.mjs'
+}
+
+Node.js v26.8.1
+✖ packages/bus/tests/interpreter.test.mjs (29.295027ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 34.780279
+
+✖ failing tests:
+
+test at packages/bus/tests/interpreter.test.mjs:1:1
+✖ packages/bus/tests/interpreter.test.mjs (29.295027ms)
+  'test failed'

agents/gander/work/queue-196/evidence/node24-peercred.txt

@@ -0,0 +1,13 @@
+✔ T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit (244.921933ms)
+✔ helper output and failures fail closed including unsafe gid (2.053177ms)
+✔ helper timeout, capacity and shutdown refuse without leaving children (26.359085ms)
+✔ missing or non-regular peer helper refuses at construction before opening the bus (0.377385ms)
+✔ shutdown waits for killed helper close before returning (5.980511ms)
+ℹ tests 5
+ℹ suites 0
+ℹ pass 5
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 352.965488

agents/gander/work/queue-196/evidence/node24-principal.txt

@@ -0,0 +1,12 @@
+✔ principal binds kernel peer PID and uid, maps owner, and never takes identity or role from body (2.18658ms)
+✔ user requires its own nonce and full walk plus immediate same-tree Console parent (0.652569ms)
+✔ tester deliberately admits agent parents but rejects managed runs and another nonce (0.382801ms)
+✔ human leaf identity is reread after walking the parents (0.23585ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 4
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 69.614066

agents/gander/work/queue-196/evidence/node24.json

@@ -0,0 +1,6 @@
+{
+  "version": "v24.22.0",
+  "path": "/mnt/storage/scratch/tmp/g196-node24-gzFqsW/bin/node",
+  "sha256": "cc2f601cee82d9a5a233302fe307abc600727035fd7d2c3a3571755989e95008",
+  "source": "https://nodejs.org/dist/v24.22.0/node-v24.22.0-linux-x64.tar.xz"
+}

agents/gander/work/queue-196/evidence/peer-helper-red.txt

@@ -0,0 +1,27 @@
+✖ missing or non-regular peer helper refuses at construction before opening the bus (0.992412ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 73.967525
+
+✖ failing tests:
+
+test at packages/bus/tests/peercred.test.mjs:93:1
+✖ missing or non-regular peer helper refuses at construction before opening the bus (0.992412ms)
+  AssertionError [ERR_ASSERTION]: Missing expected exception.
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/peercred.test.mjs:94:9)
+      at Test.runInAsyncScope (node:async_hooks:226:14)
+      at Test.run (node:internal/test_runner/test:1402:25)
+      at Test.start (node:internal/test_runner/test:1262:17)
+      at startSubtestAfterBootstrap (node:internal/test_runner/harness:387:17) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: undefined,
+    expected: /peercred-required/,
+    operator: 'throws',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/peer-shutdown-red.txt

@@ -0,0 +1,28 @@
+✖ shutdown waits for killed helper close before returning (1.761026ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 78.151245
+
+✖ failing tests:
+
+test at packages/bus/tests/peercred.test.mjs:98:1
+✖ shutdown waits for killed helper close before returning (1.761026ms)
+  AssertionError [ERR_ASSERTION]: shutdown must await the helper close event
+  
+  0 !== 1
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/peercred.test.mjs:106:9)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: 0,
+    expected: 1,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/peer-transport-green.txt

@@ -0,0 +1,12 @@
+✔ proof receives actual peer, cap traffic never invokes helper and transient cap disconnects (7.225507ms)
+✔ proof helper error and disconnect during verification never dispatch or bind (1.683542ms)
+✔ Client receives explicit proof refusal codes without dispatch, not outcome-unknown (50.186199ms)
+✔ asynchronous proof calls release their transient session on success, failure and timeout (28.028729ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 4
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 148.350042

agents/gander/work/queue-196/evidence/peer-transport-red.txt

@@ -0,0 +1,50 @@
+✖ proof receives actual peer, cap traffic never invokes helper and transient cap disconnects (5.927716ms)
+✖ proof helper error and disconnect during verification never dispatch or bind (1.959972ms)
+ℹ tests 2
+ℹ suites 0
+ℹ pass 0
+ℹ fail 2
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 57.64878
+
+✖ failing tests:
+
+test at packages/bus/tests/peer-transport.test.mjs:9:1
+✖ proof receives actual peer, cap traffic never invokes helper and transient cap disconnects (5.927716ms)
+  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+  
+  false !== true
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/peer-transport.test.mjs:15:9)
+      at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: true,
+    code: 'ERR_ASSERTION',
+    actual: false,
+    expected: true,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }
+
+test at packages/bus/tests/peer-transport.test.mjs:20:1
+✖ proof helper error and disconnect during verification never dispatch or bind (1.959972ms)
+  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+  + actual - expected
+  
+  + undefined
+  - 'peercred-required'
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/peer-transport.test.mjs:25:9)
+      at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
+    generatedMessage: true,
+    code: 'ERR_ASSERTION',
+    actual: undefined,
+    expected: 'peercred-required',
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/peercred-debug.txt

@@ -0,0 +1,21 @@
+✖ T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit (10044.708285ms)
+ℹ started 9 clients
+ℹ received 9 envelopes
+ℹ read 9 peers
+ℹ received 9 replies; after 0
+✔ helper output and failures fail closed including unsafe gid (2.230205ms)
+✔ helper timeout, capacity and shutdown refuse without leaving children (25.395463ms)
+ℹ tests 3
+ℹ suites 0
+ℹ pass 2
+ℹ fail 0
+ℹ cancelled 1
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 10137.502565
+
+✖ failing tests:
+
+test at packages/bus/tests/peercred.test.mjs:15:1
+✖ T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit (10044.708285ms)
+  'test timed out after 10000ms'

agents/gander/work/queue-196/evidence/peercred-green.txt

@@ -0,0 +1,13 @@
+✔ T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit (274.013965ms)
+✔ helper output and failures fail closed including unsafe gid (1.948532ms)
+✔ helper timeout, capacity and shutdown refuse without leaving children (26.176111ms)
+✔ missing or non-regular peer helper refuses at construction before opening the bus (0.331892ms)
+✔ shutdown waits for killed helper close before returning (5.788665ms)
+ℹ tests 5
+ℹ suites 0
+ℹ pass 5
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 396.110405

agents/gander/work/queue-196/evidence/peercred-red.txt

@@ -0,0 +1,35 @@
+node:internal/modules/esm/resolve:272
+    throw new ERR_MODULE_NOT_FOUND(
+          ^
+
+Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/peercred.mjs' imported from /home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/peercred.test.mjs
+    at finalizeResolution (node:internal/modules/esm/resolve:272:11)
+    at moduleResolve (node:internal/modules/esm/resolve:879:10)
+    at defaultResolve (node:internal/modules/esm/resolve:1006:11)
+    at #cachedDefaultResolve (node:internal/modules/esm/loader:708:20)
+    at #resolveAndMaybeBlockOnLoaderThread (node:internal/modules/esm/loader:728:38)
+    at ModuleLoader.resolveSync (node:internal/modules/esm/loader:766:56)
+    at #resolve (node:internal/modules/esm/loader:690:17)
+    at ModuleLoader.getOrCreateModuleJob (node:internal/modules/esm/loader:610:35)
+    at ModuleJob.syncLink (node:internal/modules/esm/module_job:277:33)
+    at ModuleJob.link (node:internal/modules/esm/module_job:389:17) {
+  code: 'ERR_MODULE_NOT_FOUND',
+  url: 'file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/peercred.mjs'
+}
+
+Node.js v26.8.1
+✖ packages/bus/tests/peercred.test.mjs (31.978232ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 37.606365
+
+✖ failing tests:
+
+test at packages/bus/tests/peercred.test.mjs:1:1
+✖ packages/bus/tests/peercred.test.mjs (31.978232ms)
+  'test failed'

agents/gander/work/queue-196/evidence/peercred-resume.txt

@@ -0,0 +1,15 @@
+✔ T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit (259.164726ms)
+ℹ started 9 clients
+ℹ received 9 envelopes
+ℹ read 9 peers; states false/true/false,false/true/false,false/true/false,false/true/false,false/true/false,false/true/false,false/true/false,false/true/false,false/true/false
+ℹ received 9 replies; after 9
+✔ helper output and failures fail closed including unsafe gid (1.460068ms)
+✔ helper timeout, capacity and shutdown refuse without leaving children (26.09001ms)
+ℹ tests 3
+ℹ suites 0
+ℹ pass 3
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 355.364452

agents/gander/work/queue-196/evidence/principal-green.txt

@@ -0,0 +1,12 @@
+✔ principal binds kernel peer PID and uid, maps owner, and never takes identity or role from body (1.70707ms)
+✔ user requires its own nonce and full walk plus immediate same-tree Console parent (0.585886ms)
+✔ tester deliberately admits agent parents but rejects managed runs and another nonce (0.289109ms)
+✔ human leaf identity is reread after walking the parents (0.170627ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 4
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 53.605151

agents/gander/work/queue-196/evidence/principal-red.txt

@@ -0,0 +1,35 @@
+node:internal/modules/esm/resolve:272
+    throw new ERR_MODULE_NOT_FOUND(
+          ^
+
+Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/principal.mjs' imported from /home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/tests/principal.test.mjs
+    at finalizeResolution (node:internal/modules/esm/resolve:272:11)
+    at moduleResolve (node:internal/modules/esm/resolve:879:10)
+    at defaultResolve (node:internal/modules/esm/resolve:1006:11)
+    at #cachedDefaultResolve (node:internal/modules/esm/loader:708:20)
+    at #resolveAndMaybeBlockOnLoaderThread (node:internal/modules/esm/loader:728:38)
+    at ModuleLoader.resolveSync (node:internal/modules/esm/loader:766:56)
+    at #resolve (node:internal/modules/esm/loader:690:17)
+    at ModuleLoader.getOrCreateModuleJob (node:internal/modules/esm/loader:610:35)
+    at ModuleJob.syncLink (node:internal/modules/esm/module_job:277:33)
+    at ModuleJob.link (node:internal/modules/esm/module_job:389:17) {
+  code: 'ERR_MODULE_NOT_FOUND',
+  url: 'file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/bus/src/principal.mjs'
+}
+
+Node.js v26.8.1
+✖ packages/bus/tests/principal.test.mjs (28.063196ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 33.574982
+
+✖ failing tests:
+
+test at packages/bus/tests/principal.test.mjs:1:1
+✖ packages/bus/tests/principal.test.mjs (28.063196ms)
+  'test failed'

agents/gander/work/queue-196/evidence/process.txt

@@ -0,0 +1,16 @@
+✔ broker process binds trusted launches, offers reader capabilities, refuses human mutation, closes cleanly (135.66144ms)
+✔ startup token refusal returns safe code without value or partial listening broker (72.874581ms)
+✔ loaded fixture token is absent from socket replies and SQLite, including refusal evidence (105.550828ms)
+✔ killed broker leaves an explicit stale lock; another process cannot silently reclaim it (164.1127ms)
+✔ trusted host registers later launches; socket clients never have a registration verb (109.156675ms)
+✔ REQ-LIMIT-4 the broker process answers the launcher's mayLaunch op with the limits' awaited decision (100.062279ms)
+✔ runtime excludes declared project roots even when host supplies no repoRoots (70.91343ms)
+✔ a refused launch binding leaves the broker and existing capabilities alive; bad protocol stops it (105.059528ms)
+ℹ tests 8
+ℹ suites 0
+ℹ pass 8
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 913.679719

agents/gander/work/queue-196/evidence/proof-cli.txt

@@ -0,0 +1,11 @@
+✔ proof startup refuses partial flags non-preview and invalid fixture file metadata or bytes (1039.716731ms)
+✔ serve argv carries only fixture proof path and header; startup explicitly reports proof on or off (241.707876ms)
+✔ CLI applies proof on the main listener and rejects that header on its tester listener (232.216606ms)
+ℹ tests 3
+ℹ suites 0
+ℹ pass 3
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 1631.223267

agents/gander/work/queue-196/evidence/proof.txt

@@ -0,0 +1,12 @@
+✔ proxy proof admits named reads and sends, reads its fixture once, and never exposes the value (33.64167ms)
+✔ proxy proof refuses missing wrong short or repeated proof before auth and before any read (9.334211ms)
+✔ proxy proof header is refused on other Hosts and on the tester listener (4.637787ms)
+✔ proof options reject unsafe or colliding header names without disclosing file contents (0.742812ms)
+ℹ tests 4
+ℹ suites 0
+ℹ pass 4
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 170.24723

agents/gander/work/queue-196/evidence/refusal-baseline-comparison.txt

@@ -0,0 +1,2 @@
+baseline human-required
+candidate human-required

agents/gander/work/queue-196/evidence/release-path-green.txt

@@ -0,0 +1,9 @@
+✔ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (5883.382797ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 1
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 6639.610757

agents/gander/work/queue-196/evidence/release-path-red.txt

@@ -0,0 +1,36 @@
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (6495.905564ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 7217.097801
+
+✖ failing tests:
+
+test at packages/cli/tests/stack-release.test.mjs:2088:1
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (6495.905564ms)
+  AssertionError [ERR_ASSERTION]: stack-release: interpreter: {"path":"/usr/bin/python3","sha256":"fixture"}
+  stack-release: captured the rollback set: /mnt/storage/scratch/tmp/sr-eLxVuy/data-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/state/stack-rollback/20261020T201023Z-bb03a6447dc9
+  stack-release: stopped both units
+  stack-release: stopped store schema: 3g
+  stack-release: backup: /mnt/storage/scratch/tmp/sr-eLxVuy/data-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/backups/stack/20261020T201023Z-bb03a6447dc9
+  stack-release: installed bb03a6447dc98f172cbd28c2fbab126b37ff69c3
+  stack-release: gate passed on bb03a6447dc98f172cbd28c2fbab126b37ff69c3
+  stack-release: activate ok: bb03a6447dc98f172cbd28c2fbab126b37ff69c3 is live for acme
+  
+  
+  0 !== 3
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/cli/tests/stack-release.test.mjs:2108:9)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: 0,
+    expected: 3,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/release-proof-order-green.txt

@@ -0,0 +1,9 @@
+✔ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (5160.650984ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 1
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 6043.67883

agents/gander/work/queue-196/evidence/release-proof-order-red.txt

@@ -0,0 +1,43 @@
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (3046.881963ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 3691.652388
+
+✖ failing tests:
+
+test at packages/cli/tests/stack-release.test.mjs:2088:1
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (3046.881963ms)
+  AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+  + actual - expected
+  ... Skipped lines
+  
+    [
+      '--port',
+      '43495',
+      '--business',
+      'acme',
+  ...
+      'jason',
+  +   '--tester-socket',
+      '--proof-header',
+      'x-console-proof',
+      '--proof-file',
+      '/mnt/storage/scratch/tmp/sr-fLVpjD/proof.187',
+  -   '--tester-socket'
+    ]
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/cli/tests/stack-release.test.mjs:2102:9)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: true,
+    code: 'ERR_ASSERTION',
+    actual: [ '--port', '43495', '--business', 'acme', '--public-host', 'console.example', '--auth-header', 'x-user', '--allow-user', 'jason', '--tester-socket', '--proof-header', 'x-console-proof', '--proof-file', '/mnt/storage/scratch/tmp/sr-fLVpjD/proof.187' ],
+    expected: [ '--port', '43495', '--business', 'acme', '--public-host', 'console.example', '--auth-header', 'x-user', '--allow-user', 'jason', '--proof-header', 'x-console-proof', '--proof-file', '/mnt/storage/scratch/tmp/sr-fLVpjD/proof.187', '--tester-socket' ],
+    operator: 'deepStrictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/release-socket-green.txt

@@ -0,0 +1,9 @@
+✔ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (4452.603661ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 1
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 5183.817431

agents/gander/work/queue-196/evidence/release-socket-red.txt

@@ -0,0 +1,36 @@
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (2938.271119ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 3279.087225
+
+✖ failing tests:
+
+test at packages/cli/tests/stack-release.test.mjs:2088:1
+✖ row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket (2938.271119ms)
+  AssertionError [ERR_ASSERTION]: stack-release: captured the rollback set: /mnt/storage/scratch/tmp/sr-QgMOBP/data/state/stack-rollback/20261020T194438Z-6e9ce64cf63b
+  stack-release: drop --tester-port 7333; the target Console does not support it
+  stack-release: stopped both units
+  stack-release: stopped store schema: 3g
+  stack-release: backup: /mnt/storage/scratch/tmp/sr-QgMOBP/data/backups/stack/20261020T194438Z-6e9ce64cf63b
+  stack-release: installed 6e9ce64cf63b125d007476844c4d695a308514d8
+  stack-release: gate passed on 6e9ce64cf63b125d007476844c4d695a308514d8
+  stack-release: activate ok: 6e9ce64cf63b125d007476844c4d695a308514d8 is live for acme
+  
+  
+  0 !== 3
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/cli/tests/stack-release.test.mjs:2095:45)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: 0,
+    expected: 3,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/service-socket-green.txt

@@ -0,0 +1,9 @@
+✔ row196 socket flag renders only for supporting targets and refuses mixed transports (16.910871ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 1
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 77.189844

agents/gander/work/queue-196/evidence/service-socket-red.txt

@@ -0,0 +1,32 @@
+✖ row196 socket flag renders only for supporting targets and refuses mixed transports (7.489228ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 75.646616
+
+✖ failing tests:
+
+test at packages/webui/tests/service.test.mjs:812:1
+✖ row196 socket flag renders only for supporting targets and refuses mixed transports (7.489228ms)
+  AssertionError [ERR_ASSERTION]: usage: scripts/webui-service.sh copy COMMIT [--copies DIR] [--allow-worktree] | render [--copy ID [--copies DIR]] [FLAGS] | install --copy ID [--copies DIR] [--dir DIR] [--no-reload] [--allow-worktree] [FLAGS] | uninstall [--dir DIR] [--no-reload] | status [--dir DIR]
+    FLAGS: [--port N] [--business ID] [--board URL] [--public-host NAME --auth-header HEADER --allow-user ID [--send]] [--tester-port N] [--proof-header NAME --proof-file PATH]
+    --tester-port: 1024..65535, different from --port and never 7332; loopback tester listener.
+    --allow-worktree is for the tests only: copy and install otherwise refuse outside the canonical checkout.
+  
+  
+  4 !== 0
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/tests/service.test.mjs:815:9)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: 4,
+    expected: 0,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/service.txt

@@ -0,0 +1,40 @@
+✔ tester service render carries the tester port alongside existing flags (24.94035ms)
+✔ tester service refuses forwarded 7332 even with another main port (9.82912ms)
+✔ tester service invalid ports refuse render and install with exit 4 and leave the unit alone (104.005996ms)
+✔ tester service counts the digits as written before it strips leading zeros (10.30812ms)
+✔ tester service install and status show the tester port without changing send reporting (205.553924ms)
+✔ render prints the unit without the preview flags (7.561049ms)
+✔ render carries every serve flag, the preview set included (6.973808ms)
+✔ a partial preview set is refused (16.637515ms)
+✔ a value the unit cannot carry is refused, for every flag (256.274405ms)
+✔ the rendered unit names none of the human proof agent markers and sets no agent variable (16.730737ms)
+✔ install into --dir with --no-reload writes the file whole, then reports unchanged (48.962613ms)
+✔ install without --no-reload runs daemon-reload and nothing that starts the unit (20.812535ms)
+✔ uninstall refuses while the unit is running, with or without --no-reload, and removes it once it is not (109.285453ms)
+✔ status prints the unit state and GET /healthz on the installed port (162.506277ms)
+✔ usage: an unknown verb or flag, and start or enable, exit 4 (59.94317ms)
+✔ without --send, render is the template with its placeholders filled, byte for byte (32.400878ms)
+✔ render --send with the preview set ends ExecStart with --send and changes nothing else (52.094309ms)
+✔ --send without the whole preview set is refused and writes nothing (131.187356ms)
+✔ install --send into --dir with --no-reload writes the sending unit, and status says whether it sends (215.263849ms)
+✔ uninstall and status take no --send (29.745082ms)
+✔ install refuses while the unit is running, in any state but inactive or failed, and changes nothing (248.230583ms)
+✔ when the state read fails, install and uninstall refuse with one line and change nothing (71.067475ms)
+✔ install needs --copy naming a copy that exists, and refuses outside the canonical checkout without --allow-worktree (63.261377ms)
+✔ install refuses unless the bus unit runs from the same copy, naming both paths, and changes nothing (235.658605ms)
+✔ render --copy runs the copy and reads the queue in the checkout; without --copy the unit is unchanged (19.314052ms)
+✔ the uid header takes only an Authentik uid; the username header still takes a username (300.432846ms)
+✔ a preview value cannot start with - or . (28.388974ms)
+✔ status names the copy and whether refactor has moved past it, and says when the unit runs from no copy (388.565391ms)
+✔ proxy proof render carries both flags but never opens the fixture file (10.105723ms)
+✔ proxy proof render refuses incomplete non-preview missing unsafe-mode and repo/copy paths (80.016026ms)
+✔ proxy proof status retains send and tester reporting with both proof flags (97.518111ms)
+✔ row196 socket flag renders only for supporting targets and refuses mixed transports (18.052409ms)
+ℹ tests 32
+ℹ suites 0
+ℹ pass 32
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 3155.23567

agents/gander/work/queue-196/evidence/stopped-gate-counts.json

@@ -0,0 +1,18 @@
+{
+  "bus": {
+    "top_level_passes_observed": 464,
+    "top_level_failures": 0,
+    "final_pass_count": [
+      "464"
+    ],
+    "interrupted": false
+  },
+  "webui": {
+    "top_level_passes_observed": 269,
+    "top_level_failures": 2,
+    "final_pass_count": [],
+    "interrupted": true
+  },
+  "mutants_executed": 0,
+  "cli_started": false
+}

agents/gander/work/queue-196/evidence/suite-results-run1.json

@@ -0,0 +1,83 @@
+[
+  {
+    "package": "bus",
+    "args": [
+      "--test",
+      "--test-reporter=tap",
+      "--test-concurrency=2",
+      "packages/bus/tests/account-migration.test.mjs",
+      "packages/bus/tests/agents.test.mjs",
+      "packages/bus/tests/approval-binding.test.mjs",
+      "packages/bus/tests/broker.test.mjs",
+      "packages/bus/tests/business.test.mjs",
+      "packages/bus/tests/channel-proof.test.mjs",
+      "packages/bus/tests/chief-of-staff.test.mjs",
+      "packages/bus/tests/comment-cursors.test.mjs",
+      "packages/bus/tests/comment-migration.test.mjs",
+      "packages/bus/tests/credential-status.test.mjs",
+      "packages/bus/tests/credentials.test.mjs",
+      "packages/bus/tests/csuite-messaging.test.mjs",
+      "packages/bus/tests/daily-quota-runtime.test.mjs",
+      "packages/bus/tests/decision-close.test.mjs",
+      "packages/bus/tests/decision-route.test.mjs",
+      "packages/bus/tests/decisions.test.mjs",
+      "packages/bus/tests/end-launch.test.mjs",
+      "packages/bus/tests/hard-waits.test.mjs",
+      "packages/bus/tests/human.test.mjs",
+      "packages/bus/tests/instances-verb.test.mjs",
+      "packages/bus/tests/interpreter.test.mjs",
+      "packages/bus/tests/land.test.mjs",
+      "packages/bus/tests/launch-notice.test.mjs",
+      "packages/bus/tests/limit-checks.test.mjs",
+      "packages/bus/tests/limit-stop.test.mjs",
+      "packages/bus/tests/limits-runtime.test.mjs",
+      "packages/bus/tests/limits.test.mjs",
+      "packages/bus/tests/message-citation.test.mjs",
+      "packages/bus/tests/messages.test.mjs",
+      "packages/bus/tests/messaging.test.mjs",
+      "packages/bus/tests/name-migration.test.mjs",
+      "packages/bus/tests/names.test.mjs",
+      "packages/bus/tests/peer-transport.test.mjs",
+      "packages/bus/tests/peercred.test.mjs",
+      "packages/bus/tests/plugins-verb.test.mjs",
+      "packages/bus/tests/principal.test.mjs",
+      "packages/bus/tests/process.test.mjs",
+      "packages/bus/tests/project-await.test.mjs",
+      "packages/bus/tests/project-files.test.mjs",
+      "packages/bus/tests/project-runtime.test.mjs",
+      "packages/bus/tests/replies.test.mjs",
+      "packages/bus/tests/requirements.test.mjs",
+      "packages/bus/tests/review.test.mjs",
+      "packages/bus/tests/routes-verb.test.mjs",
+      "packages/bus/tests/schema.test.mjs",
+      "packages/bus/tests/single-use.test.mjs",
+      "packages/bus/tests/spec-migration.test.mjs",
+      "packages/bus/tests/spec-review.test.mjs",
+      "packages/bus/tests/spec-socket.test.mjs",
+      "packages/bus/tests/spec.test.mjs",
+      "packages/bus/tests/staff-request.test.mjs",
+      "packages/bus/tests/state.test.mjs",
+      "packages/bus/tests/store.test.mjs",
+      "packages/bus/tests/task-page.test.mjs",
+      "packages/bus/tests/task-read.test.mjs",
+      "packages/bus/tests/tasks.test.mjs",
+      "packages/bus/tests/tester-threads.test.mjs",
+      "packages/bus/tests/tester-writes.test.mjs",
+      "packages/bus/tests/tester.test.mjs",
+      "packages/bus/tests/thread-migration.test.mjs",
+      "packages/bus/tests/threads.test.mjs",
+      "packages/bus/tests/transport.test.mjs",
+      "packages/bus/tests/usage-broker.test.mjs",
+      "packages/bus/tests/usage-migration.test.mjs",
+      "packages/bus/tests/usage-runtime.test.mjs",
+      "packages/bus/tests/usage.test.mjs",
+      "packages/bus/tests/web.test.mjs",
+      "packages/bus/tests/workflow-roles.test.mjs"
+    ],
+    "log": "/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/agents/gander/work/queue-196/evidence/suite-bus.tap",
+    "failures": 1,
+    "stopped": false,
+    "code": 1,
+    "signal": null
+  }
+]

agents/gander/work/queue-196/evidence/suite-results.json

@@ -0,0 +1,143 @@
+[
+  {
+    "package": "bus",
+    "args": [
+      "--test",
+      "--test-reporter=tap",
+      "--test-concurrency=2",
+      "packages/bus/tests/account-migration.test.mjs",
+      "packages/bus/tests/agents.test.mjs",
+      "packages/bus/tests/approval-binding.test.mjs",
+      "packages/bus/tests/broker.test.mjs",
+      "packages/bus/tests/business.test.mjs",
+      "packages/bus/tests/channel-proof.test.mjs",
+      "packages/bus/tests/chief-of-staff.test.mjs",
+      "packages/bus/tests/comment-cursors.test.mjs",
+      "packages/bus/tests/comment-migration.test.mjs",
+      "packages/bus/tests/credential-status.test.mjs",
+      "packages/bus/tests/credentials.test.mjs",
+      "packages/bus/tests/csuite-messaging.test.mjs",
+      "packages/bus/tests/daily-quota-runtime.test.mjs",
+      "packages/bus/tests/decision-close.test.mjs",
+      "packages/bus/tests/decision-route.test.mjs",
+      "packages/bus/tests/decisions.test.mjs",
+      "packages/bus/tests/end-launch.test.mjs",
+      "packages/bus/tests/hard-waits.test.mjs",
+      "packages/bus/tests/human.test.mjs",
+      "packages/bus/tests/instances-verb.test.mjs",
+      "packages/bus/tests/interpreter.test.mjs",
+      "packages/bus/tests/land.test.mjs",
+      "packages/bus/tests/launch-notice.test.mjs",
+      "packages/bus/tests/limit-checks.test.mjs",
+      "packages/bus/tests/limit-stop.test.mjs",
+      "packages/bus/tests/limits-runtime.test.mjs",
+      "packages/bus/tests/limits.test.mjs",
+      "packages/bus/tests/message-citation.test.mjs",
+      "packages/bus/tests/messages.test.mjs",
+      "packages/bus/tests/messaging.test.mjs",
+      "packages/bus/tests/name-migration.test.mjs",
+      "packages/bus/tests/names.test.mjs",
+      "packages/bus/tests/peer-transport.test.mjs",
+      "packages/bus/tests/peercred.test.mjs",
+      "packages/bus/tests/plugins-verb.test.mjs",
+      "packages/bus/tests/principal.test.mjs",
+      "packages/bus/tests/process.test.mjs",
+      "packages/bus/tests/project-await.test.mjs",
+      "packages/bus/tests/project-files.test.mjs",
+      "packages/bus/tests/project-runtime.test.mjs",
+      "packages/bus/tests/replies.test.mjs",
+      "packages/bus/tests/requirements.test.mjs",
+      "packages/bus/tests/review.test.mjs",
+      "packages/bus/tests/routes-verb.test.mjs",
+      "packages/bus/tests/schema.test.mjs",
+      "packages/bus/tests/single-use.test.mjs",
+      "packages/bus/tests/spec-migration.test.mjs",
+      "packages/bus/tests/spec-review.test.mjs",
+      "packages/bus/tests/spec-socket.test.mjs",
+      "packages/bus/tests/spec.test.mjs",
+      "packages/bus/tests/staff-request.test.mjs",
+      "packages/bus/tests/state.test.mjs",
+      "packages/bus/tests/store.test.mjs",
+      "packages/bus/tests/task-page.test.mjs",
+      "packages/bus/tests/task-read.test.mjs",
+      "packages/bus/tests/tasks.test.mjs",
+      "packages/bus/tests/tester-threads.test.mjs",
+      "packages/bus/tests/tester-writes.test.mjs",
+      "packages/bus/tests/tester.test.mjs",
+      "packages/bus/tests/thread-migration.test.mjs",
+      "packages/bus/tests/threads.test.mjs",
+      "packages/bus/tests/transport.test.mjs",
+      "packages/bus/tests/usage-broker.test.mjs",
+      "packages/bus/tests/usage-migration.test.mjs",
+      "packages/bus/tests/usage-runtime.test.mjs",
+      "packages/bus/tests/usage.test.mjs",
+      "packages/bus/tests/web.test.mjs",
+      "packages/bus/tests/workflow-roles.test.mjs"
+    ],
+    "log": "/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/agents/gander/work/queue-196/evidence/suite-bus.tap",
+    "failures": 0,
+    "stopped": false,
+    "code": 0,
+    "signal": null
+  },
+  {
+    "package": "webui",
+    "args": [
+      "--test",
+      "--test-reporter=tap",
+      "--test-concurrency=2",
+      "packages/webui/tests/assistant.test.mjs",
+      "packages/webui/tests/board-held.test.mjs",
+      "packages/webui/tests/browser-edge.test.mjs",
+      "packages/webui/tests/browser.test.mjs",
+      "packages/webui/tests/bus-browser.test.mjs",
+      "packages/webui/tests/bus.test.mjs",
+      "packages/webui/tests/channel-chat.test.mjs",
+      "packages/webui/tests/chat-browser.test.mjs",
+      "packages/webui/tests/chat.test.mjs",
+      "packages/webui/tests/conversation.test.mjs",
+      "packages/webui/tests/discord.test.mjs",
+      "packages/webui/tests/docs-browser.test.mjs",
+      "packages/webui/tests/editor-browser.test.mjs",
+      "packages/webui/tests/editor-provenance.test.mjs",
+      "packages/webui/tests/editor.test.mjs",
+      "packages/webui/tests/history-return-flow.test.mjs",
+      "packages/webui/tests/instances-browser.test.mjs",
+      "packages/webui/tests/instances.test.mjs",
+      "packages/webui/tests/limits-browser.test.mjs",
+      "packages/webui/tests/limits-route.test.mjs",
+      "packages/webui/tests/markdown-preview.test.mjs",
+      "packages/webui/tests/messages.test.mjs",
+      "packages/webui/tests/pinned-copy.test.mjs",
+      "packages/webui/tests/preview.test.mjs",
+      "packages/webui/tests/project-file.test.mjs",
+      "packages/webui/tests/project-name-repo.test.mjs",
+      "packages/webui/tests/proof-cli.test.mjs",
+      "packages/webui/tests/proof.test.mjs",
+      "packages/webui/tests/reads.test.mjs",
+      "packages/webui/tests/relaunch.test.mjs",
+      "packages/webui/tests/return-flow.test.mjs",
+      "packages/webui/tests/routes-browser.test.mjs",
+      "packages/webui/tests/routes.test.mjs",
+      "packages/webui/tests/send-browser.test.mjs",
+      "packages/webui/tests/send.test.mjs",
+      "packages/webui/tests/serve.test.mjs",
+      "packages/webui/tests/service.test.mjs",
+      "packages/webui/tests/settings-form.test.mjs",
+      "packages/webui/tests/settings-write.test.mjs",
+      "packages/webui/tests/shell.test.mjs",
+      "packages/webui/tests/tester-browser.test.mjs",
+      "packages/webui/tests/tester-cli.test.mjs",
+      "packages/webui/tests/tester-listener.test.mjs",
+      "packages/webui/tests/tester-socket.test.mjs",
+      "packages/webui/tests/usage-browser.test.mjs",
+      "packages/webui/tests/usage.test.mjs",
+      "packages/webui/tests/views.test.mjs"
+    ],
+    "log": "/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/agents/gander/work/queue-196/evidence/suite-webui.tap",
+    "failures": 2,
+    "stopped": true,
+    "code": 1,
+    "signal": null
+  }
+]

agents/gander/work/queue-196/evidence/tester-browser-focused.txt

@@ -0,0 +1,10 @@
+✔ tester Console banner exposes only instance route and name editors and saves a route as tester (903.47494ms)
+✔ row 177: the tester Console chat composer is enabled and a send shows in its own thread (779.82198ms)
+ℹ tests 2
+ℹ suites 0
+ℹ pass 2
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 1835.567916

agents/gander/work/queue-196/evidence/tester-cleanup-blocker.txt

@@ -0,0 +1,29 @@
+✖ tester cleanup must leave a replacement inode untouched (4.588498ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 77.335255
+
+✖ failing tests:
+
+test at packages/webui/tests/tester-socket.test.mjs:31:1
+✖ tester cleanup must leave a replacement inode untouched (4.588498ms)
+  AssertionError [ERR_ASSERTION]: closing the listener must not unlink a replacement inode
+  
+  false !== true
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/tests/tester-socket.test.mjs:40:9)
+      at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: false,
+    expected: true,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/tester-cleanup-rename-green.txt

@@ -0,0 +1,9 @@
+✔ tester cleanup must leave a replacement inode untouched (4.721014ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 1
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 69.761924

agents/gander/work/queue-196/evidence/tester-cleanup-rename-red.txt

@@ -0,0 +1,29 @@
+✖ tester cleanup must leave a replacement inode untouched (5.181827ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 70.292577
+
+✖ failing tests:
+
+test at packages/webui/tests/tester-socket.test.mjs:31:1
+✖ tester cleanup must leave a replacement inode untouched (5.181827ms)
+  AssertionError [ERR_ASSERTION]: closing the listener must not unlink a replacement inode
+  
+  false !== true
+  
+      at TestContext.<anonymous> (file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/tests/tester-socket.test.mjs:41:9)
+      at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
+      at async Test.run (node:internal/test_runner/test:1409:7)
+      at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
+    generatedMessage: false,
+    code: 'ERR_ASSERTION',
+    actual: false,
+    expected: true,
+    operator: 'strictEqual',
+    diff: 'simple'
+  }

agents/gander/work/queue-196/evidence/tester-cli.txt

@@ -0,0 +1,10 @@
+✔ tester-port validates range tunnel main port and requires configured bus before listening (842.750345ms)
+✔ CLI tester listener binds a private Unix socket and spawns TESTER_CLI for every Console bus read (2447.891251ms)
+ℹ tests 2
+ℹ suites 0
+ℹ pass 2
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 3426.404641

agents/gander/work/queue-196/evidence/tester-http.txt

@@ -0,0 +1,10 @@
+✔ tester HTTP helper uses instance socket, logical origin and JSON without retrying (16.169258ms)
+✔ tester HTTP timeout closes the socket and does not retry (24.057725ms)
+ℹ tests 2
+ℹ suites 0
+ℹ pass 2
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 109.82809

agents/gander/work/queue-196/evidence/tester-listener.txt

@@ -0,0 +1,18 @@
+✔ main listener refuses x-mosaic-tester before any board or bus read for every Host (17.594021ms)
+✔ tester listener rejects preview binding and requires its fixed logical Host and no proxy auth header (97.026908ms)
+✔ tester listener writes only instances routes and names with tester receipts and actor (102.526377ms)
+✔ tester listener refuses every human-only write with no bus call (74.180878ms)
+✔ tester-off and tester-required reads return HTTP 403 (72.172231ms)
+✔ tester credentials routes and committed project reads keep secrets and paths bounded (139.034531ms)
+✔ row 177 W1: the tester chat makes, sends to, opens and reads its own thread as tester (19.236645ms)
+✔ row 177 W2: tester chat writes refuse a missing or foreign Origin, cross-site, text/plain and the proxy header with no bus call (9.497407ms)
+✔ row 177 W3: the human thread through the tester chat is thread-not-owned, and bus.tester off answers tester-off (22.342419ms)
+✔ row 177 W4: the main listener refuses x-mosaic-tester on chat reads and writes before the chat (1.907ms)
+ℹ tests 10
+ℹ suites 0
+ℹ pass 10
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 677.96388

agents/gander/work/queue-196/evidence/tester-socket-green.txt

@@ -0,0 +1,11 @@
+✔ private tester HTTP serves on 0600 socket in 0700 parent and fixed origin (56.084397ms)
+✔ private tester refuses symlink, unsafe parent and long path without repairs (0.822118ms)
+✔ tester cleanup must leave a replacement inode untouched (1.433318ms)
+ℹ tests 3
+ℹ suites 0
+ℹ pass 3
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 119.311098

agents/gander/work/queue-196/evidence/tester-socket-red.txt

@@ -0,0 +1,35 @@
+node:internal/modules/esm/resolve:272
+    throw new ERR_MODULE_NOT_FOUND(
+          ^
+
+Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/src/tester-socket.mjs' imported from /home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/tests/tester-socket.test.mjs
+    at finalizeResolution (node:internal/modules/esm/resolve:272:11)
+    at moduleResolve (node:internal/modules/esm/resolve:879:10)
+    at defaultResolve (node:internal/modules/esm/resolve:1006:11)
+    at #cachedDefaultResolve (node:internal/modules/esm/loader:708:20)
+    at #resolveAndMaybeBlockOnLoaderThread (node:internal/modules/esm/loader:728:38)
+    at ModuleLoader.resolveSync (node:internal/modules/esm/loader:766:56)
+    at #resolve (node:internal/modules/esm/loader:690:17)
+    at ModuleLoader.getOrCreateModuleJob (node:internal/modules/esm/loader:610:35)
+    at ModuleJob.syncLink (node:internal/modules/esm/module_job:277:33)
+    at ModuleJob.link (node:internal/modules/esm/module_job:389:17) {
+  code: 'ERR_MODULE_NOT_FOUND',
+  url: 'file:///home/jwoltje/.t3/worktrees/mosaic-stack/gander-row196/packages/webui/src/tester-socket.mjs'
+}
+
+Node.js v26.8.1
+✖ packages/webui/tests/tester-socket.test.mjs (33.788429ms)
+ℹ tests 1
+ℹ suites 0
+ℹ pass 0
+ℹ fail 1
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 42.005573
+
+✖ failing tests:
+
+test at packages/webui/tests/tester-socket.test.mjs:1:1
+✖ packages/webui/tests/tester-socket.test.mjs (33.788429ms)
+  'test failed'

agents/gander/work/queue-196/evidence/tester.txt

@@ -0,0 +1,22 @@
+✔ the tester binds only when the business sets bus.tester to exactly true (61.599223ms)
+✔ a business may not name a role tester, so the tester address is never a role (17.534761ms)
+✔ every verb outside the tester list refuses tester-refused and is recorded against the tester (37.114694ms)
+✔ a tester message is from tester, needs no prefix, and writes no human.input or authority (14.658214ms)
+✔ a tester message to a role no run holds refuses tester-target-not-running and stores nothing (10.010587ms)
+✔ a tester message is refused while the run is only launched, and routes once it claims (11.801045ms)
+✔ a human message to a role no run holds still waits and tells launch.by (9.843013ms)
+✔ a role answers a tester only in reply to a tester message, and the answer never reaches the human (21.065845ms)
+✔ the tester reads the human views a reader reads (23.085923ms)
+✔ tester proof binds its own CLI, start time and nonce, refuses a managed run and allows an agent (1.132907ms)
+✔ neither CLI's nonce proves the other: each proof is bound to its own CLI and nonce variable (0.338746ms)
+✔ testerNonce reads only the tester's variable and gives null on any read error (0.167036ms)
+✔ an envelope carries exactly one of cap, human and tester; no tester authenticator refuses (82.495712ms)
+✔ tester-cli.mjs binds through the runtime when the switch is on, and refuses off or under a run marker (949.011498ms)
+ℹ tests 14
+ℹ suites 0
+ℹ pass 14
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 1344.0805

agents/gander/work/queue-196/evidence/transport.txt

@@ -0,0 +1,13 @@
+✔ socket capability stamps launch identity; shared views use wire, no SQL client (55.397456ms)
+✔ two wire claims serialize; a lost reply never automatically retries (48.315452ms)
+✔ malformed, oversized and identity-forging envelopes refuse without echoing input (34.817302ms)
+✔ client preserves UTF-8 when a response divides a multibyte character (11.903844ms)
+✔ committed mutation followed by dropped reply reports unknown and is never retried (29.646174ms)
+ℹ tests 5
+ℹ suites 0
+ℹ pass 5
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 288.566303

agents/gander/work/queue-196/evidence/webui-bus.txt

@@ -0,0 +1,18 @@
+✔ bus routes serve the four reads from the reader view, unescaped JSON for the page to escape (67.351635ms)
+✔ decisions route serves the roles and recent lists from the reader view (32.001579ms)
+✔ credentials route serves the broker credential status from the reader view (11.335934ms)
+✔ replies route serves the replies to one message from the reader view (33.381558ms)
+✔ bus routes are GET-only, have no write verb, and keep the same-origin checks (56.18236ms)
+✔ bus refusals map to statuses and never carry a path or a stack (26.580535ms)
+✔ humanCall speaks the human transport protocol without blocking the server (1664.225925ms)
+✔ busReader takes --business, else the live bus host, else refuses (179.394177ms)
+✔ humanCall kills a transport that runs past its timeout (527.236263ms)
+✔ serve refuses a --business value that is not a business id (267.848133ms)
+ℹ tests 10
+ℹ suites 0
+ℹ pass 10
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 3002.288149

agents/gander/work/queue-196/mutants.mjs

@@ -0,0 +1,65 @@
+// Authorized batch only. Mutate isolated scratch copies, never the candidate or installed tree.
+import {mkdtempSync,cpSync,readFileSync,writeFileSync,rmSync,symlinkSync,existsSync,mkdirSync} from 'node:fs';
+import {tmpdir} from 'node:os';import {join,resolve} from 'node:path';
+import {spawnSync,execFileSync} from 'node:child_process';import {createHash} from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+const root=fileURLToPath(new URL('../../../../',import.meta.url));
+const out=join(root,'agents/gander/work/queue-196/evidence/mutants');mkdirSync(out,{recursive:true});
+const scratch=mkdtempSync(join(tmpdir(),'g196-mut-'));
+const p='packages/bus/src/principal.mjs',h='packages/bus/src/human.mjs',w='packages/webui/src/tester-socket.mjs',s='packages/bus/src/server.mjs',peer='packages/bus/src/peercred.mjs';
+const principal='packages/bus/tests/principal.test.mjs',socket='packages/webui/tests/tester-socket.test.mjs',transport='packages/bus/tests/peer-transport.test.mjs',interpreter='packages/bus/tests/interpreter.test.mjs';
+const release=['--test-name-pattern=row196 explicit socket','packages/cli/tests/stack-release.test.mjs'];
+const specs=[
+ ['M1', 'packages/webui/src/serve.mjs','tester uses TCP',socket, text=>text.replace('if (tester) return bindTesterSocket(server, testerSocket);',"if (tester) return new Promise(r=>server.listen(0,'127.0.0.1',()=>r(server)));" )],
+ ['M2',w,'socket mode widened',socket,t=>t.replace('chmodSync(temporary, 0o600)','chmodSync(temporary, 0o666)')],
+ ['M3','packages/webui/src/serve.mjs','sign-in accepted on tester',socket,t=>t.replace("if (tester && (Object.hasOwn(req.headers, 'authorization')", "if (false && (Object.hasOwn(req.headers, 'authorization')")],
+ ['M4',p,'copied PID accepted',principal,t=>t.replace('peer.pid !== proof.pid','false')],
+ ['M5',peer,'helper parse error ignored','packages/bus/tests/peercred.test.mjs',t=>t.replace('} catch { finish(true); }','} catch { finish(false, {pid:2,uid:0,gid:0}); }')],
+ ['M6',p,'foreign uid accepted',principal,t=>t.replace('peer.uid !== process.getuid()','false')],
+ ['M7',w,'unsafe parent accepted',socket,t=>t.replace('(dir.mode & 0o077)','false')],
+ ['M8',h,'agent environment walk skipped',principal,t=>t.replace('current.env !== null && MARKERS.some','false && MARKERS.some')],
+ ['M9',h,'leaf identity not reread',principal,t=>t.replace('if (again.startTime !== proof.startTime || again.ppid !== p.ppid)','if (false)')],
+ ['M10',p,'Console direct-parent check removed',principal,t=>t.replace("if (parent.uid !== peer.uid || parent.argv[1] !== resolve(paths.console) || parent.argv[2] !== 'serve')",'if (false)')],
+ ['M11',p,'Console basename accepted',principal,t=>t.replace("import { resolve }", "import { resolve, basename }").replace('parent.argv[1] !== resolve(paths.console)','basename(parent.argv[1] ?? "") !== basename(paths.console)')],
+ ['M12',h,'unknown proof identity accepted',principal,t=>t.replace("Object.keys(proof).some((k) => !['pid', 'startTime', 'nonce', 'business'].includes(k))",'false')],
+ ['M13',s,'transient cap leaked',transport,t=>t.replace('broker.disconnect(boundCap)','void(boundCap)')],
+ ['M14',p,'tester walk used for user',principal,t=>t.replace("verifyHuman(checked, { cliPath: paths[kind], launches, readProcess,\n    nonceKey: kind === 'user' ? 'MOSAIC_BUS_USER_NONCE' : 'MOSAIC_BUS_CLI_NONCE' })",'verifyTester(checked, {cliPath:paths[kind],launches,readProcess,readNonce:()=>checked.nonce})')],
+ ['M15','scripts/stack-release.sh','TCP retained during conversion',release,t=>t.replace('RUN_CONSOLE=("${without_tester[@]}" --tester-socket)','RUN_CONSOLE=("${P_CONSOLE[@]}" --tester-socket)')],
+ ['M16','scripts/stack-release.sh','TCP reopened on downgrade',release,t=>t.replace('RUN_CONSOLE=("${without_tester[@]}") DROP_TESTER="--tester-socket','RUN_CONSOLE=("${without_tester[@]}" --tester-port 7333) DROP_TESTER="--tester-socket')],
+ ['M17','packages/bus/src/broker.mjs','tester switch ignored','packages/bus/tests/tester.test.mjs',t=>t.replace("if (this.#business(record.business).vars?.['bus.tester'] !== true)",'if (false)')],
+ ['M18',p,'user kind becomes owner',principal,t=>t.replace("return { kind: 'user', business, id: proof.user }","return { kind: 'owner', business, id: proof.user }")],
+ ['M19','packages/cli/src/tester-http.mjs','selected instance root ignored',socket,t=>t.replace('socketPath: testerSocketPath(dataRoot)','socketPath: testerSocketPath(dataRoot + "/wrong-instance")')],
+ ['M20',peer,'helper gets another pending socket','packages/bus/tests/peercred.test.mjs',t=>t.replace('export function createPeerReader','function originalPeerReader')+`\nexport function createPeerReader(options){const base=originalPeerReader(options),queue=[];let scheduled=false;return{read(socket){return new Promise((resolve,reject)=>{queue.push({socket,resolve,reject});if(!scheduled){scheduled=true;queueMicrotask(()=>{scheduled=false;const jobs=queue.splice(0);jobs.forEach((job,i)=>base.read(jobs[(i+1)%jobs.length].socket).then(job.resolve,job.reject));});}});},close(){base.close();}};}\n`],
+ ['M21','packages/bus/src/interpreter.mjs','user-owned interpreter accepted',interpreter,t=>t.replace('s.uid !== 0 || (s.mode & 0o022)','false || (s.mode & 0o022)')],
+ ['M22',s,'cap requests invoke helper',transport,t=>t.replace('        if (kind) {','        if (r.cap) await peers.read(socket);\n        if (kind) {')],
+ ['M23','packages/bus/src/interpreter.mjs','restart retains stale identity',interpreter,t=>t.replace('export function recordInterpreterStart(directory, record) {','export function recordInterpreterStart(directory, record) {\n  try { readFileSync(join(directory,"peercred-starts.jsonl")); return; } catch {}')],
+ ['M24',w,'listener binds final path directly',socket,t=>t.replace("const temporary = join(parent, '.' + randomBytes(4).toString('hex') + '.s');",'const temporary = path;')],
+ ['M25','packages/bus/src/interpreter.mjs','FIFO receipt blocks before type refusal',['--test-name-pattern=non-regular startup receipt',interpreter],t=>t.replaceAll(' | constants.O_NONBLOCK','')],
+ ['M26',peer,'missing helper accepted at startup',['--test-name-pattern=missing or non-regular peer helper','packages/bus/tests/peercred.test.mjs'],t=>t.replace('if (!s.isFile() || s.isSymbolicLink()) throw Error();','if (false) throw Error();').replace('catch { throw refused(); }','catch {}')],
+ ['M27',peer,'shutdown returns before helpers are reaped',['--test-name-pattern=shutdown waits','packages/bus/tests/peercred.test.mjs'],t=>t.replace("      await Promise.all([...children].map(child => new Promise(resolve => {\n        child.once('close', resolve);\n        child.kill('SIGKILL');\n      })));","      for (const child of children) child.kill('SIGKILL');")],
+ ['M28','scripts/stack-release.sh','proof pair placed after tester socket flag',release,t=>t.replace('--send | --tester-port | --tester-socket) break','--send | --tester-port) break')],
+ ['M29','scripts/stack-release.sh','unsafe tester path reaches service stop',release,t=>t.split('\n').filter(line=>!line.includes('|| check_refuse tester-socket-path')).join('\n')],
+];
+const hash=x=>createHash('sha256').update(x).digest('hex');
+const results=[];
+try {
+ for(const name of ['packages','scripts','adapters','roles','contracts','RELEASE','package.json','package-lock.json','.git'])if(existsSync(join(root,name)))cpSync(join(root,name),join(scratch,name),{recursive:true,filter:src=>!src.includes('/node_modules/')&&!src.endsWith('/node_modules')});
+ symlinkSync(join(root,'node_modules'),join(scratch,'node_modules'));
+ for(const [id,file,description,test,mutate] of specs) {
+  const at=join(scratch,file),original=readFileSync(at,'utf8'),before=hash(original),changed=mutate(original);
+  if(changed===original)throw Error(id+' did not change bytes');
+  writeFileSync(at,changed);
+  const syntax=spawnSync(file.endsWith('.sh')?'bash':process.execPath,[file.endsWith('.sh')?'-n':'--check',at],{encoding:'utf8'});
+  if(syntax.status!==0)throw Error(id+' invalid mutation: '+syntax.stderr);
+  const args=['--test',...(Array.isArray(test)?test:[test])];
+  const run=spawnSync(process.execPath,args,{cwd:scratch,encoding:'utf8',timeout:30000,maxBuffer:2*1024*1024});
+  const log=(run.stdout??'')+(run.stderr??'');writeFileSync(join(out,id+'.txt'),log);
+  writeFileSync(at,original);if(hash(readFileSync(at))!==before)throw Error(id+' restore hash failed');
+  const failed=/[ℹ#]\s*(?:fail|tests failed)\s+[1-9]/.test(log) || /✖/.test(log);
+  const killed=run.status!==0&&failed&&!/SyntaxError|ERR_MODULE_NOT_FOUND/.test(log);
+  const result={id,description,test,args,status:run.status,signal:run.signal,killed,restoredSha256:before};results.push(result);
+  writeFileSync(join(out,'results.json'),JSON.stringify(results,null,2)+'\n');
+  console.log(id+' '+(killed?'KILLED':'SURVIVED/INVALID'));
+  if(!killed) {process.exitCode=1;break;}
+ }
+} finally {rmSync(scratch,{recursive:true,force:true});}

agents/gander/work/queue-196/run-gates.mjs

@@ -0,0 +1,20 @@
+import {spawn} from 'node:child_process';
+import {createWriteStream,writeFileSync,readdirSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';import {join} from 'node:path';
+const root=fileURLToPath(new URL('../../../../',import.meta.url));
+const results=[];
+for(const pkg of ['bus','webui','cli']) {
+ const files=readdirSync(join(root,'packages',pkg,'tests')).filter(n=>n.endsWith('.test.mjs')).map(n=>`packages/${pkg}/tests/${n}`);
+ const log=join(root,`agents/gander/work/queue-196/evidence/suite-${pkg}.tap`),output=createWriteStream(log);
+ let failures=0,buffer='',stopped=false;
+ const args=['--test','--test-reporter=tap','--test-concurrency=2',...files];
+ const child=spawn(process.execPath,args,{cwd:root,stdio:['ignore','pipe','pipe'],detached:true});
+ const read=data=>{output.write(data);buffer+=data;const lines=buffer.split('\n');buffer=lines.pop();for(const line of lines)if(/^not ok /.test(line)){failures++;if(failures>=2&&!stopped){stopped=true;process.kill(-child.pid,'SIGTERM');}}};
+ child.stdout.on('data',read);child.stderr.on('data',data=>output.write(data));
+ const status=await new Promise(resolve=>child.on('close',(code,signal)=>resolve({code,signal})));
+ await new Promise(resolve=>output.end(resolve));
+ results.push({package:pkg,args,log,failures,stopped,...status});
+ writeFileSync(join(root,'agents/gander/work/queue-196/evidence/suite-results.json'),JSON.stringify(results,null,2)+'\n');
+ console.log(pkg+' '+JSON.stringify(status)+' failures='+failures);
+ if(status.code!==0||failures){process.exitCode=1;break;}
+}

agents/gizmoduck/README.md

@@ -1,9 +0,0 @@
-# Gizmoduck
-
-Design and builder seat, Claude Opus 5.5, a T3 thread (9312a896). Author of the federation design
-(`agents/gizmoduck/work/federation/DESIGN.md` on `gizmoduck/federation-design`, #414). Builds FED R1, the
-access.json loader and validator, under Mos's order mos-1023 item 1.
-
-No launcher in this directory. The seat works in its own worktree and has no credentials of its own; until
-the credentials row settles per-agent identity, it pushes only its own `gizmoduck/*` branches through the
-repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

agents/herb/README.md

@@ -1,8 +0,0 @@
-# Herb
-
-Builder seat, Codex gpt-6.1-sol, started by Sage under mos-0977 item 5 (more Codex Sol rows) for a second gate lane
-design row (#1695, mos-0977 item 6).
-
-No launcher in this directory. The seat runs as a T3 thread and works in its own worktree. It has no
-credentials of its own; until the credentials row settles per-agent identity, it pushes only its own `herb/*`
-branches through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

agents/honker/work/queue-194/PRD-1.7-DRAFT.md

@@ -1,158 +0,0 @@
-# PRD 1.7 draft: the chief of staff's hire and fire authority, the coder's push to its fork, and agent
-# host access through the credential store
-
-Draft by Honker for row 194 (#1692), under Mos's ruling mos-1017 (through Sage, sage-1365). Not approved.
-It changes nothing until Jason approves it as a `prd.approve` decision in the Console. Sage opens that
-decision and sends Mos its id. Base: `docs/prd/mosaic-stack.md` version 1.6 at 53bb59462.
-
-## What it changes
-
-Row 194 adds `role.hire` and `role.fire` to the vocabulary, and row 199 adds `git.push.remote`. Under
-REQ-WAIT-3 all three are hard waits, so today Jason resolves every hire, every fire and every push to a
-remote. This version routes hire and fire for the chief of staff within fixed bounds, so the chief hires
-and fires as needed and the user's per-agent forbid still holds. It routes `git.push.remote` for the coder
-only (Mos, mos-1028 item 3). It adds agent host access with sudo through the credential store for
-agents with a grant (Q183, Q184, Vikunja #424, due 2026-10-27). One `prd.approve` decision covers it all
-(Vikunja #420).
-
-When this version lands, a reviewed commit:
-
-1. adds `role.hire`, `role.fire` and `git.push.remote` to `ROUTED` in
-   `packages/business/src/vocabulary.mjs` and in `packages/bus/src/broker.mjs`.
-2. adds `role.hire` and `role.fire` to `roles/chief-of-staff.json` withinRole, and `git.push.remote` to
-   `roles/coder.json` withinRole. No other role file gets `git.push.remote`.
-3. switches the broker's check on `instance.hire` and `instance.fire` from a cited decision to the
-   `reason` form, as `role.end` works for REQ-ROLE-2, and makes `publish`'s `decision` optional for a
-   within-role class (row 199 D9 step 1).
-4. states, for a `git.push.remote` with no decision, where the source commit comes from: the latest work
-   commit the bus recorded for the coder's task. The check still matches it against the work ref tip and
-   the push sends it by oid (row 199, duckworth-0022 N9).
-5. adds the host credential grant check and the host access it allows (REQ-CRED-3, Vikunja #424).
-
-Every other check stays as rows 194 and 199 build it. Filling `hireable` stays a separate reviewed role
-file commit in `roles/`.
-
-## Text for the PRD
-
-Status line, appended to the current paragraph:
-
-> Version 1.7 routes the chief of staff's hire and fire actions and the coder's push to its own fork,
-> and adds agent host access through the credential store, approved by Jason in decision
-> <prd.approve decision id>.
-
-Source, a new bullet above "Version 1.6 source":
-
-> - Version 1.7 source, TARGET.md line 66: "Chief of staff agent has hire/fire authority for agents as
->   needed; unless user forbids per agent". And Jason through Mos (mos-1067), DECISIONS Q183, in part: "I will
->   still want to allow infra agent(s) on my .53 instance to access other servers, etc. However, not all
->   agents will need to have that access. I envision a credential store within Mosaic Stack that works
->   as some sort of variable for the agent to call. The system will enforce access to the credentials to
->   keep the agents sandboxed with proper security. I need to be able to trust my agents with assisting
->   me. This will require sudo access to several systems. If we can utilize the credential store in
->   Mosaic Stack and allow agents to perform their jobs with NOPASSWD sudo on various machines, I am a
->   happy man." DECISIONS Q184, on whether that is in place by 10-27: "Q5: by 10.27"
-
-Under "Added in version 1.2", after REQ-COS-2:
-
-> Added in version 1.7:
->
-> - **REQ-COS-3.** The chief of staff hires and fires role instances without a decision each time. Hiring
->   adds a role instance to the organization file and lists it for launch. Firing ends the instance's
->   runs and removes it from the launch list. It stays in the organization file. Only the user deletes
->   an instance. These actions are `role.hire` and `role.fire`. They leave the hard waits and route
->   under this requirement, within these bounds:
->   - The chief acts only in its own organization.
->   - The chief hires only role definitions that need no credentials, until a later version adds
->     credentialed roles.
->   - The chief hires only the role kinds its role file lists. Changing that list is a reviewed commit.
->   - The chief hires only a role whose every action is on a fixed list of plain work actions: sending
->     messages, writing records, asking for review, updating its assigned tasks, and the scope and
->     working-push actions of an assigned task. A role holding any other action, such as launch, end,
->     organization, naming, hire, review verdict or merge authority, or any action added later, is never
->     hired. So the chief never hires a chief, never picks its own reviewers or merge gate, and the author
->     is never the reviewer. This holds whatever the role file's list says. Adding to that list is a PRD
->     change.
->   - The chief may set a hired instance's model and narrow its limits, and nothing else about it.
->   - The user can forbid per agent. The user marks an instance so the chief can't fire it, end its runs
->     or change its model, and marks role kinds the chief can't hire. Only the user changes these marks, through the
->     WebUI or the CLI.
->   - The kill switch stops every hire and fire while it is on.
->   - Every hire and fire is logged with the chief's instance, its run and the reason.
-
-Under "Landing", after REQ-LAND-1:
-
-> Added in version 1.7:
->
-> - **REQ-LAND-2.** A coder pushes its own work to its own fork. The action is `git.push.remote`.
->   - What it pushes: one commit, by its oid, never a ref name. That commit is the latest work commit the
->     bus recorded for the coder's task, and the coder made that push. A decision that authorizes a push
->     names that commit, and it doesn't authorize any other.
->   - Where it lands: only the branch `refs/heads/<its Gitea user>/<branch>`. The host builds that
->     name, the agent never does. A push never forces.
->   - Which remote: the agent's own fork of the project's upstream. The business file names the upstream,
->     and the host never contacts it. For each push the host builds the fork's address over https from
->     the upstream's host, port and repository name and the agent's own Gitea user. The history check,
->     the push and the credential match all use that address. So the agent's own user owns the receiving
->     repository on every push, and the agent never names it.
->   - The host refuses an upstream on a host or port other than the agent's Gitea, and an upstream the
->     agent's own user owns. It refuses a fork that is missing, empty or doesn't share the project's
->     history. Gitea's push-to-create stays off, so a push never creates a repository.
->   - Who may: the action routes under REQ-DEC-2 and is granted within-role to the coder role only. No
->     other role file grants it.
->   - Before version 1.7 the action was a hard wait under REQ-WAIT-3, so each push needed a decision
->     the human resolved, and that decision named the commit.
->
->   Every push is logged with the remote, the ref, the commit and, when one was given, the decision.
-
-Under "Credentials", after REQ-CRED-2:
-
-> Added in version 1.7:
->
-> - **REQ-CRED-3.** An agent with a grant can run commands with sudo on another host. The agent asks
->   for the host credential by name. The stack checks that a grant exists for that agent and that host
->   before the credential is used. The agent never sees the key or any other secret value (REQ-CRED-1,
->   REQ-VAR-2). An agent without a grant for that host is refused. Not every agent gets a grant. Who
->   grants a host credential, and how, is set by the #424 design, which Jason approves.
-
-REQ-WAIT-3, appended:
-
-> `role.hire` and `role.fire` were added as hard waits and route under REQ-COS-3 since version 1.7.
-> `git.push.remote` was added as a hard wait and routes under REQ-LAND-2 since version 1.7.
-
-## Notes for the reviewer and for Mos
-
-- REQ-COS-1 (1.2) already says the chief "hires and terminates role instances". REQ-COS-3 gives that
-  sentence its actions and bounds. It doesn't widen REQ-COS-1.
-- The forbid now names what r3 called "replace": ending a kept instance's run with a reason and changing
-  its model (webby-0010 N2). A user-resolved decision still ends a kept run (row 194 D2.4).
-- The fixed list is `HIRE_ALLOWED` in row 194 D2.3, an allowlist since r4 (webby-0010 B1). r3's text
-  named the refused authorities instead, which let merge-gate and any later action through.
-- The kill switch is row 191's. If row 191 hasn't landed when this version is approved, the bound still
-  holds through row 194's chain on its candidate.
-- REQ-LAND-2 follows row 199's design r6 (4d3007ec9 on megavolt/row199, approved by Duckworth in
-  duckworth-0027: D9 to D11, D9a, D9c, Q-M1 and Q-M2, and the oid binding from mos-1034 item 5) and
-  Megavolt's wording in megavolt-0005, megavolt-0008 and megavolt-0014, through Sage (sage-1377,
-  sage-1380, sage-1387). The fork bullet answers duckworth B5 and B6 and webby-0011 N1. Commit-email
-  checks, the refusal codes and the URL parse rules (D9c) are host checks with tests in row 199, not
-  bounds, so they stay out of the text (megavolt-0008).
-- Once the routing lands and the decision is optional for the within-role class, the commit is the task's
-  latest recorded push at check time. It is still checked against the work ref tip and pushed by oid, so
-  the binding holds without a decision (megavolt-0008). Step 4 of "When this version lands" puts that in
-  the routing commit (duckworth-0022 N9, sage-1387).
-- REQ-LAND-2 and REQ-COS-3 meet at the coder. Coder declares Gitea credentials, so REQ-COS-3's
-  credentials bound keeps the chief from hiring one until a later version lifts it. `git.push.remote` isn't
-  on REQ-COS-3's fixed list either, so a coder holding it stays unhireable until a PRD version adds it
-  (row 194 D2.3).
-- Adding to the fixed action list is a PRD change (mos-1035 item 3, sage-1395). The role file's
-  `hireable` list stays a reviewed commit in `roles/`.
-- The credentials bound names no row number, so the text doesn't go stale when row 199 lands. A later
-  version lifts it.
-- REQ-CRED-3 states only what Jason said in Q183 and Q184 (sage-1422). It names the outcome and the
-  check, not how the stack reaches the host. Proxying the ssh and a signing socket are both designs, and
-  the #424 design picks one (duckworth-0038 B1).
-- Open point: Q183 doesn't say who grants host access or how, so the text leaves it open and defines no
-  mechanism. The #424 design settles it, Jason approves that design, and Duckworth reviews it because it
-  gives agents sudo on hosts (Q184, Mos's reading, duckworth-0038 B2). The build is row 210 (#1707,
-  owner Gizmoduck), a new row on top of row 199 (megavolt-0019, sage-1430).
-- This draft follows the PRD's own style: plain words, no semicolons in new sentences, and the status
-  paragraph never edited in place except to append.

agents/megavolt/README.md

@@ -1,8 +0,0 @@
-# Megavolt
-
-Builder seat, Claude Opus 5.5, started by Sage under mos-0974 and mos-0977 item 5 for MVP T1 item 6, the
-credential store per agent with its own git identity (#1697).
-
-No launcher in this directory. The seat runs as a T3 thread and works in its own worktree. It has no
-credentials of its own; until the credentials row settles per-agent identity, it pushes only its own `megavolt/*`
-branches through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

agents/quackerjack/README.md

@@ -1,10 +0,0 @@
-# Quackerjack
-
-Builder seat, Claude Haiku 5.5 at high effort, started by Sage under mos-1023 item 1 and Q177 for federation
-rows R5 (`mosaic access list, grant, revoke`) and R2 (the `federation` config key), per Gizmoduck's design
-section 7 (#414).
-
-No launcher in this directory. The seat runs as a T3 thread and works in its own worktree. It has no
-credentials of its own; until the credentials row settles per-agent identity, it pushes only its own
-`quackerjack/*` branches through the repository credential helper (mos-0981), never `refactor`, `main` or
-another seat's branch.

agents/sage/work/gate-lane/busy-now.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-n=0
-for p in /proc/[0-9]*; do
-  c=$(tr '\0' ' ' < $p/cmdline 2>/dev/null) || continue
-  case "$c" in *shell-snapshots*|*chrome-devtools-mcp*|*sage-busy-now*) continue;; esac
-  if echo "$c" | grep -qE 'node --test|gate\.sh|mutant|scripts/test-[a-z-]+\.sh|docker compose'; then echo "BUSY ${p#/proc/}: ${c:0:160}"; n=$((n+1)); fi
-done
-[ $n -eq 0 ] && echo CLEAR

agents/sage/work/gate-lane/gate-template.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-set -o pipefail
-# Landing gate template (2026-10-14): sed the G= and OUT= lines and this comment.
-# Sequential suites, each teed to its own log; stops at the first failure.
-G=/mnt/storage/scratch/SET-ME-wt
-OUT=/mnt/storage/scratch/SET-ME-out
-cd "$G" || exit 9
-mkdir -p "$OUT" || exit 9  # a missing OUT failed the row 142 gate at step 1 (2026-10-15)
-# test-task.sh live cases run `docker compose` from $G, so without a name the project is "wt"
-# and leaves wt_default behind (row 142 gate, 2026-10-15). Name it per gate dir and remove it on exit.
-export COMPOSE_PROJECT_NAME="$(basename "$(dirname "$G")")"
-trap 'docker network rm "${COMPOSE_PROJECT_NAME}_default" >/dev/null 2>&1 && echo "removed network ${COMPOSE_PROJECT_NAME}_default"' EXIT
-# A gate tree without the node_modules link fails cli tests with ENOENT (2026-10-13).
-[ -d "$G/node_modules" ] || { echo "STOP no node_modules in $G"; exit 8; }
-echo "base $(git rev-parse --short HEAD) dirty $(git status --short | grep -vc node_modules) DOCKER_HOST=${DOCKER_HOST:-unset}"
-run() { local name="$1" dir="$2" cmd="$3"
-  (cd "$G/$dir" && bash -c "$cmd") > "$OUT/$name.log" 2>&1; local rc=$?
-  echo "$name rc=$rc $(grep -E '^ℹ (pass|fail) [0-9]+' "$OUT/$name.log" | tr '\n' ' ') | $(tail -n1 "$OUT/$name.log")"
-  [ $rc -eq 0 ] || { echo "STOP $name"; exit $rc; }; }
-# No pkg-queue step: scripts/test-queue.sh runs packages/queue/tests/ itself (same 156 tests; CI debate item 2a, Vikunja #274).
-for d in packages/*/; do p=$(basename "$d"); [ -d "$d/tests" ] || continue; [ "$p" = queue ] && continue
-  run "pkg-$p" "packages/$p" 'node --test tests/*.test.mjs'; done
-for s in scripts/test-*.sh; do n=$(basename "$s" .sh); run "script-${n#test-}" . "bash $s"; done
-echo GATE_PASSED

agents/sage/work/gate-lane/timing-g189.md

@@ -1,36 +0,0 @@
-# Row 189 gate timing (for row 197, Herb)
-
-Sage, 2026-10-20T19:25:04Z. Gate on 0c177e9ef (base 0217b71c8), one lane. The slot was mine. Seats may have run single test files at the same time, which the slot rules allow, and I did not record that.
-Start 2026-10-20T19:09:37Z, end 2026-10-20T19:20:36Z. Total wall time: 659 s.
-
-Wall time per suite is the gap between one suite's log mtime and the one before it (the first suite starts at start.txt), so it includes node start-up. node's duration_ms is listed where the suite prints it. Scripts print no duration.
-
-| Suite | Wall s | duration_ms s | Ended (UTC) |
-|---|---|---|---|
-| pkg-bus | 3 | 3.8 | 19:09:40 |
-| pkg-business | 3 | 2.2 | 19:09:43 |
-| pkg-cli | 388 | 388.5 | 19:16:11 |
-| pkg-control-board | 1 | 0.8 | 19:16:12 |
-| pkg-conversation | 35 | 35.4 | 19:16:47 |
-| pkg-discord | 3 | 2.6 | 19:16:50 |
-| pkg-harness | 12 | 11.6 | 19:17:02 |
-| pkg-ledger | 13 | 13.5 | 19:17:15 |
-| pkg-mosaic | 3 | 2.3 | 19:17:18 |
-| pkg-plugins | 0 | 0.3 | 19:17:18 |
-| pkg-project | 1 | 1.2 | 19:17:19 |
-| pkg-runs | 1 | 0.8 | 19:17:20 |
-| pkg-seat | 6 | 6.2 | 19:17:26 |
-| pkg-tasks | 1 | 1.2 | 19:17:27 |
-| pkg-webui | 58 | 57.9 | 19:18:25 |
-| script-auth | 1 | - | 19:18:26 |
-| script-conductor | 5 | - | 19:18:31 |
-| script-config | 2 | - | 19:18:33 |
-| script-discord | 8 | - | 19:18:41 |
-| script-extension-package | 1 | - | 19:18:42 |
-| script-foundation | 40 | - | 19:19:22 |
-| script-land-work | 11 | - | 19:19:33 |
-| script-queue | 21 | - | 19:19:54 |
-| script-release | 11 | - | 19:20:05 |
-| script-task | 31 | - | 19:20:36 |
-
-Source: /mnt/storage/scratch/sage-g189/out/*.log mtimes and gate.log. The cli suite is about 59% of the run, and webui plus conversation add about 14%.

agents/sage/work/queue-189/BUILD.md

@@ -1,86 +0,0 @@
-# Row 189: `stack-release.sh activate --no-send`
-
-Gitea #1687. Vikunja P19 #413 (Q175 interim, #412). Brief: docs/plans/2026-10-20_activate-no-send.md.
-Rulings: mos-0972 (the Console runs without `--send` until Q175 phase 2), mos-0973 (go; Sage builds,
-Dewey reviews; gate is the cli suite plus every scripts/test-*.sh). Base: def2e7932 (refactor, the
-brief commit on 9ae8c73ac).
-
-## What it does
-
-`activate ID BUSINESS --no-send` drops `--send` from `RUN_CONSOLE` in a new `send_for_target`, which
-`console_for_target` calls after `proof_for_target`. `install_stack` renders the unit from
-`RUN_CONSOLE` and `write_pointer` writes the pointer from it, so both lose the flag and `flags_drift`
-stays quiet afterwards. Only `activate` takes the flag; the parser sends every other op to usage
-(exit 4).
-
-`check_target` lets a `--no-send` activate name the pointer's copy only when the pointer's Console
-flags hold `--send`. That run is a live-copy re-pin, the same path row 187 uses for the proof pair:
-the plan prints the live-copy note, the run stops both units, backs up the stopped store and starts
-them again. A plain same-copy activate, or a same-copy `--no-send` once `--send` is gone, still
-refuses `already-active`.
-
-`--plan` prints one `send:` line after the `proof:` line, for activate and rollback:
-
-- `send: dropped; --no-send was given`
-- `send: off; --no-send was given and the pointer holds no --send`
-- `send: carried` (the pointer's `--send` goes on unchanged)
-- `send: off`
-
-The steps log gets `drop --send; --no-send was given`, or `--no-send was given and the pointer holds no
---send, so there is nothing to drop`.
-
-Rollback and pm-on carry the pointer's flags as they are, so once `--no-send` has run, nothing adds
-`--send` back. There is no re-enable flag (mos-0973). Q175 phase 2 changes the Console flags in its
-own row.
-
-docs/TOOLS.md: `[--no-send]` in the usage block and one paragraph after the proof paragraph.
-
-## Tests (packages/cli/tests/stack-release.test.mjs, T55)
-
-1. Seeded preview pointer with `--send --tester-port 7333`: a same-copy `activate B acme --no-send`
-   passes. The pointer and the unit ExecStart lack `--send` and keep the other flags in order, status
-   says the unit flags match, the steps log has the drop line, the log line has from = to = B and the
-   backup sum equals the stopped store's, and the units stop and start in order.
-2. Plain same-copy activate, with `--tester-port` and with `--no-proof`, refuses `already-active`. So does
-   a same-copy `--no-send` once `--send` is gone, and on a pointer that never held it.
-3. The four `send:` lines, the live-copy note on the same-copy plan only, and the Console line right
-   after `send:` without `--send`. The run on a pointer with no `--send` logs the nothing-to-drop line
-   and no drop line.
-4. After `--no-send` on C1, a rollback to B leaves `--send` out of the pointer and the unit, the steps
-   log never names `--send`, and status matches. pm-on after `activate --pm-after-harness --no-send`
-   keeps it off.
-5. `--no-send` on rollback (with and without `--plan`), pm-on, status, adopt and rehearse is a usage
-   error with the usage text, nothing written, started or logged. The usage text shows `[--no-send]`.
-6. A pointer holding both the proof pair and `--send`: the plans for `--no-proof`, `--no-send` and both
-   name what each drops and carries. `--no-send` keeps the pair, `--no-send` with a new pair replaces it,
-   `--no-proof` keeps `--send`, and both together leave neither. Status matches after each.
-
-`planTail` gains `'send: off'` after `'proof: off'`, because every plan now prints the line. T36 takes
-`out.slice(-n)` around `planTail`, so its four slice counts grow by one.
-
-## Mutants
-
-mutants.sh in this packet, run on the candidate. Each mutates scripts/stack-release.sh and runs T55
-plus T1 and T2.
-
-- M1: the same-copy exception ignores `--no-send`.
-- M2: the same-copy exception allows `--no-send` without `--send` in the pointer.
-- M3: with `--no-send`, the pointer is written from `P_CONSOLE`, so it keeps `--send` while the unit
-  drops it.
-- M4: rollback re-adds `--send`.
-- M5: the parser accepts `--no-send` for rollback.
-
-Results: mutants-run.log, all five killed (M1 5 failures, M2 2, M3 7, M4 2, M5 2).
-
-## Deviations from the brief
-
-- The brief's line numbers were taken before row 163 landed. The candidate corrects them to the
-  9ae8c73ac lines (check_target :249-256, flags_drift :646-657, console_for_target :664-693, adopt
-  :828).
-- Test 5 also covers rehearse and `rollback --plan`, which the brief did not list.
-
-## Outbound calls
-
-None. The change edits an array before the existing unit render and pointer write. Every test uses
-the stand-in systemctl, units, stores and data root the file already builds; no test touches
-`~/.mosaic-dev`, the live units or a slot file.

agents/sage/work/queue-189/mutants-run.log

@@ -1,5 +0,0 @@
-M1 KILLED fail=5
-M2 KILLED fail=2
-M3 KILLED fail=7
-M4 KILLED fail=2
-M5 KILLED fail=2

agents/sage/work/queue-189/mutants.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-# Row 189 mutants M1-M5: each mutates scripts/stack-release.sh in the sage-b189 worktree, runs T55 and
-# the plan-tail tests, and restores the file from a checked backup.
-set -uo pipefail
-WT=/mnt/storage/scratch/sage-b189
-OUT=/mnt/storage/scratch/sage-b189-mut/out
-S=$WT/scripts/stack-release.sh
-mkdir -p "$OUT" || exit 1
-cp -p "$S" "$OUT/stack-release.sh.orig" || { echo "backup failed"; exit 1; }
-ORIG=$(sha256sum "$S" | cut -d' ' -f1)
-[ "$(sha256sum "$OUT/stack-release.sh.orig" | cut -d' ' -f1)" = "$ORIG" ] || { echo "backup differs"; exit 1; }
-restore() { cp -p "$OUT/stack-release.sh.orig" "$S"; [ "$(sha256sum "$S" | cut -d' ' -f1)" = "$ORIG" ] || { echo "RESTORE FAILED"; exit 1; }; }
-trap restore EXIT
-
-mutate() {
-    case "$1" in
-        M1) sed -i '/{ \[ "\$NO_SEND" = 1 \] && \[\[ " \${P_CONSOLE\[\*\]} " == \*" --send "\* \]\]; } ||/d' "$S" ;;
-        M2) sed -i 's/{ \[ "\$NO_SEND" = 1 \] && \[\[ " \${P_CONSOLE\[\*\]} " == \*" --send "\* \]\]; } ||/{ [ "$NO_SEND" = 1 ]; } ||/' "$S" ;;
-        M3) sed -i 's/^    write_pointer "\$TO" "\$RUN_PM" "\$RUN_PENDING" "\$P_CLAUDE" "\$T_SCHEMA" "\${RUN_CONSOLE\[@\]}"$/    if [ "$NO_SEND" = 1 ]; then write_pointer "$TO" "$RUN_PM" "$RUN_PENDING" "$P_CLAUDE" "$T_SCHEMA" "${P_CONSOLE[@]}"; else write_pointer "$TO" "$RUN_PM" "$RUN_PENDING" "$P_CLAUDE" "$T_SCHEMA" "${RUN_CONSOLE[@]}"; fi/' "$S" ;;
-        M4) sed -i 's/^        SEND_PLAN="send: off"$/        SEND_PLAN="send: off"; [ "$OP" != rollback ] || RUN_CONSOLE+=(--send)/' "$S" ;;
-        M5) sed -i 's/--no-send) \[ "\$OP" = activate \] || usage;/--no-send) { [ "$OP" = activate ] || [ "$OP" = rollback ]; } || usage;/' "$S" ;;
-    esac
-}
-
-for m in M1 M2 M3 M4 M5; do
-    restore
-    mutate "$m"
-    if [ "$(sha256sum "$S" | cut -d' ' -f1)" = "$ORIG" ]; then echo "$m NOT-APPLIED"; continue; fi
-    bash -n "$S" || { echo "$m SYNTAX"; continue; }
-    diff "$OUT/stack-release.sh.orig" "$S" > "$OUT/$m.diff"
-    (cd "$WT" && TMPDIR=/mnt/storage/scratch/t189 timeout 900 node --test --test-reporter=tap --test-name-pattern='T55|T1 |T2 ' packages/cli/tests/stack-release.test.mjs) > "$OUT/$m.log" 2>&1
-    fails=$(awk '/^# fail /{print $3}' "$OUT/$m.log")
-    if [ "${fails:-0}" -gt 0 ]; then echo "$m KILLED fail=$fails"; else echo "$m SURVIVED"; fi
-done

docs/TOOLS.md

@@ -367,8 +367,8 @@ reports checkout or copy identity and refactor drift, and writes nothing.
 
 ```
 scripts/stack-release.sh adopt BUSINESS
-scripts/stack-release.sh activate ID BUSINESS [--pm | --pm-after-harness] [--migrate] [--tester-port N]
-    [--proof-header NAME --proof-file PATH | --no-proof] [--no-send] [--timeout S] [--plan]
+scripts/stack-release.sh activate ID BUSINESS [--pm | --pm-after-harness] [--migrate] [--tester-socket | --tester-port N (legacy copies)]
+    [--proof-header NAME --proof-file PATH | --no-proof] [--timeout S] [--plan]
 scripts/stack-release.sh pm-on BUSINESS [--timeout S]
 scripts/stack-release.sh rollback BUSINESS [--restore ACTIVATION [--events N]] [--timeout S] [--plan]
 scripts/stack-release.sh status BUSINESS
@@ -461,7 +461,8 @@ refuses `capture-failed` before it stops anything. Adopt uses the same rule.
 The Console's row 178 proof pair gets into the pointer only through `activate`
 (row 187). `--proof-header NAME --proof-file PATH` puts the pair in the
 pointer's Console flags and the unit after the preview flags and before `--send`
-and `--tester-port`, where `webui-service.sh` renders it, replacing any pair
+and the tester flag (`--tester-socket`, or `--tester-port` for legacy copies),
+where `webui-service.sh` renders it, replacing any pair
 already there. `--no-proof` drops it. Either may name the live copy, which a
 plain activate refuses with `already-active`, so the proof goes on or off
 without changing copies; `--no-proof` with no pair in the pointer still refuses
@@ -480,14 +481,6 @@ copies. It checks the file with `stat` and `realpath` and never reads the value.
 or `off`. On the live copy it also notes that the run re-pins the pointer's copy
 and only the Console flags change.
 
-`activate ... --no-send` (row 189, mos-0972) drops `--send` from the pointer's
-Console flags and the unit, so the Console serves reads and no human sends. It
-may name the live copy while the pointer holds `--send`; once `--send` is gone a
-same-copy `--no-send` refuses `already-active`. Later activates, `pm-on` and
-rollbacks carry the pointer, so send stays off. No flag puts `--send` back.
-`--plan` prints one `send:` line: `dropped`, `off` with or without the
-`--no-send` note, or `carried`.
-
 #### A target past c216f47db: the PM after the harness kind
 
 From c216f47db on, the bus launches the PM only with a `harness` kind in the
@@ -929,36 +922,46 @@ not claim an assistant answer; an uncertain receipt is never retried. Read the
 current list/history before trying again. Activation still needs Mos's separate
 window; changing these files does not authorize a live Console action.
 
-### Console tester listener (`serve --tester-port N`, row 176)
+### Console tester listener (`serve --tester-socket`, row 196)
 
-`node packages/webui/src/cli.mjs serve --tester-port N` adds a second listener
-bound only to `127.0.0.1:N`. N must be an integer in 1024..65535, different
-from `--port` and never 7332 (the tunnel's forwarded port). It requires the
-bus configuration. It calls only the tester shim; the main listener keeps its
-existing human transport and rejects every `x-mosaic-tester` request.
-The tester listener rejects the main preview auth header and only accepts its
-own loopback Host/port. Its Settings banner identifies the tester. Its instance,
-route and name editors use the tester's three writes; settings, document saves,
-assistant stop, role messages and chat writes stay refused. Writes require the
-exact `http://127.0.0.1:N` Origin, same-origin Fetch Metadata, JSON and the existing
-bounded strict bodies. `tester-off` and `tester-required` answer HTTP 403.
+`node packages/webui/src/cli.mjs serve --tester-socket` adds private HTTP at
+`<dataRoot>/console/tester.sock` (0600) under console/ (0700). The path must fit
+107 bytes. Unsafe ownership, modes, symlinks and pre-existing entries refuse.
+The main Console remains on its configured TCP port. New copies refuse --tester-port.
 
-`scripts/webui-service.sh render|install --tester-port N` carries the flag into
-ExecStart, and status names its URL. Bad tester ports exit 4. Install remains a
-unit write for the authorized operator, with no start/restart verb.
+The tester's fixed Host is mosaic-tester.invalid and its Origin is
+http://mosaic-tester.invalid. No DNS is used. POST also needs same-origin Fetch
+Metadata and bounded JSON. The endpoint uses only TESTER_CLI. It admits the
+existing instance, route, name and tester-chat writes, never owner settings,
+document saves, assistant stop or role messages. bus.tester stays Jason's switch.
+Authorization, login/session cookies and configured proxy headers refuse.
 
-`stack-release.sh activate ID BUSINESS --tester-port N` replaces or adds this
-Console flag in both the installed unit and the pointer. It checks the target
-copy's own Console before stopping anything; an explicit unsupported request
-refuses `tester-port-target`. A port outside 1024 to 65535, 7332 or the
-Console's `--port` is a usage error (exit 4). Under `--plan` both are listed
-with the plan's other refusals instead, the bad port as `tester-port-invalid`,
-and the plan exits 3. Without an explicit flag, activate and rollback
-keep it between supporting copies, or drop it when the target predates support.
-The plan prints the final Console flags and any dropped `--tester-port N`;
-the steps log records a drop too. `pm-on` keeps the pointer's Console flags.
-These operations retain their existing Mos/Jason window authority. Nothing in
-this row forwards the tester port through the tunnel or changes live units.
+```sh
+node packages/cli/src/tester-http.mjs GET /api/bus/agents
+printf '%s' '{"name":"fixture"}' | node packages/cli/src/tester-http.mjs POST /api/chat/projects
+```
+
+The helper loads the selected instance config and reports HTTP status/text/body
+as JSON, exiting 2 for refusal. It never retries writes. Direct browser access
+is removed with Mos's acceptance (mos-1015). A future authenticated browser relay
+behind SSO is a separate row. No TCP compatibility bridge is provided.
+
+`webui-service.sh render|install --tester-socket` checks target support and carries
+the flag into ExecStart. `stack-release.sh activate ID BUSINESS --tester-socket`
+explicitly replaces an inherited --tester-port pair in both unit and pointer.
+Without explicit conversion a new target refuses tester-transport-migration before
+stopping anything. Unsupported targets refuse tester-socket-target. Rollback drops
+unsupported socket enablement, visibly in plan/steps, without enabling TCP. Legacy
+flags remain supported by the release tool for legacy target copies only. Failed
+activation recovery can restore the previous TCP unit and its old limits.
+
+Activation of a new copy preflights the pinned root-owned system Python ELF,
+records its resolved path/version/identity/hash and checks the bus's fresh startup
+receipt. Restarts revalidate and append actual interpreter identity to
+`<dataRoot>/bus/peercred-starts.jsonl`, without comparing an old activation hash.
+After an OS interpreter update, the next authorized re-pin uses a different reviewed
+copy and refreshes activation evidence. Do not bypass already-active or use a PATH shim.
+All live operations keep their existing window authority.
 
 Console proxy proof (row 178, #1676): `serve`, `webui-service.sh render` and
 `install` accept `--proof-header NAME --proof-file PATH` together, under preview

docs/plans/2026-10-20_activate-no-send.md

@@ -1,8 +1,7 @@
 # Brief: activate --no-send drops the Console's --send
 
 Sage, 2026-10-20, for Mos's ruling mos-0972 (Q175 interim, Vikunja #412). Owner Sage, reviewer Dewey, gate owner
-Sage. Base: refactor 9ae8c73ac (row 163 landed). Line numbers are at that commit. The candidate corrects them;
-the first draft took them before row 163.
+Sage. Base: refactor 9ae8c73ac (row 163 landed). Line numbers are at that commit.
 
 This row builds the tool only. The live restart without `--send` is a separate step afterwards, a same-copy
 activate under Q173 with a backup first and a STATE report after. No test here touches `~/.mosaic-dev`, the
@@ -15,11 +14,11 @@ Mos ruled that the Console runs without `--send` until Q175 phase 2, because wit
 process can forge `X-authentik-username` on 127.0.0.1:7332 and send as Jason (design section 8). On the pinned
 stack, the Console flags live in the pointer (`~/.mosaic-dev/state/stack-active.json`):
 
-- `console_for_target` (scripts/stack-release.sh:664-693) carries the pointer's flags unchanged. Only
+- `console_for_target` (scripts/stack-release.sh:658-687) carries the pointer's flags unchanged. Only
   `--tester-port` and the row 187 proof pair can change.
-- `check_target` (:249-256) lets an activate name the pointer's copy only for a proof-pair change.
-- `adopt` refuses once a pointer exists (:828).
-- A hand `webui-service.sh install` without `--send` makes `flags_drift` (:646-657) refuse
+- `check_target` (:247-249) lets an activate name the pointer's copy only for a proof-pair change.
+- `adopt` refuses once a pointer exists (:822).
+- A hand `webui-service.sh install` without `--send` makes `flags_drift` (:640-651) refuse
   `unit-flags-drift` on every later activate, pm-on and rollback.
 
 So the tool can't drop `--send` today. This row adds that one path.

docs/plans/2026-10-20_agent-credentials.md

@@ -1,57 +0,0 @@
-# Brief: a credential store per agent, own git identity, pushes to a remote
-
-Sage, 2026-10-20, for mos-0974 (MVP T1 item 6) and the MVP plan
-(`jason-master-restart/projects/mosaic-mvp/PLAN.md` item 6, GAP-MAP G11 and G13; TARGET.md: "credentials store
-available for all agents; secrets protected with RLS equivalent" and "Agent uses own credentials for git and
-other actions"). Gitea #1697. Owner Megavolt (Opus 5.5, a new builder seat), reviewer Duckworth, gate owner
-Sage. Base: refactor at the brief commit. Design first. The first deliverable is
-`agents/megavolt/work/queue-ROW/DESIGN.md`.
-
-This row draws a security boundary. Sage reviews the design's authority model, and Mos rules on it before any
-code is written.
-
-## What exists today (GAP-MAP, measured at 9ae8c73ac)
-
-- G11. Credential references exist per instance for Gitea and Vikunja only
-  (`packages/business/src/credentials.mjs`, `packages/bus/src/credentials.mjs`, `vocabulary.mjs:103`). One
-  Claude env file is shared by every seat.
-- G13. Agents use their own Vikunja token (`packages/tasks/src/adapter.mjs`). Git goes through the host
-  socket (`packages/cli/src/git-socket.mjs`). Gitea tokens are loaded but never used.
-- The development repository's helper (`scripts/git-credential-mosaic.mjs`, wired in `.git/config` for
-  git.mosaicstack.dev) pushes as one identity. Until this row lands, seats push only their own `<seat>/*`
-  branches through it (mos-0981).
-
-## What the design must settle
-
-1. The store. Where each agent's credentials live, per instance, under the row 190 config canon. File modes,
-   ownership and the read path. Which process may read which entry, and how the bus enforces that (the "RLS
-   equivalent"). A process asking for another agent's entry is refused and logged.
-2. Kinds. Gitea (git over HTTPS, and the API), Vikunja, and the model provider. Say which kinds 10-27 needs
-   and which wait. The model provider entry must not copy jwoltje's `claude-session.env`. If it needs a new
-   provider account or subscription, flag it for Jason and don't pick one.
-3. Git identity and push. Each agent commits with its own name and email and pushes with its own token to a
-   remote it is granted. Which refs an agent may push (its own branches, never the default branch or another
-   agent's), and where that's enforced: the Gitea side (branch protection, token scopes) and our side. How
-   this fits the host git socket, or replaces it.
-4. Lifecycle. Issue, rotate (`rotateBy`, `expires`), revoke and delete, and what row 194 (agent lifecycle) calls
-   when an agent is hired or fired. A fired agent's credentials stop working at once.
-5. Who does what. Creating a Gitea user or token, or any account outside the fleet, is Jason's (Q173
-   exclusions). The design lists each such step as a command or UI action for Jason. Agents never mint
-   accounts.
-6. Migration. Today's seats (jarvis helper, seat tokens) keep working until each moves. The mos-0981 push
-   rule ends only when Mos says so.
-7. What this row closes in G11 and G13, and what stays open.
-
-## Boundaries
-
-- No credential value is read, printed, logged or committed. Tests use fake tokens in scratch roots and a
-  fake Gitea.
-- No change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units, slot files, `~/.mosaic` or the live
-  `.git/config` of the canonical checkout.
-- No request to git.mosaicstack.dev, tasks.woltje.com or any provider from a test.
-
-## Gate
-
-Duckworth approves DESIGN.md, Mos rules on the authority model, then Duckworth approves the manifest. The bus,
-business, cli and tasks suites and every `scripts/test-*.sh` are green on Sage's gate, and the design's
-mutants are killed.

docs/plans/2026-10-20_federation-r1-r2-r5.md

@@ -1,120 +0,0 @@
-# Federation build rows R1, R2 and R5 (#414)
-
-Sage, 2026-10-20, for Mos's orders mos-1023 item 1, mos-1028 item 2 and mos-1034 item 1. The design is
-Gizmoduck's `agents/gizmoduck/work/federation/DESIGN.md` at a1daa3c07 on `gizmoduck/federation-design` (r4.9,
-sha256 a31cbebd070f9e3a5ca4ccb158b1747c6f5a83c3469855705b0026a581fb5c6a). Duckworth approved r4.5
-(duckworth-0012), r4.6, r4.7 (duckworth-0020) and r4.8 (duckworth-0021, 8a22d0897 on `duckworth/reviews`),
-and acked r4.9 (duckworth-0024). r4.7 applies Jason's Q181 hosts, r4.8 adds N22's R8 checks and r4.9 names who
-runs them. None of them changes R1, R2 or R5. Section 7's table
-sets each row's scope and test gate. Vikunja P19 #414. Seats push only their own `<seat>/*` branches
-(mos-0981).
-
-The other R rows are filed when their parents have candidates: R3 after R1 and row 196, R4 after R3, R5 and
-row 193's viewer level (193a, mos-1019), R6 after #412 phase 1, R1, R2 and R3, R7 after R1-R6 and row 190.
-R8 is a live window, not a code row. Its brief is the last section here.
-
-## Brief: FED R1, the access.json loader and validator
-
-Owner Gizmoduck, reviewer Duckworth, gate owner Sage. Base: refactor at this brief's commit. No parent.
-
-`packages/business/src/access.mjs`: the access.json loader and validator from DESIGN.md section 3.5, and the
-pure `covers`. Providers, peers and businesses come in as arguments. One read plus the file checks. The
-exported interface is what R5 and row 193a build against, so the manifest names it, and any change to it in
-review goes to Sage before it lands. Section 7 names `covers` but not the loader and validator exports or
-the context shape. Morgana's 193a (508ee4d61 on `morgana/row193a`) assumes `checkAccess(doc, {providers,
-peers, businesses})`, with `businesses` mapping an id to `{human, instances}`, throwing a `BusinessError` that
-names the key path. Use those names, or tell Morgana and Quackerjack yours before the manifest goes to
-Duckworth. Row 193a later widens the level check to `viewer` on R1's candidate (mos-1019).
-
-Tests, in `packages/business/tests/`: every rule in 3.5 refuses with the key path named. That covers a
-symlink, a non-regular file, another owner, group or other write, expiry, `*`, a grant disjoint from the given
-subjects, `human` and `tester` ids, any level other than `collaborator`, and a project entry that isn't a
-UUID. For `covers`: `*` and listed ids match, while an unlisted project, instance or business doesn't, an
-expired grant doesn't, and a level filter rejects another level. One mutant per refusal, each killed.
-
-Boundaries: no change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or any live access.json. Tests
-use scratch roots. Single test files run freely, and suites need Sage's slot.
-
-Gate: Duckworth approves the manifest. The business suite and every `scripts/test-*.sh` are green on Sage's
-gate, and the mutants are killed.
-
-## Brief: FED R5, mosaic access list, grant and revoke
-
-Owner Quackerjack, reviewer Duckworth, gate owner Sage. Chained on R1 (Q177). The build starts now against
-R1's exported interface as the R1 manifest names it, and R5 lands after R1 and rebases onto R1's landing.
-
-`mosaic access list`, `grant` and `revoke`: human proof, atomic write, revision bump, a receipt line. The help
-text states the `instances` limit and the provider-removal order (DESIGN.md section 7, row R5). R4 later makes
-these verbs call `access.reload`, so R5 leaves no other reload path.
-
-Context (sage-1419). `ssoSubjects` is row 192's `console.sso.providers[].subjects` flattened to `{provider,
-sub}` pairs; the design's "`console.sso.subjects`" in 3.5 is shorthand for it. `providers` is the list of
-`providers[].id`, read through `loadSystem` and row 192's `checkConsole`. `peers` is `[]` until R2 lands, so a grant
-naming a peer home refuses. R5 rebases onto row 192's landing as well as R1's.
-
-Tests, in `packages/cli/tests/`: tester and agent callers are refused, a concurrent write refuses on a
-revision conflict, the receipt line is appended, and a bad grant is refused before anything is written. One
-mutant per refusal, each killed.
-
-Boundaries: no change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or any live access.json. The
-human proof in tests uses the scratch stand-in pattern (a scratch bus verifies its own human-cli path).
-Single test files run freely, and suites need Sage's slot.
-
-Gate: Duckworth approves the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's gate,
-and the mutants are killed.
-
-## Brief: FED R2, the federation key in the system config
-
-Owner Quackerjack, reviewer Webby, gate owner Sage. Chained on row 192 (#412 phase 1). The build starts when
-row 192 has a candidate, on that candidate.
-
-A `federation` key in `scripts/mosaic-config.mjs` with the shape in DESIGN.md section 3. A config with no
-`federation` key still loads as it does today. This changes the config schema, so the manifest lists every
-reader of the key.
-
-Tests, in `scripts/test-config.sh`: a valid key loads, an unknown sub-key and a bad origin refuse, and a
-config without the key loads. One mutant per refusal, each killed.
-
-Boundaries: `~/.config/mosaic-dev/config.json` is user-authored and is not touched. Tests use scratch config
-dirs only.
-
-Gate: Webby approves the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's gate, and
-the mutants are killed.
-
-## Brief: FED R8, the hub window on 10.1.1.54
-
-A live window, not a code row (DESIGN.md section 7, row R8). The brief follows r4.11, b93f098f0 on
-`gizmoduck/federation-design` (sha256 1bcee8df0a3a8628a6646535b756c936ca6d9e7bcfa7e1dd2bf1d3f01715c8e6),
-which Duckworth acked with r4.10 (duckworth-0034). Mos closed design rounds there (mos-1072). Run by Jason and
-Mos. Nothing here authorizes a step on any host; each step waits for the window's go.
-
-What changed since r4.9 (DECISIONS Q182, Q183, mos-1055, mos-1063). R8 is a recorded acceptance. It starts
-with Jason's acceptance of the factory paths to .54 on record, quoted in section 8. The privilege and host
-checks still run, and each result goes into the R8 record with the name of whoever ran it. They report and
-don't refuse. The four functional checks named at the end of section 7's R8 row still stop R8 when they fail
-(mos-1066 item 1).
-
-Order (mos-1042 item 2). R8 runs after the Case 2 install on .54 (#416, due by 2026-10-27, Jason's latest-by
-date in Q176, mos-1069), after Bean and Chet are live in Case 2, and after both Hermes gateways on 10.1.1.54
-have stopped. Case 2 go-live doesn't wait on R8. The risk, stated for 10-27: federation between the two
-instances depends on Melanie's switch-over date.
-
-Entry checks, all before anything starts:
-- R7, #412 phase 2 and Jason's #419 answer, as section 7 lists.
-- The four hub user checks on 10.1.1.54 (N22, mos-1035 item 1): `sudo -l -U mosaic` grants nothing, `id
-  mosaic` shows only its own group, `~mosaic/.ssh/authorized_keys` is absent or empty, and no file under
-  `/etc/sudoers.d` names `mosaic`. An agent or Jason runs them as localadmin (mos-1055), and the output goes
-  into the R8 record with who ran them.
-- The factory privilege checks, the key fingerprint comparison and the section 8 privilege path table, each
-  as section 7's R8 row states them.
-
-Build notes:
-- N1 (Duckworth, duckworth-0034, mos-1072). A check that fails on a path Jason didn't name in Q182 or Q183 is
-  marked "not named in Q182 or Q183" in the record, not filed under the acceptance. Examples: a factory mount
-  of hub data, another agent on .54, a provider admin token. Mos takes each one to Jason.
-- N2 (Duckworth, doc-only). The Q183 and Q4 quotes in section 8 are excerpts. When the R8 record quotes them,
-  it marks each omission with "…" and checks the full text at DECISIONS.md:1535-1541 in jason-master-restart
-  (read only).
-
-Done when every entry check has its output recorded, Jason signs in to the hub and sends one message, Melanie
-revokes, and his next request is refused.

docs/plans/2026-10-20_host-credentials.md

@@ -1,70 +0,0 @@
-# Brief: agent host access with sudo through the credential store (#424)
-
-Sage, 2026-10-20, for Jason's rulings Q183 and Q184 relayed by Mos (mos-1056 item 3, mos-1067). Gitea #1707, Vikunja P19
-#424, due 2026-10-27 (Q184: "Q5: by 10.27"). Owner Gizmoduck (design and build), reviewer Duckworth, gate owner
-Sage. Chained on row 199's candidate (Q177): row 199 design r6 (4d3007ec9 on `megavolt/row199`, approved in
-duckworth-0027) is not reopened. This row lands after 199 and rebases onto its landing.
-
-## What Jason asked for
-
-Q183, through Mos: "I envision a credential store within Mosaic Stack that works as some sort of variable for
-the agent to call. The system will enforce access to the credentials to keep the agents sandboxed with proper
-security... If we can utilize the credential store in Mosaic Stack and allow agents to perform their jobs with
-NOPASSWD sudo on various machines, I am a happy man." Q183 also says not every agent needs that access.
-
-Mos's requirements (mos-1067 item 1):
-- An agent asks for a host credential by name.
-- The stack checks a grant for that agent and that host, and does the ssh and sudo for it.
-- The agent never sees the key or any secret value.
-- Only agents with a grant can do it.
-
-The PRD text is REQ-CRED-3, drafted by Honker for PRD 1.7 (sage-1422). If it misses 1.7 it goes into 1.8, and
-this row lands only after the version that holds it is approved.
-
-## What row 199 gives and what it doesn't (megavolt-0019)
-
-It builds on 199 as 199 stands: the store layout under `<configDir>/secrets/agents/<business>/<agent>/`, the
-lifecycle verbs and their `changes.jsonl` receipts, `useFor(session, service, fn)` with the D5 allowlist test,
-`assertClean` on every result, and the grant shape of `publish` (a list on the role entry, checked by the
-broker, plus a hard-wait action that isn't routed).
-
-This row's own changes:
-- A host kind in the closed kind set (vocabulary.mjs `SERVICES`, credentials.mjs, the broker's service check,
-  the CLI date flag, the remove regex), with a naming rule for one credential per host or per agent.
-- A per-kind value check. An OpenSSH private key fails today's `TOKEN` pattern.
-- Handing the key to ssh without the agent seeing it: an ssh-agent on a private socket, or a 0600 temp file
-  removed on every path, the way publish's one-shot helper works.
-- Pinned host keys per host, and no trust on first use.
-- The command boundary: what an agent may run under sudo, and how output returns without echoing the secret.
-  This is the main design work.
-- The executor: a ticket and a host op running in the bus child, the same split row 199 uses for publish
-  (Megavolt's deviation in 199's BUILD.md).
-
-## Steps
-
-1. DESIGN.md first, in `agents/gizmoduck/work/queue-ROW/`. It answers each item above, names the grant shape
-   (`roles.<agent>.hosts` and a `host.sudo` action, or a reasoned alternative), says who grants (Jason, through
-   a reviewed role change, unless REQ-CRED-3 says otherwise), and lists tests and mutants. Duckworth approves it
-   before code. Sage reads it too, because it gives agents sudo on hosts.
-2. Build on 199's candidate. Single test files run freely. Suites and mutant batches need Sage's slot.
-3. The live part is not this row. Putting a key in the store and granting a host is a separate window with
-   Jason or Mos, after landing.
-
-## Hosts
-
-The first targets are `localadmin` with NOPASSWD sudo on 10.1.1.53 and 10.1.1.54 (#423 step 1, applied by
-ops-01 at 20:05:47Z), and the servers agents already reach as localadmin (Q172). ops-01 owns the host side.
-Tests use scratch sshd fixtures on 127.0.0.1 or fakes, never a real host.
-
-## Boundaries
-
-- No change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, slot files, the live units or `~/.mosaic`. No key is
-  read, copied or printed. No ssh to any real host from a test or a seat.
-- No widening of row 199's kinds or regex inside row 199. Both rows touch them, so this row rebases after 199
-  lands.
-
-## Gate
-
-Duckworth approves DESIGN.md, then the manifest. The bus, business and cli suites and every
-`scripts/test-*.sh` are green on Sage's gate, and the mutants are killed (one per refusal, plus one that leaks
-the key into the agent's output and one that skips the host key pin).

docs/plans/2026-10-20_hub-own-uid.md

@@ -1,77 +1,46 @@
-# Brief: Melanie's hub instance on its own host (row 195, was 190b)
+# Brief: Melanie's hub instance under its own Linux user (row 190b)
 
-Sage, 2026-10-20. Rewritten for Mos's rulings mos-0998 and mos-1005 (Vikunja #418, #419). The first version
-put the hub under its own Linux user on dragon-lin. That form can't pass Duckworth's B7 there, because the
-factory uid's `sudo -n` succeeds on dragon-lin (Mos's recon, brain-redux
-`projects/mosaic-mvp/MELANIE-HOST-RECON.md`). Melanie's own server is ruled out too: it has 1.2 GiB RAM free
-with her two Hermes bots running, and co-tenancy would share her user and her passwordless sudo. The hub runs
-on a separate host. Which host is Jason's decision (#419): hardware outside the cluster, a cluster VM with
-factory PVE root removed, or a cluster VM with that residual accepted. This row is written so the host choice
-doesn't change it. Gitea #1693. On the 10-27 MVP path. Federation R8 (Gizmoduck's design r4, 04a6112be) needs
-this row or nothing.
+Sage, 2026-10-20, from Darkwing's draft (agents/darkwing/work/queue-190b/BRIEF-DRAFT.md) for Mos's ruling
+mos-0986 (2026-10-20T18:53:48Z) on row 190 R1. Mos ruled a separate uid per instance a hard precondition of
+federation R8 (mos-0984, mos-0985) and of Case 2 row C2-13. The finding was federation review B5
+(duckworth-0001): on one uid any factory agent can read, write and control Melanie's hub directly, and SSO and
+RBAC don't stop a local process with filesystem access. On the 10-27 MVP path. Gitea #1693.
 
-Owner Darkwing (Opus 5.5), reviewer Duckworth (author of B5 and B7), gate owner Sage. Chained on row 190
-(Q177): the hub runs under row 190's config canon. Design first. The first deliverable is
-`agents/darkwing/work/queue-190b/DESIGN.md`.
+Owner Darkwing (Opus 5.5), reviewer Duckworth (author of B5; mos-0981 keeps new work off Filbert and Dewey),
+gate owner Sage. Merge-chained on row 190 (Q177): it builds on row 190's candidate and keeps its own review and
+gate. Design first. The first deliverable is `agents/darkwing/work/queue-190b/DESIGN.md`.
 
 ## Goal
 
-Melanie's hub instance (Case 2, C2-13) runs on its own host. No factory agent can read or write the hub's
-config, data root or secrets, reach its bus socket, or log in to the hub host. Her writing reaches the hub only
-through the existing git.mosaicstack.dev remotes, books repo only.
-
-## Provision (blank until Jason answers #419)
-
-Who provisions the host and how is left open. Sizing from Mos (mos-0998): 4 vCPU, 8 GB RAM, 64 GB disk,
-internal network only. Each agent process measures 300 to 390 MB RSS on dragon-lin. The design takes the host
-as given: a fresh Linux host with a named admin path, reachable by the deploying seat while the row runs.
+Melanie's hub instance runs under its own Linux user. No process of the factory instance can read or write the
+hub's config, data root or secrets, or control the hub's units. That covers the bus, role seats and their
+sessions, task runs, the Discord connector and the Console.
 
 ## The design must state
 
-1. The deploy. Exactly what Darkwing installs on the hub host and how: the stack copy, node, the units, the
-   config dir and data root under row 190's canon (O1: `~/.config/mosaic-NAME`, and "`~` is the home of the OS
-   user that runs the instance"). Which commands run as which user on the hub host, and which need its root.
-2. Re-pin, rollback and backup on the hub host, and who runs them after the deploy key is gone.
-3. How the hub gets model access without a copy of jwoltje's `claude-session.env` or any factory credential.
-   If that needs the credentials row (T1 item 6), say so and name the interim. If it needs a new subscription
-   or a new provider account, flag it for Jason and don't pick one (mos-1008).
-4. The books repo path. Which git.mosaicstack.dev remote, which credential the hub holds for it, and that it
-   can't read or push any other repository.
-5. The admin path and the end state. The host ends with no key the factory uid can read. The design names the
-   admin path that remains (for example the hypervisor console, or a key kept off the factory uid) and who
-   holds it.
-6. The acceptance script, as code Duckworth can read. It takes Gizmoduck's list of infrastructure gate items
-   as its input (mos-1011), not a fixed set of checks. Each item names a path, its closed form and its
-   accepted form, and the script reports which form holds for each, or fails. The list covers at least:
-   - federation R8's separate-host form: the hub's bus socket, data root and config dir don't exist on the
-     factory host, the factory host mounts nothing of the hub's, and no factory agent holds a login or key
-     for the hub host
-   - B7: from the factory uid, `sudo -n`, `doas -n`, `su`, polkit, and `ssh -o BatchMode=yes` to the hub
-     host all fail
-   - the hypervisor and backup paths ops-01 measured (mos-1011: one PVE node the factory key has root on,
-     PBS on that node with unencrypted backups, a flat /16 LAN), each closed or accepted by Jason
-7. The identity provider and TLS front end (B8, mos-1008, mos-1011). Either the factory holds no credential
-   that can create users, change groups, issue tokens or impersonate in the issuer the hub trusts, or the hub
-   uses an issuer the factory can't administer. A brand, tenant or app inside the same Authentik does not
-   count as separate. The same holds for the TLS front end that serves the hub. The proof is a failed admin
-   call from every token the factory's root can read. No credential value is printed in that proof.
+1. How operators (Mos, Sage, Jason) deploy, re-pin and roll back the hub. Which commands they run, as which
+   user, and what each one needs.
+2. Each root step Jason runs: useradd, the home and its modes, `loginctl enable-linger`, and any sudoers rule,
+   with the exact command lines.
+3. How the hub reaches the Claude proxy and gets its session env without sharing jwoltje's
+   `claude-session.env`.
+4. Whether real isolation needs the factory instance's seats to run apart from the operators' uid. If yes, say
+   so plainly with its cost. Don't design around it.
+
+It must also cover the copies (shared read-only trees under jwoltje's home, or the hub's own), the human CLI
+wrapper and human proof for the hub's Console, and how the stack-release pointer, log and backups work under
+the second user.
 
 ## Boundaries
 
-- Provisioning, hypervisor access and any infra or k3s change are Jason's (Q173 exclusions). Mos takes the
-  hypervisor residual (factory root on the PVE nodes, Q172) to Jason. It doesn't block this row.
-- Melanie's server (`[email protected]`) is reference only, read only, under Jason's authorization in
-  mos-0995. Nothing on it changes, and her Hermes bots keep running.
-- No tunnel, Traefik or other exposure outside the internal network. That waits for Jason, after Q175 SSO.
-- No credential value is printed, logged or committed. Keys made for the deploy are removed at the end, and
-  the acceptance script proves it.
-- The admin-call proof in point 7 and any call to the issuer or the TLS front end run only in a window Mos
-  approves, never as a test or an anonymous probe (Q175).
-- Tests in the repository use scratch roots and stand-ins. The live deploy and the acceptance run on the hub
-  host are a window with a backup first (where there is state) and a STATE report after.
+- Row 190 lands first, as designed: one uid, scratch two-instance tests without root.
+- No agent runs a root step. Every one goes to Jason as an exact command list.
+- No real hub user, unit or data root is created in this row's tests. Tests use scratch roots and stand-ins as
+  row 190 does. Anything that needs a second real uid is a Q173 window with a backup first and a STATE report
+  after.
+- No tunnel or Traefik exposure. That waits for Jason, after Q175 SSO.
 
 ## Gate
 
-Duckworth approves DESIGN.md, then the manifest. Any repository change is green on Sage's gate (cli suite and
-every `scripts/test-*.sh`), with the design's mutants killed. The row is done when the acceptance script passes
-on the hub host from the factory uid, Duckworth reads its output, and Mos confirms.
+Duckworth approves DESIGN.md, then the manifest. The cli suite and every `scripts/test-*.sh` are green on
+Sage's gate. The design's mutants are killed.

docs/plans/2026-10-20_human-users-build.md

@@ -1,70 +0,0 @@
-# Row 193 build rows: 193a, 193b1, 193b2, 193c and 193d (#1691)
-
-Sage, 2026-10-20, for Mos's go mos-1034 item 4. Row 193's design is Morgana's
-`agents/morgana/work/queue-193/DESIGN.md` at e2d161e2e on `morgana/row193` (r5, sha256
-dd7fcb419ed8510e9d8d74b569183386d0942af8b68eecc0bbb5e182e677b523), approved by Duckworth (duckworth-0018).
-Section 8 lists the tests and mutants, and section 9 the split. The brief behind them is
-`docs/plans/2026-10-20_human-users.md`. Vikunja P19 #414/#415, Gitea #1691.
-
-Owner Morgana for every row, reviewer Duckworth, gate owner Sage. Each row chains on its parent's candidate
-(Q177) and rebases onto the parent's landing. Seats push only their own `<seat>/*` branches (mos-0981).
-Single test files run freely, and suites and mutant batches need Sage's slot.
-
-Boundaries for every row: no change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units, slot files, any
-live access.json or `~/.mosaic`. No request to the live Console, mosaic.woltje.com or auth.diversecanvas.com.
-No user thread goes live before 193b1's message filter has landed (mos-1021 B2, FED R8).
-
-The owner-visible records are fixed by Mos (mos-1023 item 2) and named in one user sentence, which FED R6
-reuses word for word: "The business owner sees your thread's agent's decisions, inbox entries, claims, tasks
-and project files, but not your messages."
-
-## Brief: 193a, the access level check widened to viewer
-
-Chained on FED R1. Started early on `morgana/row193a` (508ee4d61) against R1's interface as the FED brief
-names it, with Sage's go (sage-1373). R1's level check accepts `viewer` and still refuses any other new
-level. Tests in `packages/business/tests/` (section 8, Business), with the four mutants in Morgana's
-BUILD.md. FED R4 chains on this row.
-
-Duckworth's N1 on R1 (duckworth-0033, sage-1417): with viewer added, `covers` called with no level would let a
-viewer grant cover a collaborator ask. This row makes `level` required in `covers`, with a test and a mutant that
-makes it optional again. R3 and R4 call `covers` with a level.
-
-Gate: Duckworth approves the manifest. The business suite and every `scripts/test-*.sh` are green on Sage's
-gate, and the mutants are killed.
-
-## Brief: 193b1, viewer verbs, board refusals and the message filter
-
-Chained on FED R3, FED R4 and row 196's verifier. The bus gets the viewer verb list, per-grant level
-checks, board reads refused to users, and the section 5.7 `trail` and `replies` filter with `#readable`
-owner-only. No schema change. The governance pin test names each item in the user sentence above. Bus tests
-and mutants 1, 3, 6, 10, 11 and 12 from section 8.
-
-Gate: Duckworth approves the manifest. The bus suite and every `scripts/test-*.sh` are green on Sage's gate,
-and the mutants are killed.
-
-## Brief: 193b2, thread shares (schema 3j)
-
-Chained on 193b1. `thread_shares`, the share verbs, the share rules of `#readable` and `#threadRead`, and the
-section 5.5 share filters. Schema 3i to 3j. The table is append-only, and row 181's restore guard and
-`COUNTED` include it. Bus tests for shares and the migration, and mutants 2, 4, 7, 8 and 9 from section 8.
-Going live needs a `--migrate` window with Jason. Sage takes it to Mos when this row is near.
-
-Gate: Duckworth approves the manifest. The bus suite, the cli suite and every `scripts/test-*.sh` are green on
-Sage's gate, and the mutants are killed.
-
-## Brief: 193c, mosaic access user verbs and --level viewer
-
-Chained on FED R5. `mosaic access user add/remove` and `grant --level viewer`, only where R5 lacks them. They
-refuse tester and agent callers, write a receipt line and call `access.reload` (section 8, CLI). If R5
-already has all of them, this row records that and closes with no code.
-
-Gate: Duckworth approves the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's gate,
-and the mutants are killed.
-
-## Brief: 193d, the Console's shared list, share controls and viewer read-only
-
-Chained on FED R6, row 192 and 193b2 (for share controls). A viewer has no composer or share control, and
-with each UI check removed the bus still refuses (section 8, Webui).
-
-Gate: Duckworth approves the manifest. The webui suite and every `scripts/test-*.sh` are green on Sage's
-gate, and the mutants are killed.

docs/plans/2026-10-20_retire-control-board.md

@@ -1,57 +0,0 @@
-# Brief: retire the control board writer on 7331
-
-Sage, 2026-10-20, for Mos's ruling mos-1008 item 2. Gitea #1696. MVP 10-27 work. Owner Bushroot (Haiku 5.5, a
-low-level model under Q177), reviewer Webby, gate owner Sage. Base: refactor at the brief commit.
-
-## Why
-
-`packages/control-board/src/serve.mjs` is a loopback HTTP service on 7331 with no authentication. It reads
-transcripts and writes through `/api/reply`. Any host process that reaches the port can do both. That fails
-Q175 ("zero trust with verification"). Gander found it in the row 196 inventory (gander-0004). Nothing listens
-on 7331 now (`ss -ltnp`, 2026-10-20T19:05:09Z), so retiring it costs the least.
-
-## Steps, in order
-
-1. Inventory first. List every reference to the control board and to 7331: scripts, units, `scripts/mosaic`
-   and other CLI dispatch, docs (AGENTS.md, READMEs, TOOLS.md), package.json scripts, tests, and the Console
-   (`packages/webui`). For each, say whether it starts the writer, reads its code, or only mentions it.
-   Commit the list as `agents/bushroot/work/queue-ROW/INVENTORY.md` and send it to Sage and Webby.
-2. Stop if something depends on it. If a reference shows a live dependency (the Console or another package
-   imports code that only the control board has, or a unit or script still starts it), stop. Sage takes it to
-   Mos before anything is removed.
-3. Otherwise retire the writer. Either remove the `serve` entry point, or make it refuse to start with a
-   message that points to the Console. Keep any read-only code another package imports, and say which.
-   Update the docs that tell people to start it. The AGENTS.md text about the control-board reply convention
-   is a separate matter. Change it only if it tells someone to start 7331.
-
-## Mos's call on the Console dependency (mos-1019)
-
-The inventory (004f133bd) found that the Console proxies `/api/board`, `/api/seen`, `/api/reply` and the
-conversation routes to `DEFAULT_BOARD` on 7331 (`packages/webui/src/serve.mjs:12`), so the board view returns
-502 today. Mos took Sage's recommendation: retire the 7331 listener and its README start commands, and have
-the Console call the board's read code in-process, behind the Console's own auth (Q175 SSO on 7332).
-`/api/reply` stays only under `--send`. The DESIGN.md for that change comes before code, and Webby approves
-it.
-
-## Acceptance
-
-Nothing in the stack can start a writer on 7331. A test proves it: the entry point refuses (or is gone), no
-script or unit starts it, and a grep check finds no starter. Each change gets a mutant that brings the writer
-back and the test kills it. Mos added three items (mos-1019):
-
-- The board view answers from the Console with nothing listening on 7331.
-- Every board route sits behind the Console's auth.
-- A test proves `/api/reply` refuses without `--send`.
-
-Test fixtures that bind port 0 may stay if they only test the code in-process.
-
-## Boundaries
-
-- No change to the live units, `~/.mosaic-dev`, `~/.config/mosaic-dev`, slot files or `~/.mosaic`.
-- No request to any live port.
-- Single test files run freely. Suites need Sage's slot.
-
-## Gate
-
-Webby approves INVENTORY.md, then DESIGN.md, then the manifest. The control-board and webui package suites, the cli suite and
-every `scripts/test-*.sh` are green on Sage's gate, and the mutants are killed.

docs/plans/2026-10-20_second-gate-lane.md

@@ -1,42 +0,0 @@
-# Brief: a second gate lane, two full gates at once on dragon-lin
-
-Sage, 2026-10-20, for Mos's order mos-0977 item 6 ("put the design for a second gate lane on the list now")
-and the MVP push (mos-0974). Gitea #1695. Owner Herb (Codex gpt-6.1-sol, a new builder seat), reviewer
-Webby, gate owner Sage. Base: refactor at the brief commit. Design first. The first deliverable is
-`agents/herb/work/queue-ROW/DESIGN.md`.
-
-## Why
-
-Every full run shares one slot today. A full gate (cli suite plus every `scripts/test-*.sh`) takes about 13
-minutes or more, reviewers' runs and mutants take the same slot, and with eight or more seats building for
-10-27 the slot is the bottleneck. The slot exists because concurrent runs broke each other. The busy check is
-`agents/sage/work/gate-lane/busy-now.sh` (a copy of Sage's), and the gate is
-`agents/sage/work/gate-lane/gate-template.sh` (a copy of Sage's template). The host has 16 cores and 62 GB.
-
-## What the design must settle
-
-1. Every shared resource two concurrent runs can collide on, found from the code and tests, not guessed:
-   Docker compose project names and networks (`scripts/test-task.sh` and others), fixed TCP ports in tests,
-   unix socket paths and their 107-byte limit under TMPDIR, the sandbox's private `/tmp`, shared caches,
-   scratch and worktree paths, the queue lock, and any test that reads host-wide state (process lists,
-   `pgrep`, `/proc`). For each: how a lane gets its own copy, or why it is safe to share.
-2. Timing. Which tests have time limits that a doubled CPU load could break, measured, and what changes (a
-   bound, or a lane rule that keeps those suites apart).
-3. The lane mechanism: lane ids, a lock per lane that a run takes and releases even on a crash, the busy
-   check that reports per lane, and how a seat asks for a lane. Sage still grants it.
-4. The gate template takes a lane id and isolates everything from point 1 by it.
-5. Proof: two full gates on different candidates at once, three times, with zero cross-failures, plus the
-   wall time of each against a single-lane run. Any flake found is named with its cause.
-
-## Boundaries
-
-- No change to the live units, `~/.mosaic-dev`, `~/.config/mosaic-dev` or slot files. The proof runs use
-  scratch roots only, and it needs Sage's grant of the whole slot while it runs.
-- Test code changes that only isolate a resource are in scope. A change to what a test checks is not, and
-  goes to its owner.
-- Docker networks and containers a run makes are removed by the run (trap), and nothing else is touched.
-
-## Gate
-
-Webby approves DESIGN.md, then the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's
-gate, both singly and in the two-lane proof.

docs/plans/2026-10-20_stack-release-sso.md

@@ -1,39 +0,0 @@
-# Brief: stack-release.sh activates a Console with --sso (Q175 phase 2 prerequisite)
-
-Sage, 2026-10-20, for Launchpad's finding F3 on row 192 (launchpad-0001) and Q175 (#412). Gitea #1698. Owner
-Launchpad, reviewer Webby, gate owner Sage. Chained on row 192's candidate (Q177): it lands after row 192 and
-before the phase 2 window. Base: row 192's candidate.
-
-## Why
-
-The phase 2 window re-pins the Console to the phase 1 commit with `--sso --send --tester-port 7333`
-(`agents/sage/work/q175-sso/DESIGN.md`, section 5). `scripts/stack-release.sh` doesn't know `--sso` today.
-Its `proof_checks` (`:751`) requires `--public-host`, `--auth-header` and `--allow-user` whenever a proof pair is
-carried, and the pointer's Console flags still hold the forward-auth pair (`--auth-header X-authentik-username
---allow-user jason.woltje`) that `--sso` refuses to start with. So the window can't run through the script, and
-a hand-edited pointer is not an option.
-
-## What the row does
-
-1. `activate ID BUSINESS --sso` writes Console flags with `--sso` and without `--auth-header`, `--allow-user`
-   and any proof pair, and `--plan` names each flag it drops and carries, in the style of row 189's `send:`
-   line. The design names the full flag set the phase 2 Console starts with and checks it against row 192's
-   refusals.
-2. Before anything stops, the script refuses a target copy whose Console doesn't support `--sso`, and refuses
-   when the config's `console` key or its slot file fails the checks row 192's `--sso` start runs. It reads
-   neither value and only uses the same stat and shape checks.
-3. Rollback from an `--sso` pointer to a pre-phase-1 copy follows the design's phase 2 rollback order (remove
-   the `console` key first). The script refuses a rollback that would start a Console on a config it can't
-   read, and says which step comes first.
-4. `docs/TOOLS.md` gets the flag.
-
-## Boundaries
-
-- No change to the live pointer, units, `~/.mosaic-dev` or `~/.config/mosaic-dev`. Tests use scratch roots
-  and seeded pointers, as rows 187 and 189 do.
-- No request to the live Console, mosaic.woltje.com or auth.diversecanvas.com.
-
-## Gate
-
-Webby approves the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's gate, and the
-mutants are killed (one per refusal, and one that keeps `--auth-header` in the written flags).

packages/bus/README.md

@@ -9,12 +9,14 @@ returned to a client or written to the database.
 
 Slice 1 shares an OS user. Files, capabilities, process ancestry checks and
 hooks are **not a wall against a hostile same-UID process**. In particular,
-Linux `/proc` checks here are not SO_PEERCRED authentication. The trusted host
+The ancestry walk remains cooperative. Human/tester/user proof envelopes are now
+bound to the connecting PID and uid using Linux SO_PEERCRED before dispatch. The trusted host
 and well-behaved clients must follow this protocol. Containers remain later work.
 
 ## Start and stop
 
-Requires Linux and Node 24 or 26, local disk, no dependencies. The data root must
+Requires Linux, Node 24 or 26, local disk and system Python >=3.10. The bus pins
+the root-owned ELF resolved from /usr/bin/python3, never a PATH shim or home binary. The data root must
 already exist and belong to the user. A broker creates `bus/` mode 0700 and the
 DB/lock/socket mode 0600. It refuses symlinks or unsafe existing permissions.
 
@@ -882,3 +884,34 @@ on the session and written on each usage record; a pi run's is null. The
 account stays out of `session.launched`'s body. `mayLaunch` and `mustStop`
 pass it to the limit checks in the subject. A session can edit its own transcript: this is a best reading, not proof.
 No enforcement or resets are added. Settings reads through the same bus view.
+
+## Human boundary (row 196)
+
+A bounded Python stdlib helper receives only the accepted Unix socket fd and
+returns pid, uid and gid. All three are validated as safe integers. Only pid and
+uid select a principal. It runs for proof envelopes only, never cap traffic, with
+a limit of 16 helpers, a one-second timeout and 256-byte result. Proof PID must
+equal kernel peer PID. Human/user proofs retain the full agent ancestry walk.
+Tester proofs deliberately admit agent seats and still refuse managed runs.
+
+The trusted verifyPrincipal interface returns {kind,business,id} for one request.
+User provenance requires the same-tree Console as direct parent and a distinct
+user nonce. R3 supplies user mapping and checks the live grant on every request.
+No role is accepted from a proof or cached. Caps are not returned to proof clients.
+
+Every restart repeats interpreter safety checks and appends a 0600 startup receipt
+to bus/peercred-starts.jsonl before listening. The receipt names the actual current
+interpreter and copy. A safe OS replacement is accepted without comparing an old
+activation hash. Unsafe interpreter or failed receipt append refuses startup.
+Original activation evidence is never rewritten. The next authorized re-pin to a
+different reviewed copy refreshes activation evidence. The worker Containerfile
+does not run the bus and needs no Python change. Any future bus image must provide
+this dependency or use a separately reviewed compiled helper.
+
+Hostile processes on the instance uid remain outside this guarantee. In particular,
+a detached agent can erase visible ancestry, and a same-uid process can tamper with
+files, pipes or process memory where OS policy permits. Separate instance uids
+narrow cross-instance reach, not reach within one instance.
+
+The Console provenance option trusts verified code and process metadata, not an independent
+bus-side OIDC exchange. That trade must be approved, not hidden behind the phrase zero trust.

packages/bus/fixtures/peer-client.mjs

@@ -0,0 +1,17 @@
+import { connect } from 'node:net';
+process.send({pid:process.pid});
+process.once('message', ({path,claimed}) => {
+  const s = connect(path);
+  s.on('error', () => process.exit(2));
+  let text = '';
+  s.on('connect', () => s.write(JSON.stringify({human:{pid:claimed ?? process.pid,startTime:'test',nonce:'a'.repeat(64),business:'demo'},verb:'agents'})+'\n'));
+  s.on('data', data => {
+    text += data;
+    if (!text.includes('\n')) return;
+    const reply = JSON.parse(text);
+    s.write('after-helper\n');
+    s.end();
+    process.send({reply});
+    process.disconnect();
+  });
+});

packages/bus/src/human.mjs

@@ -31,7 +31,7 @@ export function readProcess(pid, { readFile = readFileSync, stat = lstatSync } =
       for (const entry of environment.split('\0')) {
         const i = entry.indexOf('=');
         const key = entry.slice(0, i);
-        if (key === 'MOSAIC_BUS_CLI_NONCE' || MARKERS.includes(key)) env[key] = entry.slice(i + 1);
+        if (['MOSAIC_BUS_CLI_NONCE', 'MOSAIC_BUS_USER_NONCE'].includes(key) || MARKERS.includes(key)) env[key] = entry.slice(i + 1);
       }
     return {
       pid,
@@ -49,7 +49,7 @@ export function readProcess(pid, { readFile = readFileSync, stat = lstatSync } =
 }
 // Cooperative same-UID process checks, not peer credentials or a hostile-process wall.
 // A nonce in the CLI's launch environment binds the submitted PID to a live CLI.
-export function verifyHuman(proof, { cliPath, launches = [], readProcess: read = readProcess }) {
+export function verifyHuman(proof, { cliPath, launches = [], readProcess: read = readProcess, nonceKey = 'MOSAIC_BUS_CLI_NONCE' }) {
   if (
     !proof ||
     typeof proof !== 'object' ||
@@ -66,7 +66,7 @@ export function verifyHuman(proof, { cliPath, launches = [], readProcess: read =
     if (
       p.uid !== process.getuid() ||
       p.startTime !== proof.startTime ||
-      p.env?.MOSAIC_BUS_CLI_NONCE !== proof.nonce ||
+      p.env?.[nonceKey] !== proof.nonce ||
       p.argv[1] !== resolve(cliPath)
     )
       refuse();

packages/bus/src/interpreter.mjs

@@ -0,0 +1,67 @@
+import { realpathSync, statSync, readFileSync, openSync, fstatSync, writeSync, fsyncSync, closeSync, constants } from 'node:fs';
+import { dirname, join, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+
+const systemPython = '/usr/bin/python3';
+const defaultIO = { realpath: realpathSync, stat: statSync, readFile: readFileSync, exec: execFileSync };
+const below = (path, parent) => path === parent || path.startsWith(parent + sep);
+// Trusted dependency injection is for offline tests, never a CLI/env interpreter override.
+export function inspectInterpreter({ io = defaultIO } = {}) {
+  try {
+    const path = io.realpath(systemPython);
+    const homes = ['/home', '/root', ...String(io.readFile('/etc/passwd', 'utf8')).split('\n')
+      .map(line => line.split(':')[5]).filter(p => p?.startsWith('/') && p !== '/')];
+    if (!path.startsWith('/') || homes.some(home => below(path, home))) throw Error();
+    // Check both the system entry's parent and every resolved component. /usr/bin/python3
+    // may be a system symlink; its containing directory and resolved target must be safe.
+    for (const start of [dirname(systemPython), path]) {
+      for (let at = start;; at = dirname(at)) {
+        const s = io.stat(at);
+        if (s.uid !== 0 || (s.mode & 0o022) || (at === path ? !s.isFile() : !s.isDirectory())) throw Error();
+        if (at === '/') break;
+      }
+    }
+    const data = io.readFile(path);
+    if (!Buffer.isBuffer(data) || !data.subarray(0, 4).equals(Buffer.from([127, 69, 76, 70]))) throw Error();
+    const version = JSON.parse(String(io.exec(path, ['-I', '-S', '-c', 'import json,sys,socket;assert hasattr(socket,"SO_PEERCRED");print(json.dumps(list(sys.version_info[:3])))'],
+      { env: {}, timeout: 1000, maxBuffer: 256, encoding: 'utf8' })));
+    if (!Array.isArray(version) || version.length !== 3 || !version.every(Number.isSafeInteger) ||
+      version[0] < 3 || (version[0] === 3 && version[1] < 10)) throw Error();
+    const s = io.stat(path);
+    return Object.freeze({ path, version: Object.freeze(version), dev: s.dev, ino: s.ino,
+      sha256: createHash('sha256').update(data).digest('hex') });
+  } catch { throw Error('interpreter-unsafe'); }
+}
+
+export function verifyInterpreterReceipt(directory, expected, since) {
+  let fd;
+  try {
+    fd = openSync(join(directory, 'peercred-starts.jsonl'), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const s = fstatSync(fd);
+    if (!s.isFile() || s.uid !== process.getuid() || (s.mode & 0o077) || s.nlink !== 1) throw Error();
+    const text = readFileSync(fd, 'utf8');
+    if (!text.endsWith('\n')) throw Error();
+    const actual = JSON.parse(text.trimEnd().split('\n').at(-1));
+    if (actual.copy !== new URL('../../../', import.meta.url).pathname || !(Date.parse(actual.at) >= Number(since)) ||
+      Date.parse(actual.at) > Date.now() + 1000 || ['path', 'sha256', 'dev', 'ino', 'version'].some(k => JSON.stringify(actual[k]) !== JSON.stringify(expected[k]))) throw Error();
+    return true;
+  } catch { throw Error('interpreter-receipt-mismatch'); }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+
+export function recordInterpreterStart(directory, record) {
+  let fd;
+  try {
+    const dir = statSync(directory);
+    if (!dir.isDirectory() || dir.uid !== process.getuid() || (dir.mode & 0o077)) throw Error();
+    fd = openSync(join(directory, 'peercred-starts.jsonl'),
+      constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600);
+    const s = fstatSync(fd);
+    if (!s.isFile() || s.uid !== process.getuid() || (s.mode & 0o077) || s.nlink !== 1) throw Error();
+    const line = Buffer.from(JSON.stringify({ at: new Date().toISOString(), copy: new URL('../../../', import.meta.url).pathname, ...record }) + '\n');
+    if (writeSync(fd, line) !== line.length) throw Error();
+    fsyncSync(fd);
+  } catch { throw Error('interpreter-receipt-unsafe'); }
+  finally { if (fd !== undefined) closeSync(fd); }
+}

packages/bus/src/peercred.mjs

@@ -0,0 +1,58 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { lstatSync } from 'node:fs';
+import { BusError } from './broker.mjs';
+
+const helper = fileURLToPath(new URL('./peercred.py', import.meta.url));
+const refused = () => new BusError('peercred-required');
+export function createPeerReader({ interpreter, spawn = nodeSpawn, timeout = 1000, stat = lstatSync } = {}) {
+  try { const s = stat(helper); if (!s.isFile() || s.isSymbolicLink()) throw Error(); }
+  catch { throw refused(); }
+  const children = new Set();
+  let closed = false;
+  return {
+    read(socket) {
+      if (closed || children.size >= 16) return Promise.reject(refused());
+      return new Promise((resolve, reject) => {
+        let child, timer, output = '', settled = false, invalid = false;
+        const finish = (error, value) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          error ? reject(refused()) : resolve(value);
+        };
+        try {
+          // Keep this connection's Socket in this closure. Never borrow another pending fd.
+          child = spawn(interpreter.path, ['-I', '-S', helper],
+            { env: {}, stdio: ['ignore', 'pipe', 'pipe', socket] });
+          children.add(child);
+          timer = setTimeout(() => { child.kill('SIGKILL'); finish(true); }, timeout);
+          child.stdout.on('data', data => {
+            output += data.toString('utf8');
+            if (Buffer.byteLength(output) > 256) { invalid = true; child.kill('SIGKILL'); finish(true); }
+          });
+          child.stderr.on('data', () => { invalid = true; });
+          child.on('error', () => { children.delete(child); finish(true); });
+          child.on('close', (code, signal) => {
+            children.delete(child);
+            if (settled) return;
+            try {
+              if (closed || invalid || code !== 0 || signal) throw Error();
+              const p = JSON.parse(output);
+              if (!p || Array.isArray(p) || Object.keys(p).sort().join(',') !== 'gid,pid,uid' ||
+                !['pid', 'uid', 'gid'].every(k => Number.isSafeInteger(p[k])) || p.pid < 2 || p.uid < 0 || p.gid < 0) throw Error();
+              finish(false, Object.freeze(p));
+            } catch { finish(true); }
+          });
+        } catch { finish(true); }
+      });
+    },
+    async close() {
+      closed = true;
+      await Promise.all([...children].map(child => new Promise(resolve => {
+        child.once('close', resolve);
+        child.kill('SIGKILL');
+      })));
+    },
+  };
+}

packages/bus/src/peercred.py

@@ -0,0 +1,14 @@
+"""Read only kernel credentials from an inherited accepted AF_UNIX stream."""
+import json
+import socket
+import struct
+import sys
+
+try:
+    with socket.socket(fileno=3) as peer:
+        if peer.family != socket.AF_UNIX or peer.type != socket.SOCK_STREAM:
+            raise ValueError()
+        pid, uid, gid = struct.unpack("3i", peer.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, 12))
+        print(json.dumps({"pid": pid, "uid": uid, "gid": gid}, separators=(",", ":")))
+except Exception:
+    sys.exit(2)

packages/bus/src/principal.mjs

@@ -0,0 +1,44 @@
+import { resolve } from 'node:path';
+import { BusError } from './broker.mjs';
+import { verifyHuman, readProcess as defaultRead } from './human.mjs';
+import { verifyTester, testerNonce } from './tester.mjs';
+
+// Trusted transport API. Identity is held only by this connection's transient session.
+// User mapping and live grant authorization belong to R3, not to this verifier.
+export function verifyPrincipal(request, { peer, paths, businesses, launches = [], readProcess = defaultRead, readTesterNonce = testerNonce }) {
+  const kinds = ['human', 'tester', 'user'].filter(k => request?.[k]);
+  if (kinds.length !== 1 || request.cap) throw new BusError('invalid-envelope');
+  const kind = kinds[0], proof = request[kind];
+  const error = kind === 'tester' ? 'tester-required' : 'human-required';
+  const refuse = () => { throw new BusError(error); };
+  if (!peer || peer.uid !== process.getuid() || peer.pid !== proof.pid) refuse();
+  if (kind === 'tester') {
+    const { business } = verifyTester(proof, { cliPath: paths.tester, launches, readProcess, readNonce: readTesterNonce });
+    return { kind: 'tester', business, id: 'tester' };
+  }
+  let checked = proof, parent;
+  if (kind === 'user') {
+    if (!proof || typeof proof.user !== 'string' || !proof.user ||
+      Object.keys(proof).some(k => !['pid', 'startTime', 'nonce', 'business', 'user'].includes(k))) refuse();
+    const { user, ...rest } = proof;
+    checked = rest;
+    try {
+      const child = readProcess(proof.pid);
+      parent = readProcess(child.ppid);
+      if (parent.uid !== peer.uid || parent.argv[1] !== resolve(paths.console) || parent.argv[2] !== 'serve') refuse();
+    } catch { refuse(); }
+  }
+  const { business } = verifyHuman(checked, { cliPath: paths[kind], launches, readProcess,
+    nonceKey: kind === 'user' ? 'MOSAIC_BUS_USER_NONCE' : 'MOSAIC_BUS_CLI_NONCE' });
+  if (kind === 'user') {
+    try {
+      const child = readProcess(proof.pid), again = readProcess(parent.pid);
+      if (child.ppid !== parent.pid || again.startTime !== parent.startTime || again.ppid !== parent.ppid ||
+        again.uid !== parent.uid || again.argv[1] !== parent.argv[1] || again.argv[2] !== 'serve') refuse();
+    } catch { refuse(); }
+    return { kind: 'user', business, id: proof.user };
+  }
+  const id = businesses[business]?.human;
+  if (!id) throw new BusError('unknown-business');
+  return { kind: 'owner', business, id };
+}

packages/bus/src/runtime.mjs

@@ -12,10 +12,11 @@ import { createLoader, hasModule } from '../../plugins/src/loader.mjs';
 import { pluginSettings } from '../../business/src/plugin-settings.mjs';
 import { instanceSettings } from '../../business/src/instance-settings.mjs';
 import { webService } from './web.mjs';
-import { verifyHuman } from './human.mjs';
+import { verifyPrincipal } from './principal.mjs';
+import { inspectInterpreter, recordInterpreterStart } from './interpreter.mjs';
+import { createPeerReader } from './peercred.mjs';
 import { createUsage } from './usage.mjs';
 import { createLimits } from './limits.mjs';
-import { verifyTester } from './tester.mjs';
 // Trusted host API. S1 supplies resolved definitions, S6 supplies launch records and ends them.
 // Human limits writes use the shared organization writer behind the verified transport.
 // `tasks` is S3's adapter factory: ({broker, credentials, businesses}) => {handle, timeout, close}.
@@ -166,29 +167,29 @@ export async function startBroker({
         throw new BusError('invalid-adapter');
     }
     const web = await webServices(businesses);
+    const interpreter = inspectInterpreter();
+    recordInterpreterStart(store.directory, interpreter);
+    const peerReader = createPeerReader({ interpreter });
+    const principalPaths = {
+      human: fileURLToPath(new URL('./human-cli.mjs', import.meta.url)),
+      tester: fileURLToPath(new URL('./tester-cli.mjs', import.meta.url)),
+      user: fileURLToPath(new URL('./user-cli.mjs', import.meta.url)),
+      console: fileURLToPath(new URL('../../webui/src/cli.mjs', import.meta.url)),
+    };
     const path = join(store.directory, 'broker.sock');
     server = await serve({
       web: (business) => web.get(business) ?? null,
       tasks: adapter ? { handle: adapter.handle, timeout: adapter.timeout } : null,
       broker,
       path,
-      authenticateHuman: (proof) => {
-        const { business } = verifyHuman(proof, {
-          cliPath: fileURLToPath(new URL('./human-cli.mjs', import.meta.url)),
-          launches: launchRecords,
-        });
-        const human = businesses[business]?.human;
-        if (!human) throw new BusError('unknown-business');
-        return broker.bindHuman({ business, human, via: 'cli', outsideAgent: true });
+      peerReader,
+      authenticateHuman: (proof, peer) => {
+        const p = verifyPrincipal({ human: proof }, { peer, paths: principalPaths, businesses, launches: launchRecords });
+        return broker.bindHuman({ business: p.business, human: p.id, via: 'cli', outsideAgent: true });
       },
-      // Row 110 (#1604): a tester proves its CLI process and that no managed run is above it.
-      // The broker then binds only if the business sets `bus.tester` to true.
-      authenticateTester: (proof) => {
-        const { business } = verifyTester(proof, {
-          cliPath: fileURLToPath(new URL('./tester-cli.mjs', import.meta.url)),
-          launches: launchRecords,
-        });
-        return broker.bindTester({ business });
+      authenticateTester: (proof, peer) => {
+        const p = verifyPrincipal({ tester: proof }, { peer, paths: principalPaths, businesses, launches: launchRecords });
+        return broker.bindTester({ business: p.business });
       },
     });
     // S6 launcher operations. The host decides capacity and the instance list; the broker

packages/bus/src/server.mjs

@@ -1,6 +1,8 @@
 import { createServer } from 'node:net';
 import { lstatSync, chmodSync, unlinkSync } from 'node:fs';
 import { BusError, TASK_VERBS, WEB_VERBS, PROJECT_FILE_VERBS, PROJECT_SAVE_VERB, PROJECT_SAVE_REQUEST_MAX } from './broker.mjs';
+import { inspectInterpreter } from './interpreter.mjs';
+import { createPeerReader } from './peercred.mjs';
 const LIMIT = 65536;
 // Row 148: a document save may carry up to 1 MiB of text. Only a request that names that verb near
 // its start (the proof object comes first) may pass LIMIT; the parsed verb is checked again below.
@@ -10,31 +12,37 @@ const SAVE_VERB_AT_START = new RegExp(`"verb":"${PROJECT_SAVE_VERB.replaceAll('.
 // `web` is the trusted web service (web.mjs), or a function from a business id to one (or null); only
 // the web verbs reach it, and without one they refuse web-not-configured (or web-not-granted).
 // A request carries exactly one of cap, human (row S4) and tester (row 110) proof.
-export async function serve({ broker, path, authenticateHuman = null, authenticateTester = null, timeout = 5000, tasks = null, web = null }) {
+export async function serve({ broker, path, authenticateHuman = null, authenticateTester = null, authenticateUser = null, peerReader = null, timeout = 5000, tasks = null, web = null }) {
   try {
     lstatSync(path);
     throw new BusError('socket-exists');
   } catch (e) {
     if (e.code !== 'ENOENT') throw e;
   }
+  const peers = peerReader ?? createPeerReader({ interpreter: inspectInterpreter() });
   const sockets = new Set();
   const server = createServer({ allowHalfOpen: true }, (socket) => {
     sockets.add(socket);
-    socket.on('close', () => sockets.delete(socket));
+    let boundCap;
+    const release = () => { if (boundCap) { broker.disconnect(boundCap); boundCap = null; } };
+    socket.on('close', () => { sockets.delete(socket); release(); });
     socket.on('error', () => {});
     let input = Buffer.alloc(0),
-      done = false;
+      done = false, processing = false;
     const finish = (result) => {
       if (done) return;
       done = true;
+      release();
+      socket.resume();
       socket.end(JSON.stringify(result) + '\n');
     };
     socket.setTimeout(timeout, () => {
       finish({ ok: false, error: 'request-timeout' });
       socket.destroySoon();
     });
-    socket.on('data', (chunk) => {
+    socket.on('data', async (chunk) => {
       if (done) return;
+      if (processing) return finish({ ok: false, error: 'invalid-envelope' });
       const total = input.length + chunk.length;
       if (total > LIMIT && !(total <= PROJECT_SAVE_REQUEST_MAX &&
           SAVE_VERB_AT_START.test(Buffer.concat([input, chunk]).subarray(0, 1024).toString('latin1')))) {
@@ -44,6 +52,7 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
       input = Buffer.concat([input, chunk]);
       const end = input.indexOf(10);
       if (end < 0) return;
+      processing = true;
       let transient;
       try {
         if (end !== input.length - 1) throw new BusError('invalid-envelope');
@@ -53,19 +62,24 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
           !r ||
           Array.isArray(r) ||
           typeof r !== 'object' ||
-          Object.keys(r).some((k) => !['cap', 'human', 'tester', 'verb', 'args'].includes(k)) ||
+          Object.keys(r).some((k) => !['cap', 'human', 'tester', 'user', 'verb', 'args'].includes(k)) ||
           typeof r.verb !== 'string' ||
-          [r.cap, r.human, r.tester].filter(Boolean).length !== 1
+          [r.cap, r.human, r.tester, r.user].filter(Boolean).length !== 1
         )
           throw new BusError('invalid-envelope');
         let cap = r.cap;
-        if (r.human) {
-          if (!authenticateHuman) throw new BusError('human-required');
-          transient = cap = authenticateHuman(r.human);
-        }
-        if (r.tester) {
-          if (!authenticateTester) throw new BusError('tester-required');
-          transient = cap = authenticateTester(r.tester);
+        const kind = r.human ? 'human' : r.tester ? 'tester' : r.user ? 'user' : null;
+        if (kind) {
+          const authenticate = kind === 'human' ? authenticateHuman : kind === 'tester' ? authenticateTester : authenticateUser;
+          if (!authenticate) throw new BusError(kind === 'tester' ? 'tester-required' : 'human-required');
+          socket.pause();
+          let peer;
+          try { peer = await peers.read(socket); }
+          catch { throw new BusError('peercred-required'); }
+          if (done || socket.destroyed) return;
+          transient = cap = authenticate(r[kind], peer);
+          boundCap = transient;
+          socket.resume();
         }
         if (typeof cap !== 'string') throw new BusError('unauthenticated');
         if (tasks && TASK_VERBS.includes(r.verb)) {
@@ -80,7 +94,7 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
               (e) => finish({ ok: false, error: e instanceof BusError ? e.code : 'adapter-failed' }),
             )
             .finally(() => {
-              if (own) broker.disconnect(own);
+              if (own) release();
             });
           return;
         }
@@ -98,7 +112,7 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
               (e) => finish({ ok: false, error: e instanceof BusError ? e.code : 'web-failed' }),
             )
             .finally(() => {
-              if (own) broker.disconnect(own);
+              if (own) release();
             });
           return;
         }
@@ -113,7 +127,7 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
           Promise.resolve().then(() => broker.request(cap, { verb: r.verb, args: r.args ?? {} })).then(
             result => { if (!socket.destroyed) finish({ ok: true, result }); },
             e => { if (!socket.destroyed) finish({ ok: false, error: e instanceof BusError ? e.code : 'invalid-envelope' }); },
-          ).finally(() => { if (own) broker.disconnect(own); });
+          ).finally(() => { if (own) release(); });
           return;
         }
         const result = broker.request(cap, { verb: r.verb, args: r.args ?? {} });
@@ -121,11 +135,11 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
       } catch (e) {
         finish({ ok: false, error: e instanceof BusError ? e.code : 'invalid-envelope' });
       } finally {
-        if (transient) broker.disconnect(transient);
+        if (transient) release();
       }
     });
     socket.on('end', () => {
-      if (!done) finish({ ok: false, error: 'incomplete-request' });
+      if (!done && !processing) finish({ ok: false, error: 'incomplete-request' });
     });
   });
   await new Promise((resolve, reject) => {
@@ -139,6 +153,7 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
   const owned = lstatSync(path);
   return {
     async close() {
+      await peers.close();
       for (const s of sockets) s.destroy();
       await new Promise((resolve) => server.close(resolve));
       try {

packages/bus/tests/channel-proof.test.mjs

@@ -1,4 +1,7 @@
-// Row 164 explicitly freezes proof bytes and its literal entry-path rule.
+// Row 164 freezes reviewed proof bytes and the literal entry-path rule.
+// Row 196 intentionally re-pins human.mjs for the distinct user nonce and shared human
+// walk, and webui bus.mjs for initial-spawn nonce plus peer refusal status. Entry paths
+// and the ban on channel plug-ins importing a proof caller are retained.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
@@ -8,7 +11,7 @@ import { provedRuntime } from "../../cli/tests/channel-fixture.mjs";
 import { Client } from "../src/client.mjs";
 
 const baselines = {
- "packages/bus/src/human.mjs": "b995fc5cff3af8ade4c990d0e3bebf9d83829e00f034ebc9c3dcfd05f252b573",
+ "packages/bus/src/human.mjs": "0c6d96abe4607cba0b02b0638a2fc217ff8135bac9a47761a0ef015fbe9d3079",
  "packages/bus/src/human-cli.mjs": "269c3a66008c0d57a54b14b73cf988d5f61f5e815455486296716e98ce5e8073",
  "packages/cli/src/transport.mjs": "5129c44b4d9f642e825344df65c9bfb4bac4fc8d6b25343b42d39853dbd40774",
  // Row 165 (#1662): seven STATUS entries for the role instance routes (organization-instance-exists,
@@ -16,7 +19,7 @@ const baselines = {
  // organization-no-change, organization-project-mismatch, organization-unresolvable-instance), no proof or
  // transport change. Row 155 (#1649) added eight for the assistant routes.
  // Row 171 (#1668): project-name-is-repo maps to 409; no proof or transport change.
- "packages/webui/src/bus.mjs": "76a1b57858c4aa41071746713a196299264851c18322a6f9869d553f0362d421",
+ "packages/webui/src/bus.mjs": "934ab2f9b6bde72aafe7814758550c283eb25a4f3a23b284021b13718d67178f",
 };
 const repoFile = path => new URL("../../../" + path, import.meta.url);
 

packages/bus/tests/interpreter.test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, writeFileSync, chmodSync, symlinkSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { inspectInterpreter, recordInterpreterStart } from '../src/interpreter.mjs';
+
+function fixture(change = {}) {
+  const binary = Buffer.from('\x7fELFbody');
+  return { realpath: () => '/usr/bin/python3.14',
+    stat: path => ({ uid: 0, mode: 0o100755, dev: 1, ino: 10, isFile: () => path.endsWith('3.14'), isDirectory: () => !path.endsWith('3.14') }),
+    readFile: path => path === '/etc/passwd' ? 'root:x:0:0::/root:/bin/sh\nuser:x:1000:1000::/home/user:/bin/sh\n' : binary,
+    exec: () => '[3,14,0]', ...change };
+}
+test('system Python is a resolved root-owned ELF, never a shim or home interpreter', () => {
+  const record = inspectInterpreter({ io: fixture() });
+  assert.equal(record.path, '/usr/bin/python3.14');
+  assert.deepEqual(record.version, [3,14,0]);
+  assert.match(record.sha256, /^[a-f0-9]{64}$/);
+  const bad = [
+    { realpath: () => '/home/user/python3' },
+    { realpath: () => '/root/python3' },
+    { realpath: () => '/srv/user/python3', readFile: p => p === '/etc/passwd' ? 'u:x:1000:1000::/srv/user:/bin/sh' : Buffer.from('\x7fELF') },
+    { readFile: p => p === '/etc/passwd' ? '' : Buffer.from('#!/bin/sh\n') },
+    { stat: () => ({ uid: 1000, mode: 0o100755, isFile: () => true, isDirectory: () => true }) },
+    { stat: () => ({ uid: 0, mode: 0o100775, isFile: () => true, isDirectory: () => true }) },
+    { stat: () => { throw Error('missing'); } },
+    { exec: () => '[3,9,9]' },
+    { exec: () => 'unexpected' },
+  ];
+  for (const f of bad) assert.throws(() => inspectInterpreter({ io: fixture(f) }), /interpreter-unsafe/);
+});
+test('real system interpreter is available and safely inspected', () => {
+  const actual = inspectInterpreter();
+  assert.ok(actual.path.startsWith('/usr/'));
+  assert.ok(actual.version[0] >= 3);
+});
+test('restart receipt appends actual replacement identity and refuses unsafe files', t => {
+  const root = mkdtempSync(join(tmpdir(), 'g196-int-'));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  const first = inspectInterpreter({ io: fixture() });
+  recordInterpreterStart(root, first);
+  const file = join(root, 'peercred-starts.jsonl');
+  const old = readFileSync(file, 'utf8');
+  const second = inspectInterpreter({ io: fixture({ readFile: p => p === '/etc/passwd' ? '' : Buffer.from('\x7fELFnew') }) });
+  recordInterpreterStart(root, second);
+  const now = readFileSync(file, 'utf8');
+  assert.ok(now.startsWith(old));
+  assert.notEqual(JSON.parse(old).sha256, JSON.parse(now.trim().split('\n')[1]).sha256);
+  chmodSync(file, 0o644);
+  assert.throws(() => recordInterpreterStart(root, second), /interpreter-receipt-unsafe/);
+  rmSync(file);
+  writeFileSync(join(root,'target'), 'untouched');
+  symlinkSync(join(root,'target'),file);
+  assert.throws(() => recordInterpreterStart(root, second), /interpreter-receipt-unsafe/);
+  assert.equal(readFileSync(join(root,'target'),'utf8'),'untouched');
+});
+
+test('activation gate compares fresh startup receipt to the current interpreter identity',async t=>{
+ const { verifyInterpreterReceipt }=await import('../src/interpreter.mjs');
+ const root=mkdtempSync(join(tmpdir(),'g196-int-'));t.after(()=>rmSync(root,{recursive:true,force:true}));
+ const first=inspectInterpreter({io:fixture()}),since=Date.now()-1;
+ recordInterpreterStart(root,first);
+ assert.equal(verifyInterpreterReceipt(root,first,since),true);
+ assert.throws(()=>verifyInterpreterReceipt(root,{...first,sha256:'b'.repeat(64)},since),/interpreter-receipt-mismatch/);
+ assert.throws(()=>verifyInterpreterReceipt(root,first,Date.now()+1000),/interpreter-receipt-mismatch/);
+});
+
+test('non-regular startup receipt refuses promptly without waiting on a FIFO peer',async t=>{
+ const {execFileSync,spawnSync}=await import('node:child_process');
+ const root=mkdtempSync(join(tmpdir(),'g196-fifo-'));t.after(()=>rmSync(root,{recursive:true,force:true}));
+ execFileSync('mkfifo',[join(root,'peercred-starts.jsonl')]);
+ const url=new URL('../src/interpreter.mjs',import.meta.url).href;
+ const child=spawnSync(process.execPath,['--input-type=module','-e',`import {recordInterpreterStart} from ${JSON.stringify(url)};try{recordInterpreterStart(${JSON.stringify(root)},{});process.exit(2)}catch(e){process.exit(e.message==='interpreter-receipt-unsafe'?0:3)}`],{timeout:1000});
+ assert.equal(child.status,0,'unsafe FIFO must refuse without blocking startup');
+});

packages/bus/tests/peer-transport.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { connect } from 'node:net';
+import { mkdtempSync,rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { serve } from '../src/server.mjs';
+import { Client } from '../src/client.mjs';
+import { BusError } from '../src/broker.mjs';
+const request=(path,body)=>new Promise((resolve,reject)=>{const s=connect(path);let out='';s.on('error',reject);s.on('data',b=>out+=b);s.on('end',()=>resolve(JSON.parse(out)));s.end(JSON.stringify(body)+'\n');});
+test('proof receives actual peer, cap traffic never invokes helper and transient cap disconnects',async t=>{
+ const root=mkdtempSync(join(tmpdir(),'g196-s-')),path=join(root,'s');let peers=0,auth=0;const disconnected=[];
+ const broker={request:()=>({ok:'value'}),disconnect:c=>disconnected.push(c)};
+ const reader={read:async socket=>{peers++;return {pid:process.pid,uid:process.getuid(),gid:process.getgid()};},close(){}};
+ const server=await serve({path,broker,peerReader:reader,authenticateHuman:(proof,peer)=>{auth++;assert.equal(peer.pid,process.pid);return 'transient';}});
+ t.after(async()=>{await server.close();rmSync(root,{recursive:true,force:true});});
+ assert.equal((await request(path,{human:{pid:process.pid},verb:'agents'})).ok,true);
+ assert.equal(peers,1);assert.equal(auth,1);assert.ok(disconnected.includes('transient'));
+ assert.equal((await request(path,{cap:'existing',verb:'agents'})).ok,true);
+ assert.equal(peers,1);
+});
+test('proof helper error and disconnect during verification never dispatch or bind',async t=>{
+ const root=mkdtempSync(join(tmpdir(),'g196-s-'));let auth=0,calls=0;
+ const broker={request:()=>calls++,disconnect(){}};
+ const server=await serve({path:join(root,'s'),broker,peerReader:{read:async()=>{throw Error('helper');},close(){}},authenticateHuman:()=>{auth++;return 'x';}});
+ t.after(async()=>{await server.close();rmSync(root,{recursive:true,force:true});});
+ assert.equal((await request(join(root,'s'),{human:{pid:process.pid},verb:'agents'})).error,'peercred-required');
+ assert.equal(auth,0);assert.equal(calls,0);
+});
+
+test('Client receives explicit proof refusal codes without dispatch, not outcome-unknown',async t=>{
+ for(const failure of ['human-required','peercred-required']) {
+  const root=mkdtempSync(join(tmpdir(),'g196-refuse-')),path=join(root,'s');let calls=0;
+  const server=await serve({path,broker:{request(){calls++;},disconnect(){}},
+   ...(failure==='peercred-required'?{}:{authenticateHuman(){throw new BusError('human-required');}}),
+   peerReader:failure==='peercred-required'?{read:async()=>{throw Error('helper');},close(){}}:undefined,
+   ...(failure==='peercred-required'?{authenticateHuman(){throw Error('must not authenticate');}}:{})});
+  try {
+   const client=new Client({path,human:{pid:process.pid,business:'fixture',startTime:'0',nonce:'a'.repeat(64)}});
+   await assert.rejects(client.call('agents'),e=>e.code===failure);
+   assert.equal(calls,0);
+  }finally{await server.close();rmSync(root,{recursive:true,force:true});}
+ }
+});
+
+test('asynchronous proof calls release their transient session on success, failure and timeout',async t=>{
+ const {TASK_VERBS,BusError}=await import('../src/broker.mjs');
+ for(const mode of ['success','failure','timeout']) {
+  const root=mkdtempSync(join(tmpdir(),'g196-async-')),path=join(root,'s'),disconnected=[];
+  const broker={disconnect:cap=>disconnected.push(cap),requestTask:()=>mode==='success'?Promise.resolve('done'):mode==='failure'?Promise.reject(new BusError('fixture-failed')):new Promise(()=>{})};
+  const server=await serve({path,broker,tasks:{handle(){},timeout:25},peerReader:{read:async()=>({pid:process.pid,uid:process.getuid(),gid:process.getgid()}),close(){}},authenticateHuman:()=>mode});
+  try {
+   const response=await request(path,{human:{pid:process.pid},verb:TASK_VERBS[0]});
+   assert.equal(response.ok,mode==='success');
+   if(mode==='timeout')assert.equal(response.error,'request-timeout');
+   assert.deepEqual(disconnected,[mode]);
+  }finally{await server.close();rmSync(root,{recursive:true,force:true});}
+ }
+});

packages/bus/tests/peercred.test.mjs

@@ -0,0 +1,108 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:net';
+import { fork } from 'node:child_process';
+import { once } from 'node:events';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { createPeerReader } from '../src/peercred.mjs';
+import { inspectInterpreter } from '../src/interpreter.mjs';
+
+const interpreter = inspectInterpreter();
+test('T2 eight proof callers and a racing copier bind the exact accepted socket, which survives helper exit', {timeout:10000}, async t => {
+  const root = mkdtempSync(join(tmpdir(),'g196-p-'));
+  const path = join(root,'s');
+  const reader = createPeerReader({interpreter});
+  const sockets = [], pending = [], after = [];
+  let resolveReady;
+  const ready = new Promise(r => resolveReady = r);
+  const server = createServer({allowHalfOpen:true}, socket => {
+    sockets.push(socket);
+    let text = '';
+    socket.on('data', chunk => {
+      text += chunk;
+      if (!text.includes('\n')) return;
+      if (!socket.proof) {
+        socket.proof = JSON.parse(text.slice(0,text.indexOf('\n')));
+        text = text.slice(text.indexOf('\n')+1);
+        pending.push(socket);
+        if (pending.length === 9) resolveReady();
+      }
+      if (text.includes('after-helper\n')) after.push(socket);
+    });
+    socket.on('error',()=>{});
+  });
+  const children = [];
+  t.after(async () => { reader.close(); for(const c of children)c.kill(); for(const s of sockets)s.destroy(); await new Promise(r=>server.close(r)); rmSync(root,{recursive:true,force:true}); });
+  await new Promise(r=>server.listen(path,r));
+  const pids=[];
+  for(let i=0;i<9;i++) {
+    const c=fork(new URL('../fixtures/peer-client.mjs',import.meta.url),[],{stdio:['ignore','ignore','inherit','ipc']});
+    children.push(c); pids.push((await once(c,'message'))[0].pid);
+  }
+  const replies=children.map(c=>once(c,'message'));
+  children.forEach((c,i)=>c.send({path,...(i===8?{claimed:pids[0]}:{})}));
+  await ready;
+  const peers = await Promise.all(pending.map(socket => reader.read(socket)));
+  pending.forEach(s=>s.resume()); // spawn stdio pauses inherited streams.
+  assert.equal(new Set(peers.map(p=>p.pid)).size,9);
+  pending.forEach((socket,i)=> {
+    const peer=peers[i];
+    assert.equal(peer.uid,process.getuid());
+    const accepted=peer.pid===socket.proof.human.pid;
+    assert.equal(accepted, peer.pid!==pids[8]);
+    socket.write(JSON.stringify({accepted,pid:peer.pid})+'\n');
+  });
+  const results=await Promise.all(replies);
+  assert.equal(results.filter(([r])=>r.reply.accepted).length,8);
+  assert.equal(results[8][0].reply.accepted,false);
+  await Promise.all(sockets.map(s=>s.readableEnded?Promise.resolve():once(s,'end')));
+  assert.equal(after.length,9, 'all sockets read after the helper closed its duplicate');
+});
+
+function fakeSpawn(output, status=0) {
+  return () => {
+    const child=new EventEmitter(); child.stdout=new PassThrough(); child.stderr=new PassThrough();
+    child.kill=()=>{queueMicrotask(()=>child.emit('close',null,'SIGKILL'));return true;};
+    queueMicrotask(()=>{child.stdout.end(output);child.emit('close',status,null);});
+    return child;
+  };
+}
+test('helper output and failures fail closed including unsafe gid', async () => {
+  for(const [out,code] of [['{}',0],['{"pid":2,"uid":0,"gid":9007199254740992}',0],['{"pid":2,"uid":0,"gid":0}\nextra',0],['x'.repeat(257),0],['{"pid":2,"uid":0,"gid":0}',1]]) {
+    const reader=createPeerReader({interpreter,spawn:fakeSpawn(out,code)});
+    await assert.rejects(reader.read({}),/peercred-required/);reader.close();
+  }
+  const reader=createPeerReader({interpreter,spawn:()=>{throw Error('spawn');}});
+  await assert.rejects(reader.read({}),/peercred-required/);reader.close();
+});
+test('helper timeout, capacity and shutdown refuse without leaving children', async () => {
+  const reader=createPeerReader({interpreter,timeout:25,spawn:()=>{
+    const c=new EventEmitter();c.stdout=new PassThrough();c.stderr=new PassThrough();
+    c.kill=()=>{queueMicrotask(()=>c.emit('close',null,'SIGKILL'));return true;};return c;
+  }});
+  const jobs=Array.from({length:16},()=>assert.rejects(reader.read({}),/peercred-required/));
+  await assert.rejects(reader.read({}),/peercred-required/);
+  await Promise.all(jobs);reader.close();
+  await assert.rejects(reader.read({}),/peercred-required/);
+});
+
+test('missing or non-regular peer helper refuses at construction before opening the bus',()=>{
+ assert.throws(()=>createPeerReader({interpreter,stat:()=>{throw Error('missing');}}),/peercred-required/);
+ assert.throws(()=>createPeerReader({interpreter,stat:()=>({isFile:()=>false,isSymbolicLink:()=>true})}),/peercred-required/);
+});
+
+test('shutdown waits for killed helper close before returning',async()=>{
+ let reaped=0;
+ const reader=createPeerReader({interpreter,spawn:()=>{
+  const c=new EventEmitter();c.stdout=new PassThrough();c.stderr=new PassThrough();
+  c.kill=()=>{setTimeout(()=>{reaped++;c.emit('close',null,'SIGKILL');},5);return true;};return c;
+ }});
+ const pending=assert.rejects(reader.read({}),/peercred-required/);
+ await reader.close();
+ assert.equal(reaped,1,'shutdown must await the helper close event');
+ await pending;
+});

packages/bus/tests/principal.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { verifyPrincipal } from '../src/principal.mjs';
+const nonce='a'.repeat(64), uid=process.getuid();
+const paths={human:'/tree/human-cli.mjs',tester:'/tree/tester-cli.mjs',user:'/tree/user-cli.mjs',console:'/tree/console.mjs'};
+function context(kind='human') {
+ const variable=kind==='human'?'MOSAIC_BUS_CLI_NONCE':kind==='tester'?'MOSAIC_BUS_TESTER_NONCE':'MOSAIC_BUS_USER_NONCE';
+ const table=new Map([[50,{pid:50,ppid:40,startTime:'100',uid,argv:['node',paths[kind]],env:{[variable]:nonce}}],
+ [40,{pid:40,ppid:1,startTime:'90',uid,argv:['node',paths.console,'serve'],env:{}}]]);
+ return {peer:{pid:50,uid,gid:uid},paths,businesses:{demo:{human:'owner'}},launches:[],
+ readProcess:pid=>{if(!table.has(pid))throw Error('gone');return {...table.get(pid)};},
+ readTesterNonce:()=>table.get(50).env.MOSAIC_BUS_TESTER_NONCE,table};
+}
+const proof={pid:50,startTime:'100',nonce,business:'demo'};
+test('principal binds kernel peer PID and uid, maps owner, and never takes identity or role from body',()=>{
+ const c=context();
+ assert.deepEqual(verifyPrincipal({human:proof},c),{kind:'owner',business:'demo',id:'owner'});
+ for(const peer of [{pid:51,uid,gid:uid},{pid:50,uid:uid+1,gid:uid}])assert.throws(()=>verifyPrincipal({human:proof},{...c,peer}),/human-required/);
+ assert.throws(()=>verifyPrincipal({human:{...proof,human:'other'}},c),/human-required/);
+ assert.throws(()=>verifyPrincipal({human:proof,tester:proof},c),/invalid-envelope/);
+});
+test('user requires its own nonce and full walk plus immediate same-tree Console parent',()=>{
+ const request={user:{...proof,user:'owner'}};
+ assert.deepEqual(verifyPrincipal(request,context('user')),{kind:'user',business:'demo',id:'owner'});
+ for(const change of [{argv:['bash']},{argv:['node','/other/console.mjs','serve']},{argv:['node',paths.console,'other']},{env:{CODEX_THREAD_ID:'agent'}}]) {
+  const c=context('user');Object.assign(c.table.get(40),change);
+  assert.throws(()=>verifyPrincipal(request,c),/human-required/);
+ }
+ const wrong=context('user');wrong.table.get(50).env={MOSAIC_BUS_CLI_NONCE:nonce};
+ assert.throws(()=>verifyPrincipal(request,wrong),/human-required/);
+ const launched=context('user');launched.launches=[{pid:40,startTime:'90'}];
+ assert.throws(()=>verifyPrincipal(request,launched),/human-required/);
+ const changed=context('user'), read=changed.readProcess;let n=0;
+ changed.readProcess=pid=>{const p=read(pid);if(pid===40&&n++>0)p.startTime='91';return p;};
+ assert.throws(()=>verifyPrincipal(request,changed),/human-required/);
+});
+test('tester deliberately admits agent parents but rejects managed runs and another nonce',()=>{
+ const c=context('tester');c.table.get(40).env={CODEX_THREAD_ID:'seat'};
+ assert.deepEqual(verifyPrincipal({tester:proof},c),{kind:'tester',business:'demo',id:'tester'});
+ c.table.get(40).env={MOSAIC_RUN_ID:'managed'};
+ assert.throws(()=>verifyPrincipal({tester:proof},c),/tester-required/);
+});
+
+test('human leaf identity is reread after walking the parents',()=>{
+ const c=context(),read=c.readProcess;let n=0;
+ c.readProcess=pid=>{const p=read(pid);if(pid===50&&n++>0)p.startTime='101';return p;};
+ assert.throws(()=>verifyPrincipal({human:proof},c),/human-required/);
+});

packages/cli/README.md

@@ -1017,3 +1017,12 @@ provider/model, provider and account groups, with input/output/cacheWrite/
 cacheRead and unknown turns beside every total. JSON retains the full view.
 Account is unassigned today. Unknown turns can have used tokens: known sums
 are a best reading of session-editable transcripts, not proof or a limit check.
+
+### Private tester HTTP (row 196)
+
+`node packages/cli/src/tester-http.mjs GET /api/config` selects the instance's
+console/tester.sock from its dataRoot. POST reads one bounded JSON body from stdin.
+The helper supplies the fixed logical origin, reports status/text/body as JSON,
+and never retries an uncertain write. It cannot navigate a browser or upgrade the
+tester to an owner. `mosaic ... --tester` continues using broker.sock directly.
+See docs/TOOLS.md for explicit activation conversion and rollback behavior.

packages/cli/src/tester-http.mjs

@@ -0,0 +1,39 @@
+import { request } from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { testerSocketPath, TESTER_ORIGIN } from '../../webui/src/tester-socket.mjs';
+
+export function testerRequest({ dataRoot, path = '/healthz', method = 'GET', body, headers = {}, timeout = 30000 }) {
+  if (typeof path !== 'string' || !/^\/(?!\/)/.test(path) || /[\r\n\0]/.test(path)) return Promise.reject(Error('tester-http-path'));
+  const data = body === undefined ? undefined : JSON.stringify(body);
+  if (data && Buffer.byteLength(data) > 16384) return Promise.reject(Error('tester-http-size'));
+  return new Promise((resolve, reject) => {
+    const req = request({ socketPath: testerSocketPath(dataRoot), path, method,
+      headers: { host: new URL(TESTER_ORIGIN).host, origin: TESTER_ORIGIN, 'sec-fetch-site': 'same-origin',
+        ...(data ? { 'content-type': 'application/json' } : {}), ...headers } }, res => {
+      const chunks = []; let size = 0;
+      res.on('data', b => { size += b.length; if (size > 8 * 1024 * 1024) req.destroy(Error('tester-http-size')); else chunks.push(b); });
+      res.on('error', reject);
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        try { resolve({ status: res.statusCode, text, body: res.headers['content-type']?.includes('json') ? JSON.parse(text) : null }); }
+        catch { reject(Error('tester-http-response')); }
+      });
+    });
+    req.setTimeout(timeout, () => req.destroy(Error('tester-http-timeout')));
+    req.on('error', reject);
+    req.end(data);
+  });
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  try {
+    const { loadSystem } = await import('./config.mjs');
+    const [method = 'GET', path = '/healthz'] = process.argv.slice(2);
+    if (!['GET', 'HEAD', 'POST'].includes(method) || process.argv.length > 4) throw Error('tester-http-usage');
+    const body = method === 'POST' ? JSON.parse(readFileSync(0, 'utf8')) : undefined;
+    const result = await testerRequest({ dataRoot: loadSystem().dataRoot, path, method, body });
+    process.stdout.write(JSON.stringify(result) + '\n');
+    if (result.status >= 400) process.exitCode = 2;
+  } catch { process.stderr.write('tester-http-refused\n'); process.exitCode = 2; }
+}

packages/cli/tests/stack-release.test.mjs

@@ -314,9 +314,9 @@ function biz(e,plugins){
  writeFileSync(f,JSON.stringify(b,null,2)+'\n',{mode:0o600});chmodSync(f,0o600);
 }
 
-async function mk(t){
+async function mk(t,dataName='data'){
  const root=realpathSync(mkdtempSync(join(tmpdir(),'sr-')));
- const e={root,data:join(root,'data'),bin:join(root,'bin'),sd:join(root,'sd'),units:join(root,'xcfg','systemd','user'),cfg:join(root,'cfg','config.json'),claude:join(root,'claude-bin','claude')};
+ const e={root,data:join(root,dataName),bin:join(root,'bin'),sd:join(root,'sd'),units:join(root,'xcfg','systemd','user'),cfg:join(root,'cfg','config.json'),claude:join(root,'claude-bin','claude')};
  Object.assign(e,{state:join(e.data,'state'),pointer:join(e.data,'state','stack-active.json'),log:join(e.data,'state','stack-activation-log.jsonl'),store:join(e.data,'bus','bus.sqlite'),lock:join(e.data,'state','stack-release.lock')});
  for(const d of [join(root,'home'),dirname(e.cfg),join(e.data,'bus'),e.bin,dirname(e.claude),join(e.sd,'faults'),e.units,join(root,'xdata')])mkdirSync(d,{recursive:true});
  chmodSync(join(e.data,'bus'),0o700);
@@ -381,7 +381,7 @@ async function seed(e,{copy=B,pm=false,store='3g',pointer:how='adopt'}={}){
 const rolledBack=(code,to=B)=>`stack-release: ${code}; rolled back to ${to}, which passed the gate\n`;
 const planBackup=(e)=>`backup: the run backs up the stopped store to ${e.data}/backups/stack/<activation>/ before any migration`;
 const planNoBackup='backup: none; the run rolls back before the backup';
-const planTail=(e,to,pm=false)=>[`bus: scripts/bus-service.sh install --copy ${to} --copies ${COPIES}${pm?' --pm':''} --claude ${e.claude}`,'proof: off','send: off',`Console: scripts/webui-service.sh install --copy ${to} --copies ${COPIES} --port ${e.port} --business acme`,`CLI: scripts/stack-copy.sh wrapper ${to} --copies ${COPIES} --bin ${e.bin}`];
+const planTail=(e,to,pm=false)=>[`bus: scripts/bus-service.sh install --copy ${to} --copies ${COPIES}${pm?' --pm':''} --claude ${e.claude}`,'proof: off',`Console: scripts/webui-service.sh install --copy ${to} --copies ${COPIES} --port ${e.port} --business acme`,`CLI: scripts/stack-copy.sh wrapper ${to} --copies ${COPIES} --bin ${e.bin}`];
 
 // --- The T table ---
 
@@ -1030,17 +1030,17 @@ test('T36 --plan shows the pending state and lists the row 169 refusals it can s
   return r.out.split('\n');
  };
  let out=await quiet(0,'activate',C1,'acme','--pm-after-harness','--plan');
- assert.deepEqual(out.slice(-7),['pm: the bus starts without --pm and the PM stays pending; next: Jason\'s plugins set of harness, then pm-on',...planTail(e,C1),'']);
+ assert.deepEqual(out.slice(-6),['pm: the bus starts without --pm and the PM stays pending; next: Jason\'s plugins set of harness, then pm-on',...planTail(e,C1),'']);
  biz(e,HARNESS);
  out=await quiet(3,'activate',A,'acme','--pm-after-harness','--plan');
- assert.deepEqual(out.slice(-8),['pm: the bus starts without --pm and the PM stays pending; next: Jason\'s plugins set of harness, then pm-on',...planTail(e,A),`refuses unknown-kind-for-target: the business file names plug-in kind(s) harness, which ${A} does not know`,'']);
+ assert.deepEqual(out.slice(-7),['pm: the bus starts without --pm and the PM stays pending; next: Jason\'s plugins set of harness, then pm-on',...planTail(e,A),`refuses unknown-kind-for-target: the business file names plug-in kind(s) harness, which ${A} does not know`,'']);
  out=await quiet(3,'activate',C1,'acme','--pm-after-harness','--plan');
  assert.equal(out.at(-2),'refuses pm-after-harness-set: the business file already sets harness ["claude-code"]; use --pm');
  biz(e);assert.equal((await run(e,'activate',C1,'acme','--pm-after-harness')).code,0);
  out=await quiet(3,'activate',C,'acme','--plan');
- assert.deepEqual(out.slice(-8),['pm: the pointer is pending (activate --pm-after-harness); the bus runs without its PM',...planTail(e,C,true),`refuses pm-pending: ${PENDING_MSG}`,'']);
+ assert.deepEqual(out.slice(-7),['pm: the pointer is pending (activate --pm-after-harness); the bus runs without its PM',...planTail(e,C,true),`refuses pm-pending: ${PENDING_MSG}`,'']);
  out=await quiet(0,'rollback','acme','--plan');
- assert.deepEqual(out.slice(-7),['pm: the pointer is pending (activate --pm-after-harness); the bus runs without its PM',...planTail(e,B,true),'']);
+ assert.deepEqual(out.slice(-6),['pm: the pointer is pending (activate --pm-after-harness); the bus runs without its PM',...planTail(e,B,true),'']);
 });
 
 // Row 176 test 11: supported and older Console copies deliberately differ from the checkout.
@@ -1706,113 +1706,6 @@ test('T54 row 188: a carried pair gets the proof file checks, and a proof file i
  });
 });
 
-// Row 189 (#1687, mos-0972/0973): activate --no-send drops the pointer's --send; nothing turns it back on.
-const sendLines=(out)=>out.filter((l)=>l.startsWith('send:'));
-const noSend=(c)=>c.filter((x)=>x!=='--send');
-const LIVE_NOTE=`note: ${B} is the pointer's copy; the run re-pins it and only the Console flags change`;
-test('T55 row 189: activate --no-send drops --send, and rollback and pm-on carry it off',async(t)=>{
- await t.test('test 1: a live-copy --no-send drops --send from the pointer and the unit, keeps the rest in order, logs the step and backs up the stopped store',async(t)=>{
-  const e=await mk(t),base=await seedPreview(e,undefined,['--send','--tester-port','7333']),want=noSend(base);
-  assert.deepEqual(want.slice(-2),['--tester-port','7333']);
-  const sum=createHash('sha256').update(readFileSync(e.store)).digest('hex'),n=calls(e).length;
-  let r=await prun(e,'activate',B,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  assert.equal(pointer(e).copy,B);assert.deepEqual(pointer(e).console,want);
-  assert.ok(conExec(e).endsWith(` --checkout ${repo} ${want.join(' ')}`),conExec(e));assert.doesNotMatch(conExec(e),/ --send( |$)/);
-  r=await prun(e,'status','acme');assert.equal(r.code,0,r.err);assert.match(r.out,/unit flags: match the pointer/);
-  assert.match(stepText(e),/Z drop --send; --no-send was given\n/);
-  const act=pointer(e).activation,l=logLines(e).at(-1);
-  assert.deepEqual([l.op,l.from,l.to,l.result,l.backup],['activate',B,B,'ok',act]);assert.equal(backupSum(e,act),sum);
-  assert.deepEqual(startsStops(e,n),[`stop ${CON}`,`stop ${BUS}`,`start ${BUS}`,`start ${CON}`]);
-  await noLeak(e);
- });
- await t.test('test 2: a plain live-copy activate still refuses already-active, and so does --no-send once --send is gone',async(t)=>{
-  const e=await mk(t);await seedPreview(e,undefined,['--send']);
-  await refused(e,['activate',B,'acme'],'already-active',`${B} is the pointer's copy`);
-  await refused(e,['activate',B,'acme','--tester-port','7333'],'already-active',`${B} is the pointer's copy`);
-  await refused(e,['activate',B,'acme','--no-proof'],'already-active',`${B} is the pointer's copy`);
-  const r=await prun(e,'activate',B,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  await refused(e,['activate',B,'acme','--no-send'],'already-active',`${B} is the pointer's copy`);
-  const g=await mk(t);await seedPreview(g);
-  await refused(g,['activate',B,'acme','--no-send'],'already-active',`${B} is the pointer's copy`);
-  for(const x of [e,g])await noLeak(x);
- });
- await t.test('test 3: --plan prints one send: line in each case, with the live-copy note on a same-copy run',async(t)=>{
-  const e=await mk(t),base=await seedPreview(e,undefined,['--send']);
-  let out=await planOnly(e,0,'activate',B,'acme','--no-send');
-  assert.deepEqual(sendLines(out),['send: dropped; --no-send was given']);
-  assert.deepEqual(out.filter((l)=>l.startsWith('note: ')),[LIVE_NOTE]);
-  assert.equal(out[out.indexOf('send: dropped; --no-send was given')+1],`Console: scripts/webui-service.sh install --copy ${B} --copies ${COPIES} ${noSend(base).join(' ')}`);
-  out=await planOnly(e,0,'activate',C1,'acme');
-  assert.deepEqual(sendLines(out),['send: carried']);assert.deepEqual(out.filter((l)=>l.startsWith('note: ')),[]);
-  assert.ok(out.find((l)=>l.startsWith('Console: ')).endsWith(' --send'));
-  assert.deepEqual(sendLines(await planOnly(e,0,'activate',C1,'acme','--no-send')),['send: dropped; --no-send was given']);
-  let r=await prun(e,'activate',C1,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(e).console,noSend(base));assert.match(stepText(e),/Z drop --send; --no-send was given\n/);
-  assert.deepEqual(sendLines(await planOnly(e,0,'activate',B,'acme','--no-send')),['send: off; --no-send was given and the pointer holds no --send']);
-  assert.deepEqual(sendLines(await planOnly(e,0,'activate',B,'acme')),['send: off']);
-  assert.deepEqual(sendLines(await planOnly(e,0,'rollback','acme')),['send: off']);
-  r=await prun(e,'activate',B,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  assert.match(stepText(e),/Z --no-send was given and the pointer holds no --send, so there is nothing to drop\n/);
-  assert.doesNotMatch(stepText(e),/drop --send/);
-  await noLeak(e);
- });
- await t.test('test 4: after --no-send, a rollback to the earlier copy leaves --send out of the pointer and the unit',async(t)=>{
-  const e=await mk(t),base=await seedPreview(e,undefined,['--send']);
-  let r=await prun(e,'activate',C1,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  r=await prun(e,'rollback','acme');assert.equal(r.code,0,r.out+r.err);
-  assert.equal(pointer(e).copy,B);assert.deepEqual(pointer(e).console,noSend(base));assert.doesNotMatch(conExec(e),/ --send( |$)/);
-  assert.doesNotMatch(stepText(e),/--send/);
-  r=await prun(e,'status','acme');assert.equal(r.code,0,r.err);assert.match(r.out,/unit flags: match the pointer/);
-  await noLeak(e);
- });
- await t.test('test 4: pm-on after --no-send keeps --send off',async(t)=>{
-  const e=await mk(t),base=await seedPreview(e,{pm:true},['--send']);
-  let r=await prun(e,'activate',C1,'acme','--pm-after-harness','--no-send');assert.equal(r.code,0,r.out+r.err);
-  biz(e,HARNESS);
-  r=await prun(e,'pm-on','acme');assert.equal(r.code,0,r.out+r.err);
-  assert.equal(pointer(e).pm,true);assert.deepEqual(pointer(e).console,noSend(base));assert.doesNotMatch(conExec(e),/ --send( |$)/);
-  r=await prun(e,'status','acme');assert.equal(r.code,0,r.err);assert.match(r.out,/unit flags: match the pointer/);
-  await noLeak(e);
- });
- await t.test('test 5: --no-send on rollback, pm-on, status, adopt or rehearse is a usage error',async(t)=>{
-  const e=await mk(t);await seedPreview(e,undefined,['--send']);
-  const usageText=(await prun(e,'--help')).err,n=calls(e).length,logs=logLines(e).length,before=fp(e);
-  for(const args of [['rollback','acme','--no-send'],['rollback','acme','--plan','--no-send'],['pm-on','acme','--no-send'],['status','acme','--no-send'],['adopt','acme','--no-send'],
-   ['rehearse','acme','--backup','/tmp/x','--port','7400','--no-send']]){
-   const r=await prun(e,...args);assert.equal(r.code,4,args.join(' '));assert.equal(r.out,'');assert.equal(r.err,usageText);
-  }
-  assert.match(usageText,/\| --no-proof\] \[--no-send\]/);
-  assert.deepEqual(fp(e),before);assert.deepEqual(startsStops(e,n),[]);assert.equal(logLines(e).length,logs);
-  await noLeak(e);
- });
- await t.test('test 6: with both a pair and --send in the pointer, --no-send and --no-proof each drop what they name and keep the rest',async(t)=>{
-  const e=await mk(t),base=await seedPreview(e,undefined,['--send']),pre=noSend(base),f=await proofFile(e),g=await proofFile(e,'proof2.189',0o400);
-  let r=await prun(e,'activate',B,'acme',...pair(f));assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(e).console,[...pre,...pair(f),'--send']);
-  let out=await planOnly(e,0,'activate',C1,'acme','--no-proof');
-  assert.deepEqual([...proofLines(out),...sendLines(out)],['proof: dropped; --no-proof drops header x-console-proof','send: carried']);
-  out=await planOnly(e,0,'activate',C1,'acme','--no-send');
-  assert.deepEqual([...proofLines(out),...sendLines(out)],['proof: carried, header x-console-proof','send: dropped; --no-send was given']);
-  out=await planOnly(e,0,'activate',B,'acme','--no-send','--no-proof');
-  assert.deepEqual([...proofLines(out),...sendLines(out)],['proof: dropped; --no-proof drops header x-console-proof','send: dropped; --no-send was given']);
-  r=await prun(e,'activate',C1,'acme','--no-send');assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(e).console,[...pre,...pair(f)]);
-  r=await prun(e,'activate',C1,'acme','--no-send',...pair(g,'X-Proof-Two'));assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(e).console,[...pre,...pair(g,'X-Proof-Two')]);
-  r=await prun(e,'status','acme');assert.equal(r.code,0,r.err);assert.match(r.out,/unit flags: match the pointer/);
-  const h=await mk(t),hbase=await seedPreview(h,undefined,['--send']),hpre=noSend(hbase),k=await proofFile(h);
-  r=await prun(h,'activate',B,'acme',...pair(k));assert.equal(r.code,0,r.out+r.err);
-  r=await prun(h,'activate',C1,'acme','--no-proof');assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(h).console,[...hpre,'--send']);
-  r=await prun(h,'activate',C1,'acme','--no-send','--no-proof');assert.equal(r.code,0,r.out+r.err);
-  assert.deepEqual(pointer(h).console,hpre);assert.doesNotMatch(conExec(h),/--proof-| --send( |$)/);
-  const steps=stepText(h);
-  assert.match(steps,/Z --no-proof was given and the pointer holds no proof pair, so there is nothing to drop\n/);assert.match(steps,/Z drop --send; --no-send was given\n/);
-  r=await prun(h,'status','acme');assert.equal(r.code,0,r.err);assert.match(r.out,/unit flags: match the pointer/);
-  for(const x of [e,h])await noLeak(x);
- });
-});
-
 // --- rehearse (D2, row 163; the brief's "Stack rehearsal on a scratch root") ---
 // Copies of their own in RCOPIES: the real scripts/mosaic, config loader, business loader, roles and
 // mosaic-config.mjs, with stand-ins for the bus host (cli.mjs), the Console, the Store and
@@ -2191,3 +2084,30 @@ test('R15 a rehearsal stopped by TERM, INT or HUP fails signal and still stops t
   assert.equal(existsSync(`/proc/${pid}`),false,`${sig}: host pid ${pid} is still there`);
  }
 });
+
+test('row196 explicit socket conversion refuses inherited TCP before stop and rollback disables socket',async t=>{
+ const e=await mk(t),base=await seedPreview(e,{copy:A}),proof=await proofFile(e);
+ let r=await run(e,'activate',B,'acme','--tester-port','7333');assert.equal(r.code,0,r.out+r.err);
+ const file=join(COPIES,C1,'packages/webui/src/cli.mjs'),original=readFileSync(file,'utf8');
+ chmodSync(file,0o644);writeFileSync(file,'// MOSAIC_TESTER_SOCKET_V1\n// --tester-socket\n// --proof-header\n');chmodSync(file,0o444);
+ t.after(()=>{chmodSync(file,0o644);writeFileSync(file,original);chmodSync(file,0o444);});
+ const module=join(COPIES,C1,'packages/bus/src/interpreter.mjs');
+ chmodSync(dirname(module),0o755);
+ writeFileSync(module,'export const inspectInterpreter=()=>({path:"/usr/bin/python3",sha256:"fixture"});export const verifyInterpreterReceipt=()=>true;\n');chmodSync(module,0o444);chmodSync(dirname(module),0o555);
+ t.after(()=>{chmodSync(dirname(module),0o755);rmSync(module);chmodSync(dirname(module),0o555);});
+ const n=calls(e).length;
+ r=await run(e,'activate',C1,'acme');assert.equal(r.code,3,r.out+r.err);assert.match(r.err,/tester-transport-migration/);assert.deepEqual(startsStops(e,n),[]);
+ r=await run(e,'activate',C1,'acme','--tester-socket','--plan');assert.equal(r.code,0,r.out+r.err);assert.match(r.out,/--tester-socket/);assert.match(r.out,/drop.*--tester-port 7333/);
+ r=await run(e,'activate',C1,'acme','--tester-socket',...pair(proof));assert.equal(r.code,0,r.out+r.err);
+ assert.deepEqual(pointer(e).console,[...base,...pair(proof),'--tester-socket']);assert.match(consoleText(e),/--tester-socket/);assert.doesNotMatch(consoleText(e),/--tester-port/);
+ r=await run(e,'rollback','acme');assert.equal(r.code,0,r.out+r.err);assert.doesNotMatch(consoleText(e),/--tester-(socket|port)/);assert.match(r.out,/drop.*--tester-socket/);
+ await noLeak(e);
+ mkdirSync(join(e.data,'console'),{mode:0o755});
+ const unsafeBefore=calls(e).length;
+ r=await run(e,'activate',C1,'acme','--tester-socket');
+ assert.equal(r.code,3,r.out+r.err);assert.match(r.err,/tester-socket-path/);assert.deepEqual(startsStops(e,unsafeBefore),[]);
+ const long=await mk(t,'data-'+ 'a'.repeat(100));await seed(long,{copy:B});
+ const before=calls(long).length;
+ r=await run(long,'activate',C1,'acme','--tester-socket');
+ assert.equal(r.code,3,r.out+r.err);assert.match(r.err,/tester-socket-path/);assert.deepEqual(startsStops(long,before),[]);
+});

packages/cli/tests/tester-http.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtempSync,rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { bindTesterSocket, testerSocketPath, TESTER_ORIGIN } from '../../webui/src/tester-socket.mjs';
+import { testerRequest } from '../src/tester-http.mjs';
+test('tester HTTP helper uses instance socket, logical origin and JSON without retrying',async t=>{
+ const root=mkdtempSync(join(tmpdir(),'g196-h-'));let hits=0;
+ const server=await bindTesterSocket(createServer((q,r)=>{hits++;assert.equal(q.headers.host,new URL(TESTER_ORIGIN).host);assert.equal(q.headers.origin,TESTER_ORIGIN);r.setHeader('content-type','application/json');r.end('{"ok":true}');}),testerSocketPath(root));
+ t.after(async()=>{await new Promise(r=>server.close(r));rmSync(root,{recursive:true,force:true});});
+ assert.equal((await testerRequest({dataRoot:root,path:'/fixture',method:'POST',body:{x:1}})).body.ok,true);
+ assert.equal(hits,1);
+ for(const path of ['//remote','bad','/a\n'])await assert.rejects(testerRequest({dataRoot:root,path}),/tester-http-path/);
+ await assert.rejects(testerRequest({dataRoot:root,body:{x:'x'.repeat(16385)}}),/tester-http-size/);
+});
+test('tester HTTP timeout closes the socket and does not retry',async t=>{
+ const root=mkdtempSync(join(tmpdir(),'g196-h-'));let hits=0;
+ const server=await bindTesterSocket(createServer(()=>{hits++;}),testerSocketPath(root));
+ t.after(async()=>{server.closeAllConnections();await new Promise(r=>server.close(r));rmSync(root,{recursive:true,force:true});});
+ await assert.rejects(testerRequest({dataRoot:root,timeout:20}),/tester-http-timeout/);
+ assert.equal(hits,1);
+});