gizmoduck: T3 federation design r4.11 for #414 (mos-1063): hub on .54 VM 1012 as mosaic (Q181), R8 depends on the Case 2 install (#416), #418 dropped

agents/README.md

@@ -16,17 +16,6 @@ not fleet seats. Keep changes in `/mnt/storage/src/mosaic-stack`; do not modify
 | Rocko | General development, investigation, testing, and review | T3 session (Codex, gpt-6.1-sol, thread d99326cc, lead decision 122; Claude thread b84bb264 retired 2026-10-12); launcher Claude Code, Sonnet model | `agents/rocko/launch.sh` |
 | Filbert | General development, investigation, testing, and review | T3 session (Claude, Opus 5.5, thread 048f3c63, non-sandbox reviews only, lead decisions 130 and 134; Codex threads f712d8af and 50342f6a retired 2026-10-13, Claude thread 9cb9731e retired 2026-10-12); launcher Pi, `openai-codex/gpt-6-astra:low`, not to be used under R26 until it changes (lead decision 69) | `agents/filbert/launch.sh` |
 | Researcher | Source-grounded technical research and evidence | T3 session (Claude, Sonnet 5.5, thread 9bac0794, rows 97 and 98, lead decision 124); Haiku rows (71, 80, 84, 88, later 96) run as subagents Sage dispatches with model haiku, effort high and a worktree (lead decision 129); Haiku thread c98aaf4a retired 2026-10-13 unused; launcher Pi, configured Mosaic model | `agents/researcher/launch.sh` |
-| Launchpad | Builder, MVP T1 row 192 (Q175 SSO phase 1) | T3 session (Claude, Opus 5.5), started by Sage under mos-0974/0977 | none, T3 only |
-| 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` |
 
 Each script supports `--check` and `--fresh`. Normal launches resume the agent's

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/duckworth/README.md

@@ -1,7 +0,0 @@
-# Duckworth
-
-Reviewer seat, Claude Opus 5.5, started by Mos (mos-0977, thread ffceafec). Reviews federation designs and MVP T1 row 193.
-
-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 `duckworth/*` branches
-through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

agents/gander/README.md

@@ -1,8 +0,0 @@
-# Gander
-
-Builder seat, Codex gpt-6.1-sol, started by Sage under mos-0977 item 5 (more Codex Sol rows) for the human
-boundary row (P19 333, #1694, mos-0989).
-
-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 `gander/*`
-branches through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

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/gizmoduck/work/federation/DESIGN.md

@@ -0,0 +1,655 @@
+# T3 federation design: factory and hub (Vikunja #414, G3, G4, C1.1)
+
+Author Gizmoduck (Opus 5.5), 2026-10-20, r4.11. Design only, no product code. Reviewer Duckworth (Opus 5.5,
+mos-0978), r1 verdict changes B1-B5 (duckworth-0001, REVIEW.md at b402197ff), r2 verdict changes B6 (duckworth-0002,
+REVIEW-r2.md at 03a663cd7), r3 verdict changes B7 (duckworth-0003, REVIEW-r3.md at 45cbe5896), r4 verdict changes B8 (duckworth-0005, REVIEW-r4.md at
+4966136d4), r4.1 verdict changes, B8's issuer host (duckworth-0007, REVIEW-r4.1.md at b14f11136), r4.4 verdict changes B9 (duckworth-0010, REVIEW-r4.4.md at 4cf3ce232), r4.5 approved (duckworth-0012, REVIEW-r4.5.md at 912b1d325). R1, R2 and R5 go to Sage's
+queue once Duckworth approves, and Sage assigns owners. Code lines are at origin/refactor 9ae8c73ac. The
+Q175 SSO design is cited at Sage's local commit 817e8f51b (agents/sage/work/q175-sso/DESIGN.md), which was
+not on origin when this was written.
+
+Binding inputs: TARGET.md addendum 2026-10-20, DECISIONS Q175 to Q178, projects/mosaic-mvp/GAP-MAP.md and
+PLAN.md T3 (all in jason-master-restart).
+
+## Changes from r1
+
+- B1. A user principal now comes only from the Console's verified OIDC session. The user CLI takes the
+  human proof's walk, which refuses agent markers and binaries, and its direct parent must be the
+  Console from the bus's own tree. This needs the path-bound human proof (P19 333). Residual risk in 3.6.
+- B2. 3.6 names the ownership changes: `#owner`, `#threadFor`, the `#human` gates and `thread.send`'s
+  sender fields. `message.send` is on no list, and `#threadFor` refuses users as a second wall.
+- B3. One level for 10-27, `collaborator`, with an exact verb list and a filter per read (3.5). Viewer and
+  every board read wait.
+- B4. Revocation has three triggers: the next user request, a 30 s broker timer, and a reload verb that
+  R5 calls. The launcher refuses to start a revoked thread, because the broker reports it on every
+  `threadsState`. It also SIGTERMs a running one (3.7). R4 now depends on R3 and R5.
+- B5. A separate uid per instance is a hard entry gate of R8, with checks (mos-0984 point 2).
+- N1 to N9 are handled where they apply: v1 count (2), `configDir` at business.mjs:25-28 (5), R1 takes
+  providers and peers as arguments (7), "human-only" (3.5), file checks (3.5), `instances` as the real limit
+  (3.5), provider removal needs a Console restart (3.7), Q1 is with Jason (9), client ids in R8 (7).
+- r3 (duckworth-0002): B6, the reply path to a user (3.6 item 7, runner header, R3 test and mutant, R7
+  asserts a reply). C1, the walk doesn't stop an unsandboxed same-uid agent (3.6). N10, `names` gates
+  through `#agent` (3.6 item 4). mos-0991: R8's gate accepts a separate host or a separate uid, and 3.8
+  checks the federation path for one-host assumptions. Q1 holds Jason's answer. morgana-0002 settles Q2.
+- r4 (duckworth-0003, mos-0996): B7, R8's gate now proves there is no privilege path from the factory to
+  the hub. Per mos-0996 (Vikunja #418) the hub runs on its own host, and for 10-27 the gate is the host form
+  only. The uid form (row 190b) is a later option. The checks run as the factory uid with a clean
+  environment and pass only when the call fails: `sudo -n`, `doas -n`, and `ssh -o BatchMode=yes` to the
+  hub host with and without the agent socket. Factory root on the PVE nodes defeats the host form
+  (duckworth-0004, mos-1004), so it is an open R8 gate item with options O1 to O3 for Jason (Vikunja
+  #419, section 8). N11, `#waiting` returns null for `to` `user` (3.6 item 7, R3).
+  N12, R3 assumes nothing about how shares end (section 9 Q2). Row 196 (#1694, Gander) owns the shared
+  principal verifier before R3 (section 5).
+- r4.11 (mos-1063): the hub's host is settled, so the "own host, not dragon-lin or Melanie's server"
+  lines and the #418 dependency are gone. The hub runs on .54, VM 1012, as user `mosaic` (Q181), and R8
+  depends on the Case 2 install on .54 (#416). #418 is closed. #419 carries only the wording for
+  Melanie. Mos ruled the four functional checks stay blocking.
+- r4.10 (mos-1055, DECISIONS Q182 and Q183): R8 is a recorded acceptance. It starts with Jason's
+  acceptance of the factory paths to .54 on record, quoted in section 8. Every privilege and host check
+  still runs, and its result goes into the R8 record with who ran it. They report and don't refuse.
+  Agents may run the .54 checks as localadmin, which replaces r4.9's line. The mos-1042 order is now in
+  the R8 row. The wording still reaches Melanie only through Jason (#419).
+  Two lines that said R8 proves the factory has no login on the hub (sections 3.5 and 3.6) now say
+  factory agents keep ssh to .54 under Q183, recorded as accepted.
+- r4.9 (mos-1037): R8 names who runs the root checks on 10.1.1.54.
+- r4.8 (duckworth-0020 N22): R8 checks the hub user's limits on 10.1.1.54 instead of taking #421's plan
+  as done.
+- r4.7 (mos-1030, DECISIONS Q181): the hosts are settled. Case 1 is W-jarvis, 10.1.1.53 (VM 1008), the
+  same host as the Hermes agents, so section 8 lists them as one factory host. The hub, Case 2, is
+  W-Melanie-OC, 10.1.1.54 (VM 1012). Its OS user is `mosaic`, a system user with no sudo, no groups
+  and no keys (ops-01's tightening plan section 3, Vikunja #421).
+- r4.6 (duckworth-0012 N21, morgana-0011): R6's notice is row 193's final user sentence, word for word
+  (row 193 design r5 section 5.7, morgana/row193 e2d161e2e). The start-order line now matches the
+  section 7 table: R2 waits on #412 phase 1, and R5 lands after R1.
+- r4.5 (duckworth-0010): B9, a user-thread run can't message the owner, but its decisions do reach the
+  owner's inbox, as Sage ruled for row 193 (sage-1368, morgana-0008)
+  and Mos kept (mos-1022). 3.6 item 7 says so, R6 tells
+  the user, and R3 tests both sides. N20, the start-order line waits for row 193's viewer level. R8
+  can't start while any host variable is unresolved.
+- r4.4 (mos-1020, mos-1019): N17, R4 is chained after row 193's viewer level and keeps the level-loss
+  test, which has to kill its mutant before R4 is done.
+- r4.3 (duckworth-0007): B8, an issuer that isn't on the hub host must pass the host-access, hypervisor
+  and backups rows against its own host, and a hosted issuer's admin accounts each pass the failed-call
+  check (section 8, sign-in row). N16, the dependency note covers every secret on a PVE guest. N17, R4's
+  level-loss test moves to row 193's viewer level. N18, 3.6 names `verifyPrincipal`. N19, the TLS check
+  runs through the public route and from the LAN.
+- r4.2 (mos-1013, morgana-0007): "factory" in R8 and section 8 means every principal outside the hub
+  instance, not only the dragon-lin uid: the dragon-lin dev uid, the Case 1 instance's VM and its agents,
+  and Jason's Hermes agents on W-jarvis. Every R8 check runs from each of their hosts. Hosts are variables
+  until Mos confirms them with Jason. The table rows don't change. Q1 is settled by Q180: P2P is
+  person-to-person. Row 193 calls `covers` with no level for share reads and with
+  `level: 'collaborator'` for create, open, send and share, so `covers` needs no other argument
+  (morgana-0007, row 193 DESIGN.md at 19c015741).
+- r4.1 (mos-1006, gander-0007, morgana-0005): R8's gate adds the identity provider path. A factory
+  credential that can administer the issuer the hub trusts gets in without the host (the B8 bullet below
+  has the rule). Mos accepted the sudo deviation (root ssh
+  and the `authorized_keys` check). Row 196's interface is settled: one verify per one-request
+  connection, `s.user` for that request only, and the walk mutants move to row 196. morgana-0005: grants
+  name bus project ids, and one pure `covers` in R1 matches a grant to a thread (3.5). R4's loss
+  predicate counts only collaborator grants, so a downgrade to viewer ends the run.
+- r4.1 (duckworth-0005): B8, the hub's issuer and TLS front end are in its trust base. The hub trusts
+  only an issuer no factory credential can administer, and TLS ends where the factory can't reach
+  (3.4, R8). A brand, tenant or application in the factory's Authentik doesn't count. N13, the key check
+  is a procedure. N14, R3 consumes row 196's verifier and depends on it. N15, DNS control. mos-1009:
+  section 8 has a table of every privilege path (hypervisor, backups, sign-in provider, TLS front end,
+  certificate authority, DNS, network), each closed by a check or accepted by Jason with set wording.
+- r2.1 (mos-0988): the separate uid is row 190b. R8's gate points at 190b, R7 at row 190 (one uid,
+  scratch). P19 333 is on the 10-27 path (section 8).
+- Mos's rulings in mos-0978 and mos-0984 replace the r1 questions (section 9). The push credential note is
+  in section 10.
+
+## 1. Summary
+
+By 10-27, federation means a person from one instance can sign in to the other instance's Console and use
+exactly what its owner granted: one business, some projects and its thread instance, at the collaborator
+level. The receiving instance verifies that person itself through OIDC (Q175) and its broker enforces the
+grant on every request. Revoking a grant refuses the next request and stops that user's thread runs within
+about 30 s, or at once when the grant CLI makes the change.
+
+Instance-to-instance traffic, where an agent on the factory talks to a role on the hub, waits until after
+10-27 unless Jason rules otherwise (mos-0984 point 3). Section 6 sketches it (Ed25519 instance keys and
+signed HTTP requests) so the 10-27 slice doesn't block it.
+
+## 2. What exists today (measured)
+
+- F1. The bus is a local Unix socket per data root: `socketPath` at packages/cli/src/config.mjs:19, opened
+  at packages/bus/src/runtime.mjs:169. Nothing listens on a network port. No live federation code exists.
+  The PRD lists REQ-FED-1 as post-v1 (packages/tasks/requirements.json:61).
+- F2. A business has exactly one human: `human` at packages/business/src/business.mjs:160.
+  `bindHuman` refuses any other name (packages/bus/src/broker.mjs:532-538).
+- F3. The human proof is a cooperative same-uid process check, not a wall. `verifyHuman` compares the
+  caller's uid, start time, nonce and CLI path (packages/bus/src/human.mjs:52-72), then walks the parents
+  and refuses agent markers, launch records and agent binaries (:73-88). The tester proof refuses only
+  managed runs and allows agents by design (packages/bus/src/tester.mjs:5-9, :56-60). The server takes
+  exactly one of `cap`, `human` or `tester` per request (packages/bus/src/server.mjs:52-70).
+- F4. Authority for agents is checked in the broker: `#checkAuthority` and `#authorityFor`
+  (broker.mjs:763-799), with classification at :596-609. Every one of these is about a role run. Humans
+  get no roles. `#human` (broker.mjs:375-378) is the only human check.
+- F5. Threads have a single `owner` column (packages/bus/schema.sql:247). `#thread` refuses a thread whose
+  owner isn't the caller (broker.mjs:356-362). `#owner` returns `tester` or the human (broker.mjs:364-366).
+  `#threadFor` special-cases the human (:326) and checks reply chains for the tester only (`#testerOwns`,
+  :352-355, called at :337 and :342). `#threadHolders(business, instance, owner)` finds the held runs of
+  one owner's threads (broker.mjs:298-306).
+- F6. The Console reaches the bus as the one human by spawning `human-cli.mjs` per call
+  (packages/webui/src/bus.mjs:1-9, 27-31). Its entry is `packages/webui/src/cli.mjs serve`
+  (scripts/webui-service.sh:3). Its sign-in today trusts a proxy header (Sage's design, section "What exists
+  today"). Q175 replaces that with an OIDC relying party that takes a `subjects` list from a `console.sso`
+  key in config.json (Sage's design sections 1 and 4).
+- F7. config.json is read by one loader that refuses unknown top-level keys
+  (scripts/mosaic-config.mjs:112-116). The business file is writable by agents through
+  `organizationWriter` (packages/business/src/organization.mjs:83), which is why Sage put SSO config in
+  config.json and not the business file.
+- F8. Bus, Discord and Console run as `systemctl --user` units (scripts/bus-service.sh:200), so every
+  instance on a host runs under Jason's uid today.
+- F9. Board reads are per business, not per project or instance: `inbox`, `agents`, `tasks`, `trail` at
+  broker.mjs:2143-2146, `decisions` :2174, `credentials` :2195, `messages` :2217 (the Console's set is
+  views.mjs:3-13). `project.list` returns every project in the business (:2318-2322).
+- F10. The launcher restarts a thread that has pending messages and no holder (packages/cli/src/launcher.mjs:533),
+  launched as the business human (:542), every 2 s (:133). Its `startedFor` guard is in memory. A claim end
+  stops a run only at its next bus call (broker.mjs:2273-2275). The idle stop is the one place that
+  SIGTERMs a thread runner (launcher.mjs:527).
+
+### The archived v1 federation (v1/apps/gateway/src/federation)
+
+What it does: mTLS between gateways with certificates from step-ca. The grant id and subject user id sit
+in custom certificate OIDs (ca.service.ts:22-24). A peer enrolls with a single-use, 15-minute bearer
+token. The guard reads the client certificate off the TLS socket (server/federation-auth.guard.ts:93-106)
+and re-checks the grant row on every request. Scopes are zod-validated resource lists
+(scope-schema.ts:15-99). Shared data is read-only list and get queries.
+
+Verdict: none of the code is reusable here.
+
+1. It is about 4,470 lines of NestJS, Drizzle and Postgres code without tests (9,198 with them), plus a
+   step-ca dependency. The new stack has none of those.
+2. Inbound federation never worked. The guard depends on `requestCert: true`, but the server is built as
+   `new FastifyAdapter({ bodyLimit })` with no TLS options (v1/apps/gateway/src/main.ts:50-53). Every
+   inbound call would get 401.
+3. mTLS is the wrong fit for the homelab path. Traefik terminates TLS in front of the Console (Sage's
+   design, public path). A client certificate would reach the app as a forwarded header, which is the
+   header trust Q175 point 1 rules out.
+
+Ideas worth keeping: re-check the grant on every request, never cache it in the credential. Keep
+enrollment short-lived and single-use. Tag every federated result with its source instance.
+
+## 3. The 10-27 slice
+
+### 3.1 What it must do
+
+1. D1. Each instance names itself and its peers in config.json, so the Console can show "you are on the
+   hub" and link to the factory. Peer entries carry no trust in the 10-27 slice. They are labels and URLs.
+2. D2. The owner of an instance grants a person access to one business, with a project list and an
+   instance list. Grants live in a human-authored access file on the receiving instance.
+3. D3. That person signs in to the receiving instance's Console with OIDC. The Console verifies the token
+   itself (Q175) and matches `(provider, sub)` to an access-file user with a live grant.
+4. D4. The broker, not the Console, enforces the grant on every request: which verbs, which projects,
+   which instances, and which threads (own threads only).
+5. D5. Revoking a grant refuses that user's next request on the Console and on the bus, and ends the runs
+   of that user's threads in that business.
+
+### 3.2 What waits
+
+- W1. Agent-to-agent traffic between instances (section 6).
+- W2. Shared threads between several users (C1.4), and a viewer level. Both are T1.3's. A granted user gets
+  private threads only.
+- W3. Remote owners. A grant never gives owner verbs: organization, instances, routes, plugins, limits,
+  decision resolution, launch revoke and the kill switch stay with the local human.
+- W4. A registry, `mosaic comms`, enrollment tokens and key rotation tooling. With two instances,
+  out-of-band setup by Jason is cheaper.
+- W5. Federated reads that merge results from both instances into one view, and any board read for a
+  granted user (F9).
+
+### 3.3 Instance identity in the slice
+
+An instance is its public HTTPS origin plus its own OIDC client at the provider. The factory and the hub
+are two clients, so their ID tokens carry different `aud` values. The Q175 audience check refuses a
+factory token presented at the hub, which makes tokens instance-bound by signature, not by a header. This
+holds only if the two client ids differ, which R8 checks. No instance key is needed until instances talk
+to each other (W1).
+
+### 3.4 Remote user identity
+
+A user is `(provider, sub)` where `provider` is an id from that instance's `console.sso.providers`. Q175
+already verifies signature, issuer, audience, expiry and nonce, and allows several providers. The hub
+trusts only an issuer that no factory credential can administer (B8, duckworth-0005), for example a
+Pocket ID on the hub's side. Jason then has his own account at that issuer, with a `sub` of its own. A
+separate brand, tenant or application in the factory's Authentik doesn't count: factory agents hold an
+Authentik API token, and whoever administers the issuer can impersonate any user, reset a login or
+repoint a redirect. If Jason wants the hub on the factory's Authentik anyway, that is his decision, of
+the same kind as #419 (section 8). Either way the receiving instance checks the token. It never takes the
+home instance's word for who the user is.
+
+The owner path stays as Sage designed it: `console.sso` subjects sign in as the business human. Everyone
+else comes from the access file. The two lists are disjoint, and the loader refuses a subject in both.
+
+### 3.5 The access file and the collaborator level
+
+`<configDir>/access.json`, next to config.json, so it is per instance (`configDir` at business.mjs:25-28
+reads `MOSAIC_CONFIG`). It is not in config.json for two reasons. Revocation has to take effect without a
+restart, and a typo in config.json stops every tool on the instance (Sage's design, section 4). It is not
+in the business file because agents can write that (F7).
+
+```json
+{
+  "accessVersion": 1,
+  "revision": 3,
+  "users": [
+    { "id": "jason", "home": "factory", "subjects": [{ "provider": "authentik", "sub": "<sub>" }] }
+  ],
+  "grants": [
+    {
+      "id": "g-hub-1",
+      "user": "jason",
+      "business": "creative-hub",
+      "projects": ["*"],
+      "instances": ["researcher"],
+      "level": "collaborator",
+      "expires": "2026-12-31T00:00:00Z"
+    }
+  ]
+}
+```
+
+Rules the loader enforces, refusing the whole file on any failure (fail closed). The loader takes the
+provider ids, peer ids and declared businesses as arguments, so it stays pure:
+
+- The file is a regular file, not a symlink, owned by the instance's uid, with no group or other write.
+  These are the checks Sage's loader runs on the secret slot.
+- Unknown keys refuse. `accessVersion` is 1. `revision` is a positive integer.
+- A user id matches the business id rule and is never `human`, `tester`, or any business's `human`.
+- `subjects[].provider` names a given provider. A `(provider, sub)` pair appears once in the file and
+  never in `console.sso.subjects`.
+- `home` names a given peer, or is `local` for a non-federated extra user.
+- A grant names a declared business. `projects` is `["*"]` or bus project ids, the UUIDs
+  `project.create` makes (broker.mjs:2306). `instances` is
+  `["*"]` or declared instances. `level` is `collaborator`, the only level in 10-27. `expires` is optional
+  ISO time.
+- The loader checks a project entry's shape only (a UUID). It can't see the bus, so an id with no bus
+  project covers nothing.
+- A grant past `expires` is treated as absent.
+- A file that fails any rule leaves every user with no grant, which revokes everything. That is the safe
+  direction.
+
+Matching a grant to a thread (morgana-0005). A thread's `project` is a bus project id
+(`threads.project REFERENCES projects(id)`, packages/bus/schema.sql:245), set by `thread.create`
+(broker.mjs:2329-2345). A bus project may have no repo in the business file, so grants can't name
+business-file projects. They name bus project ids, not names. A name could be taken later: the tester,
+which runs from an agent, can call `project.create` (:2300), and nothing renames or deletes a project
+today. R1 exports one pure function, `covers(grant, { business, project, instance }, now, { level })`.
+It is true when the grant is unexpired, the business matches, `projects` is `["*"]` or holds the
+project id, `instances` is `["*"]` or holds the instance, and the grant's level is the one asked for,
+when one is asked for. The broker passes the thread row. `["*"]` also covers projects made after the
+grant, and the R5 help text says so. R5's `grant --project <name>` resolves the name to the id through
+`project.list` at grant time and writes the id. `mosaic access list` shows both. Row 193 uses the same
+`covers`.
+
+The collaborator level is an exact verb list. Every other verb fails `access-refused` before the verb's own
+checks. That covers all owner verbs (W3), every board read (F9), `message.*`, `decision.*`, project files,
+`spec.read`, `assistant.stop`, `launch.*`, `name.set` and `usage.*`.
+
+| Verb | Today | For a user |
+|---|---|---|
+| `project.list` | every project in the business (:2318-2322) | granted projects only |
+| `thread.create` | the business's one thread instance (:2331-2334) | project granted, and that instance in the grant's `instances`, else `access-refused` |
+| `thread.list` | owner filter (:2351-2362) | owner `user:<id>`, and only threads whose project and instance are still granted |
+| `thread.open` | `#thread` owner check (:2365-2371) | same, plus the thread's project and instance still granted |
+| `thread.send` | `#thread`, sender `human`, writes `human.input` (:2374-2398) | same grant check. Sender `from_role` `user`, `from_run` `user:<id>`, no `human.input` |
+| `thread.messages` | `#thread` (:2401-2420) | same grant check |
+| `names` | business-wide (:2288-2295) | granted instances only |
+
+`human.input` events are the owner's authority evidence (the `input` view, broker.mjs:1203-1207). A user's
+message must never write one, the same rule the tester follows at :2398.
+
+`instances` is the real limit of a grant. The thread instance runs with its full role authority and is
+launched as the business human (F10), so a collaborator's message drives that instance with the owner's
+role. A grant gives a user exactly what the granted instance can do. The grant docs and the R5 help text
+say so.
+
+Writes go through `mosaic access grant` and `revoke` (row R5), atomically with a revision bump and one
+receipt line in `<dataRoot>/state/access-log.jsonl` (append-only, as `activation-log.jsonl` is). The
+CLI checks its caller with the human proof, but a direct file write by the instance's uid skips both the
+CLI and the receipt. The separate host keeps other instances' processes from making that write, but
+factory agents keep ssh to .54 (Q183), so one with a login there can make it. R8 records that as
+accepted (section 8). Jason may also edit the file by hand.
+
+### 3.6 The user principal in the broker
+
+The bar (B1, mos-0984 point 1): a bus user principal comes only from something the bus can verify. Here
+that is the Console's verified OIDC session, reached through a proof the bus checks itself. The calling
+process's claim alone isn't enough, and neither is a proof that admits agent ancestry.
+
+The proof. Row 196 (#1694, Gander) builds this check as the `user` kind of its shared `verifyPrincipal`,
+and R3 consumes it (section 5). The checks are the ones below. A new path-bound CLI, `packages/bus/src/user-cli.mjs`, with its own nonce variable
+(`MOSAIC_BUS_USER_NONCE`), so neither of the other CLIs' nonces proves it. The bus checks it with
+the `user` kind of row 196's `verifyPrincipal`, which:
+
+1. Runs `verifyHuman`'s checks with `cliPath` set to the bus's own `user-cli.mjs`: same uid as the bus,
+   start time, nonce, CLI path, and the parent walk that refuses agent markers, launch records and agent
+   binaries (human.mjs:64-96).
+2. Also requires the user CLI's direct parent to be the Console from the bus's own tree: `argv[1]` equals
+   the bus's resolved `packages/webui/src/cli.mjs`, and `argv[2]` is `serve`. This binds the user CLI to
+   the Console's tree, as #225 binds `human-cli` to its literal path.
+3. Takes `user` from the proof and binds it only if the access file gives that user a live grant in the
+   proof's business. Otherwise `access-revoked`.
+
+So the claim "I am user jason" comes from a process the bus has verified as its own Console, outside any
+agent. The Console makes that claim only after Q175 verified the ID token's signature, issuer, audience,
+expiry and nonce and mapped `(provider, sub)` to the user.
+
+This needs the path-bound human proof, P19 333. Residual risk, stated as Sage's design section 8 states it
+for the owner. The proof is a cooperative same-uid check. A non-agent process on the instance's uid, a
+shell Jason opens for example, can start its own copy of the Console's tree from the bus's path and claim
+any granted user. So can anything that can ptrace or write files as that uid. The walk refuses an agent
+in its normal process tree, but an unsandboxed agent on the same uid can get past it by starting the
+Console through `systemd-run --user` or by daemonizing so its parent chain ends at pid 1. That is the same
+hole the owner proof has (P19 333), not a new one. Other instances can't: the 10-27 hub runs on its own host, so its bus
+isn't on their host at all. Factory agents keep ssh to .54 and root on pve (Q183), so the host form doesn't stop them, and R8 records that as accepted (section 8). Federation adds no weaker path than the owner's.
+
+The broker changes, each with an R3 test:
+
+1. `bindUser({ business, user })` makes a session with `s.user` set and `s.human` and `s.tester` unset.
+2. `#owner(s)` (:364-366) returns `user:<id>` for a user session. Today it would return undefined.
+3. `#threadFor` (:318-345) refuses a user session with `thread-required-use-thread-send`, as it refuses
+   the human at :326. `message.send` is also off the verb list. Two walls, so a reply-chain send into
+   another user's thread fails even if one is removed (R3 mutant).
+4. The `if (!s.tester) this.#human(s)` gates on the six project and thread verbs above become a check
+   that admits the human, the tester, or a user with a live grant. `names` gates differently, with
+   `if (!s.human && !s.tester) this.#agent(s)` (:2290), so there the user branch goes before the `#agent`
+   fall-through, or a user session fails `#agent`.
+5. Every other `s.human` and `s.tester` branch (48 and 41 in broker.mjs) gets an audit line in R3's
+   packet: user refused, user treated as human, or not reachable for a user. Since every non-list verb
+   fails first, most are "not reachable", and the audit shows it.
+6. `refuse()` records `action.refused` for every refusal (broker.mjs:526-530), with `by` = `user:<id>`.
+7. The reply path (B6). The runner answers each message with `message.send { to: m.from_role }`
+   (packages/harness/src/runner.mjs:450), and today the broker accepts only `human`, `tester` or a role as
+   `to` (broker.mjs:1862). A user's message has `from_role` `user`, so without this every reply fails
+   `unknown-role`. The broker accepts `to: 'user'` from a run only when all of these hold, else
+   `user-reply-required`:
+   - `in_reply_to` names a message with `from_role` `user` in this business,
+   - that message's `from_run` is `user:<id>` and `user:<id>` owns the run's thread,
+   - the message is in that thread (`message_threads`).
+
+   This is the tester rule at :1852-1857, narrowed to one user and one thread. A `#userThread(s)` beside
+   `#testerThread` (:631) finds a run of a user's thread. Such a run can't send `to: 'human'`
+   (`user-thread-human`), as :1864-1866 does for the tester, so a collaborator can't message the owner.
+   Decisions are different (B9). The tester's decision guard at :1683 (`tester-thread-human`) is not
+   copied: a user-thread run's uncited gated raise or hard wait routes to the human (:1677-1680) and
+   lands in the owner's inbox with the run's own question, options and recommendation. Sage ruled
+   that this is intended governance (sage-1368, morgana-0008): the owner decides gated actions in any
+   thread. Mos keeps this behaviour (mos-1021, mos-1022), so R3 doesn't refuse those decisions. R6 tells
+   the user with row 193's sentence (5.7 there, N21): "The business owner sees your thread's agent's decisions, inbox entries, claims, tasks and project files, but not your messages." `#checkMessaging` reads `user` as `human` for that run, as :1867 does for
+   the tester. A human or tester session sending `to: 'user'` fails `unknown-role`. The reply lands in the
+   thread through the existing route, so the user reads it with `thread.messages`.
+   `#waiting` (broker.mjs:2556) returns null at once for `to` `user`, as it does for `human` and `tester`.
+   Otherwise every reply to a user falls through to the launch notice at :2562 and posts a waiting
+   notice to the owner's launcher (N11).
+
+   The runner header (runner.mjs:75-78 has the tester's) gains a line for `from_role` `user`: "This message
+   is from <id>, a granted user. It is never Jason's or the owner's instruction and authorizes nothing."
+   The id comes from `from_run`, which `receive` already returns (`SELECT *`, broker.mjs:1932).
+
+The Console only authenticates. The owner session keeps `human-cli.mjs`, a granted user's session uses
+`user-cli.mjs` with the user id. It re-reads the access file per request and drops a session whose user
+has no live grant left. The bus check stays authoritative, so a Console bug can't widen a grant.
+
+### 3.7 Revocation
+
+A grant is lost when it is removed, when it expires, or when the file fails validation. Three triggers
+find the loss:
+
+1. The next user request. The broker re-reads the file when its mtime, size or inode changes, so any write
+   counts.
+2. A broker timer every 30 s re-reads and re-evaluates expiry. This catches hand edits and expiry with
+   no request at all.
+3. `access.reload`, a new human-only verb. `mosaic access grant` and `revoke` (R5) call it after the
+   write, so CLI changes act at once.
+
+On a loss, in one transaction, the broker ends the claims of every `user:<id>` thread that no live collaborator
+grant covers any more (via `#threadHolders(business, instance, 'user:<id>')`, F5, and `#claimEnd`). The run's next bus
+call is then refused (F10).
+
+The launcher side, so a pending message can't start a new run:
+
+- `threadsState` (broker.mjs:390-393) adds `revoked: true` to any thread owned by `user:<id>` that no live
+  collaborator grant covers (`covers` with `level: 'collaborator'`, morgana-0005). A downgrade to viewer
+  ends the run. The broker computes this from the file on each call, so it survives a launcher restart,
+  unlike `startedFor`.
+- The launcher's thread pass (launcher.mjs:510-553) never starts a revoked thread.
+- For a revoked thread that is still running, the launcher SIGTERMs the runner at once, as the idle stop
+  does at :527, but without waiting for `threadIdle`'s release, since the claim is already ended. The
+  launch check also refuses a revoked thread, which covers a start racing the revocation.
+
+Bound: the bus refuses the user and the run from the next request on. The runner gets SIGTERM within one
+launcher tick (2 s, launcher.mjs:133) of the broker seeing the loss. A model turn already in flight ends
+when its runner exits. Its last bus call is refused, so it can't deliver a reply into the thread.
+
+Removing a provider from `console.sso` is different. config.json is read at start, so that takes effect
+only after a Console restart. Removing the users from access.json acts at once, so the R5 help text says to
+do that first.
+
+### 3.8 One host or two (mos-0991)
+
+For 10-27 the hub runs on .54, VM 1012, as user `mosaic` (Q181), a host of its own (mos-0996).
+Jason (mos-1013): dragon-lin is his workstation and won't host the final instances, and both cases run
+as VMs on the PVE node. Jason confirmed the hosts (DECISIONS Q181, mos-1030). The Case 1 instance is on W-jarvis,
+10.1.1.53 (VM 1008), and the hub, Case 2, is W-Melanie-OC, 10.1.1.54 (VM 1012). The hub's OS user is
+`mosaic`, a system user with no sudo, no groups and no keys (Vikunja #421).
+It is a PVE VM, and Jason accepted the factory's paths to it (Q182, Q183, section 8). The federation path
+assumes nothing about sharing a host:
+
+- Nothing crosses between the instances' buses or filesystems. Each Console talks only to its own bus
+  through `user-cli` or `human-cli`, spawned on its own host. access.json lives in the receiving
+  instance's config dir. `federation.peers` holds URLs and labels, never a path or a socket. No row reads
+  a peer's file or socket.
+- In the 10-27 slice the two Consoles never call each other. The user's browser reaches each origin, and a
+  peer link is a plain link. Section 6 does need each Console's origin reachable from the other host, so
+  R8 checks that now and the later rows add no infra.
+- Each instance has its own OIDC client with its own redirect URI on its own origin (3.3). Each Console
+  must reach its provider's issuer and JWKS from its own host. The issuer is a privilege path too. Whoever administers it can mint a hub user, so
+  the hub's issuer is one the factory can't administer (3.4, R8). The factory's Console reaches its own
+  Authentik, and the hub's reaches its own issuer.
+- Q175 checks token expiry, and section 6 has a 60 s window on signed requests, so both hosts need a synced
+  clock.
+
+The only one-host piece is R7, which is scratch on one host by design (row 190). The uid form of R8's gate
+(row 190b) is a later option, outside the 10-27 gate.
+
+## 4. Fit with the current code
+
+- The bus stays a local socket. Federation reaches it only through the receiving instance's Console, which
+  is the one network-facing piece. No row opens a bus port.
+- The broker's agent authority path (broker.mjs:763-799) is untouched. User checks are a separate path,
+  next to `#human`, because humans have no role claim and `#agent` would refuse them (broker.mjs:367-374).
+- New ownership code is small but real: `#owner`, `#threadFor`, the seven verb gates, `thread.send`'s
+  sender fields and `threadsState` (3.6, 3.7).
+- The business file keeps one `human`. Granted users sit outside it, which keeps every existing
+  business-file test and the organization writer unchanged.
+- The config loader gains one optional key, `federation`, in the same file Sage's phase 1 changes
+  (mosaic-config.mjs:112-116). Row R2 chains on that candidate and repeats its blast-radius rule: the key
+  goes in only after a copy that accepts it is pinned.
+
+```json
+"federation": {
+  "self": "hub",
+  "peers": [{ "id": "factory", "origin": "https://mosaic.woltje.com", "label": "Software factory" }]
+}
+```
+
+## 5. Dependencies on T1
+
+- T1.1, several instances per host (mos-0988). Row 190 (Darkwing) lands several instances on one uid,
+  for scratch tests. R7 runs on that. Row 190b (Darkwing, Opus, design first, chained on 190) puts the hub
+  under its own Linux user, with no factory process able to touch it (mos-0986). Rows R1 to R7 don't need
+  190b: they use separate `MOSAIC_CONFIG` files and data roots, which the code already honours
+  (business.mjs:25-28). For 10-27, R8's gate is the host form only (mos-0996), so 190b is a later
+  option, not an R8 dependency. With per-uid instances,
+  a factory-uid process can't read or write the hub's access.json or data root, and it can't pass the
+  hub's human or user proof, because `verifyHuman` requires the caller's uid to equal the bus's
+  (human.mjs:67). Inside one instance the proofs stay same-uid cooperative (3.6, P19 333).
+  The design doesn't plan a single-uid live run.
+- A separate host (mos-0991, mos-0996). The hub runs on its own host, which R8 checks and records (section 7,
+  3.8). It is a PVE VM, with the factory paths accepted by Jason (Q182, Q183, section 8).
+  mos-0996 measured why the other hosts fail: on dragon-lin `sudo -n true` succeeds for jwoltje, and
+  Melanie's server takes `ssh -o BatchMode=yes` from here with passwordless sudo behind it.
+- Row 196 (#1694, Gander) owns the bus human boundary before R3 (gander-0006): one shared verifier,
+  `verifyPrincipal(request, connection)` returning `{kind, business, id}`, with `SO_PEERCRED` binding
+  `proof.pid` to the connection. R3 consumes it for the `user` kind instead of writing its own
+  `verifyUser`, with the same checks as 3.6 (human walk, direct parent the bus tree's Console `serve`,
+  own nonce variable). It runs once for each one-request connection, and `s.user` holds for that
+  request only, with no role or grant cached (gander-0007). R3 owns every live grant check, the
+  `(provider, sub)` to user mapping and the user-name policy. Row 196 kills the agent-parent,
+  non-Console-parent and kind-confusion mutants. R3 keeps the reserved user-name mutant.
+- T1.1 live also needs two Consoles, two public origins, two reverse-proxy routes and two provider
+  clients, which are Jason-gated infra.
+- T1.2, #412 SSO. Hard dependency. Row R6 builds on Sage's phase 1 candidate (Q177 merge-chaining) and
+  goes live only after the phase 2 window.
+- T1.3, human users and RBAC. One user and grant model for local and federated humans (mos-0978 Q2).
+  Row 193 (Morgana) confirmed access.json as that store (morgana-0002, section 9 Q2). T1.3 adds `local`
+  users, the viewer level and `thread_shares`, and federation adds `home`. R1 is the shared loader, so row
+  193 builds on R1's candidate.
+
+## 6. After 10-27: instance-to-instance
+
+Sketch only, so the slice doesn't block it. If Jason puts agent-to-agent inside 10-27 (mos-0984 point 3),
+rows for it are added after r2.
+
+- Each instance gets an Ed25519 key in a secrets slot (`~/.config/mosaic-dev/secrets/<instance>/`, 0600,
+  per the Q173 slot rule). Peers pin each other's public keys in `federation.peers[].keys`. Public keys are
+  not secrets.
+- Requests between instances are signed with HTTP Message Signatures (RFC 9421) over method, target URI,
+  authority, content digest, created time and a nonce. The receiving Console verifies the signature
+  itself, so the proof survives Traefik. A created time outside 60 s or a reused nonce refuses. No shared
+  secret, no bearer token.
+- A peer agent becomes a grant subject of kind `peer` (`factory/researcher`), in the same access file, so
+  grant and revoke work the same way. Removing a peer key refuses all of that peer's traffic at once.
+- First use: a factory agent sends a message into a hub thread it was granted, owned by `peer:factory`.
+
+## 7. Rows
+
+Owner model per Q177 and Q178. Opus 5.5 for hard design and builds, Haiku 5.5 at high effort for mid work,
+Codex gpt-6.1-sol for parallel builds. Every row has its own independent review (Filbert or Dewey) and
+gate. Chains follow Q177: a dependent row builds on its parent's candidate.
+
+| Row | Work | Owner model | Depends on | Test gate |
+|---|---|---|---|---|
+| R1 | `packages/business/src/access.mjs`: access.json loader and validator. Providers, peers and businesses come in as arguments. One read plus the file checks | Codex Sol | none | business tests: every rule in 3.5 refuses with the key path named, symlink, non-regular file, other owner, group or other write, expiry, `*`, disjoint from the given subjects, `human`/`tester` ids, a level other than `collaborator`, a project entry that isn't a UUID. `covers`: `*` and listed ids match, an unlisted project, instance or business doesn't, an expired grant doesn't, a level filter rejects another level |
+| R2 | `federation` key in scripts/mosaic-config.mjs | Haiku 5.5 high | Sage #412 phase 1 candidate | test-config.sh: valid key loads, unknown sub-key and bad origin refuse, config without it loads |
+| R5 | `mosaic access list, grant, revoke`: human proof, atomic write, revision bump, receipt line. Help text states the `instances` limit and the provider-removal order | Haiku 5.5 high | R1 | cli tests: tester and agent callers refused, concurrent write refuses on revision conflict, receipt appended, bad grant refused before write |
+| R3 | Broker user principal: consumes row 196's `verifyPrincipal` (`user` kind, `user-cli.mjs`), `bindUser`, the 3.6 changes, the collaborator verb list and its filters, per-request grant read, audit lines for every `s.human`/`s.tester` branch | Opus 5.5 | R1, row 196 | bus tests: each listed verb allowed, every other verb refused, a leak test per listed read (other projects, other instances, other users' threads), a reply-chain `message.send` into another user's thread refused, `thread.send` writes no `human.input`, the run's reply to a user's message reaches that user's `thread.messages`, a reply `to: 'user'` without a matching `in_reply_to` refused, a user-thread run sending `to: 'human'` refused, a reply to a user returns `waiting` null and posts no notice message, a user-thread run's uncited gated raise reaches the owner's inbox and no other inbox or role, while its `message.send` `to: 'human'` is still refused (B9, mos-1022), revoked and expired grant refused on next request, refusals recorded. Mutants (the agent-parent, non-Console-parent and kind-confusion mutants are row 196's): the grant read skipped, a read filter dropped, `#threadFor`'s user refusal removed, the reply-to check dropped (a run answers another user's message or one outside its thread), a user named like the human accepted |
+| R4 | Revocation: 30 s timer, `access.reload` verb, claim end on loss, `threadsState` `revoked`, launcher skip and SIGTERM, launch check refusal, R5 calls `access.reload` | Codex Sol | R3, R5, row 193's viewer level (mos-1019) | bus and launcher tests, each with a mutant: a hand edit removing the grant ends the run within one timer period, an expiry with no request ends it, a pending message followed by a launcher restart starts no run, a running revoked thread gets SIGTERM, a grant downgraded to viewer counts as a loss, another user's runs stay. R4 starts after row 193's viewer level lands, because before it R1 refuses any other level, the whole file fails, and the downgrade test can't kill its mutant (N17, mos-1020) |
+| R6 | Console: granted-user sign-in, `user-cli` transport per session, per-request grant re-read, owner-only controls hidden, a notice on the user's thread page with row 193's sentence word for word (B9, N21): "The business owner sees your thread's agent's decisions, inbox entries, claims, tasks and project files, but not your messages.", peer links | Opus 5.5 | Sage #412 phase 1, R1, R2, R3 | webui tests on Sage's fake OP: granted user signs in, ungranted `sub` refused, revoked mid-session gets 401 on next call, a granted user's owner-verb call refused by the bus even with the UI check removed (mutant), the thread page's notice equals row 193's sentence exactly (N21) |
+| R7 | Scratch two-instance acceptance: two configs, two data roots, two Consoles, one fake OP. The Consoles start outside agent ancestry (a transient user unit), as the user proof requires. They never use the live stack's units or ports | Haiku 5.5 high | R1-R6, row 190 (several instances on one uid) | script test: Jason granted collaborator on one hub project signs in to the hub, makes a thread, sends to the granted instance, gets the instance's reply in the thread, is refused on another project and on board reads, is revoked and gets refused with the run ended. The factory shows nothing of the hub |
+| R8 | Live window, not a code row: hub provider client, hub proxy route, access.json written by Jason, re-pins | Jason, Mos | the Case 2 install on .54 (#416), Bean and Chet live and both Hermes gateways on .54 stopped (mos-1042), #412 phase 2, R7 | Host form only for 10-27 (mos-0996): the hub runs on .54, VM 1012, as user `mosaic` (Q181). R8 is a recorded acceptance (mos-1055). It starts with Jason's acceptance of the factory paths to .54 on record, DECISIONS Q182 and Q183, quoted in section 8. Every privilege and host check below still runs, and its result goes into the R8 record with the name of whoever ran it. They report and don't refuse. R8 runs after Bean and Chet are live and both Hermes gateways on .54 have stopped (mos-1042). Case 2 go-live doesn't wait on R8. The hub is W-Melanie-OC, 10.1.1.54 (VM 1012), and its OS user is `mosaic`, with no sudo, no groups and no keys (Q181, Q183). R8 checks that on 10.1.1.54 as root and records whether each holds: `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 it (N22). An agent or Jason runs these as localadmin (mos-1055), and the output goes into the R8 record with who ran them. The privilege checks run on every factory host in section 8's list (the dragon-lin dev uid, and W-jarvis at 10.1.1.53, which is the Case 1 VM with its agents and the Hermes agents), as each factory uid there under `env -i`, and each is recorded as passing only when the call fails: `sudo -n true`, `doas -n true`, and `ssh -o BatchMode=yes 10.1.1.54 true` as the hub user `mosaic`, as Jason's user and as root, each with and without the session's `SSH_AUTH_SOCK`. If `sudo -n` succeeds, as it does for jwoltje on dragon-lin (mos-0996 point 1), the factory counts as root on its own host. Then, as root through `sudo -n`: fingerprint every private key under every home and `/root`, and every key loaded in any agent socket found on the host (`ssh-add -l` per socket). Compare them with `ssh-keygen -lf` over every `authorized_keys` on the hub host, root's included, and no fingerprint matches. Run the ssh checks as root, once with no agent socket and once with each socket found, and record each result (N13). Every other privilege path is a named item in section 8's table (mos-1009): hypervisor, backups, sign-in provider, TLS front end, certificate authority, DNS and network. The record marks each one closed, with its check passing, or accepted under Q182 and Q183 with the table's wording. That wording goes to Melanie through Jason (#419), never to her directly. R8 also records whether the hub host's bus socket, data root and config dir don't exist on any factory host, no factory host mounts anything of the hub's, and whether the hub host runs no other instance or agent. These must work, or R8 stops and Mos takes it to Jason, because federation fails without them: the two provider client ids differ, each origin answers over HTTPS from the other host, each Console reaches its issuer's discovery URL, and both clocks are synced. The record holds Jason's acceptance and the check results side by side, so a passing check is a measured fact and an accepted path is named as accepted. The uid form (row 190b) is a later option, outside this gate. Then Jason signs in to the hub from his account and sends one message, Melanie revokes, and his next request is refused |
+
+R1 can start now. R5 can be briefed now against R1's exported interface and lands after R1. R2 starts
+when Sage's #412 phase 1 candidate exists. R3 starts when R1 has a candidate, R4 when R3, R5 and row 193's viewer level do (mos-1019).
+R6 waits on Sage's phase 1 candidate.
+
+## 8. Risk to 10-27
+
+The slice lands only if three things hold. #412 phase 1 has a reviewed candidate by about 10-23. P19 333,
+the path-bound human proof R3 depends on, is settled in time for R3 (Mos told Sage, mos-0988). The Case 2
+install on .54 (#416) is done in time for R8. Jason's answer on the factory paths is Q182 and Q183. R6 and R7 chain on #412 phase 1. R8 needs all three, plus
+two Jason-gated windows (#412 phase 2 and the federation re-pin), plus infra work only Jason does: a
+second public origin, a proxy route and a provider client. A failed privilege check
+doesn't stop R8. It goes into the record, and Mos takes it to Jason.
+
+The hypervisor path (Vikunja #419, mos-1004), accepted by Jason under Q182 and Q183. Factory agents hold root
+ssh to the PVE nodes (Q172). Root on a node can read a running VM's memory and disk, open its console,
+and change its config or boot. So it defeats the host form completely when the hub is a cluster VM
+(duckworth-0004). LUKS inside the VM doesn't close it alone: the key sits in the running VM's memory,
+which the node can read, and a node that can change the boot can capture the passphrase. Options:
+
+- O1. The hub runs on hardware outside the PVE cluster, where the factory has no root.
+- O2. A cluster VM, with factory root ssh removed on every node, no factory PVE token with console,
+  monitor, config, backup or snapshot rights on the VM, VM storage the factory can't read, and PBS
+  backups the factory can't read or that are encrypted with a key it doesn't hold.
+- O3. Jason accepts it as a residual. Then this section and R8 say plainly that the host form doesn't
+  stop a factory agent using PVE root, and Melanie is told.
+
+Jason's answer is O3, accepted (DECISIONS Q183 confirms Q4). His lines, verbatim:
+
+Q182 (DECISIONS.md:1514-1519, jason-master-restart):
+
+> "I am not pursuing a tightening of key and agent security on my workstation. I need my agents to be able to get onto the other workstations and servers."
+
+> "We will eventually have my agents running on my VM on PVE, but currently I accept the risk of agents running on my workstation."
+
+Q183 (DECISIONS.md:1535-1541):
+
+> "Security tightening on .53 and .54 is fine. 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."
+
+> "Q4 appears to properly reflect my statements."
+
+Q4, as Mos asked it and Jason confirmed it:
+
+> "The #421 plan stops. Your key stays, and agents keep root on pve and PBS and ssh to .53 and .54. Each VM still gets a mosaic user without sudo to run its instance. The federation gate records your acceptance instead of refusing to start."
+
+So this section and R8 say it plainly: the host form doesn't stop a factory agent using PVE root, and
+R8 records that as accepted. Melanie is told through Jason (#419).
+
+### R8 privilege paths (mos-1009, duckworth-0005, Vikunja #419)
+
+Here and in R8, "factory" means every principal outside the hub instance (mos-1013), and "factory
+host" means each of their hosts:
+
+- the dragon-lin dev uid, on Jason's workstation
+- W-jarvis, 10.1.1.53 (VM 1008): the Case 1 instance's VM and its agents, and Jason's Hermes agents.
+  ops-01 reports the `jarvis@w-jarvis` key has root on `pve`.
+
+Case 1 and the Hermes agents share W-jarvis, so they are one factory host (Q181, mos-1030). The hub is
+W-Melanie-OC, 10.1.1.54 (VM 1012). Every check in the
+table runs on each factory host, and a path is closed only when it passes on all of them.
+
+ops-01 measured the estate read-only at 19:10Z (relayed in mos-1009). There is one PVE node, `pve`,
+standalone, and its root `authorized_keys` holds the factory's key (dragon-lin's, and per mos-1013
+the `jarvis@w-jarvis` key), so the factory has root on the
+hypervisor without any API token. The only PBS is VM 1021 on that node, the factory has root on it, and
+its backups are unencrypted. The LAN is flat (10.1.0.0/16) with dragon-lin on it and no internal VLAN.
+The factory has used the jarvis Authentik token for admin changes. No hardware outside PVE without
+factory root has been confirmed. So today the factory administers every path below.
+
+Each path is a record item. Its check runs and the result is recorded. A path is closed when its check
+passes. Otherwise it is accepted under Q182 and Q183, and its wording goes into the R8 record and to
+Melanie through Jason (#419). Every check runs from the factory
+host, as root through `sudo -n` where the factory has it, and passes only when the call fails.
+
+| Path | Closed: the check | Accepted: the wording | Hub-local option |
+|---|---|---|---|
+| Host access | The R8 sudo, doas, ssh and key checks (section 7, N13) | "Factory agents can log in to the hub host." | none needed, the checks can pass today |
+| Hypervisor | O1 or O2 above: no factory key in any PVE node's root `authorized_keys`, and a PVE API call on the hub VM fails with each token the factory holds | "Factory agents have root on the machine the hub runs on and can read its memory and disk." | O1, hardware outside PVE |
+| Backups | The hub's backups are encrypted with a key only Jason or Melanie holds: the PBS datastore shows the hub's snapshots encrypted, and the key's fingerprint matches no file on the factory host | "Factory agents can read the hub's backups in full." | client-side encrypted backups, key held by Jason or Melanie |
+| Sign-in provider (B8, mos-1006) | The hub's `console.sso` trusts only an issuer no factory credential administers, never a brand, tenant or application in the factory's Authentik. An admin API call on it fails with each identity provider token found on the factory host, and the issuer's list of admin tokens and service accounts (names only, never values) shows none held on the factory. An issuer that isn't on the hub host passes the host-access, hypervisor and backups rows itself, run against its own host, and a hosted issuer's admin accounts each pass the failed-call check (duckworth-0007) | "Anyone with admin on the factory's sign-in provider can sign in to the hub as any user, Melanie included." | an issuer on the hub host, such as Pocket ID (Q175 supports several providers) |
+| TLS front end (B8) | TLS for the hub's origin ends on the hub host: the certificate the origin serves, fetched both through the public route and from the LAN (N19), matches the key on the hub host, and no factory proxy, tunnel or overlay route names the hub's origin | "The factory's proxy sees every hub sign-in, cookie and message in clear." | TLS ending on the hub host |
+| Certificate authority (mos-1009) | The hub's certificate comes from a public CA through an ACME account whose key is only on the hub host, and the zone's CAA record names only that CA | "The factory can get a valid certificate for the hub's name." | ACME run on the hub host |
+| DNS (N15) | A zone edit for the hub's name fails with each DNS credential found on the factory host, and the zone's owner account is one the factory can't sign in to | "The factory can point the hub's name at a host it runs." | a zone or registrar account only Jason or Melanie holds |
+| Network | From the factory host, the hub host answers only on the ports R8 needs (HTTPS, and ssh where it is used), and nothing else is open to the LAN | "The hub host sits on the same flat LAN as the factory, and only its logins protect it." | a host firewall on the hub, a separate VLAN |
+
+Some paths depend on others. While the hypervisor row is open, every secret on a PVE guest is exposed to
+node root: the TLS key, the ACME account key, an issuer's database and signing key on a guest, and the
+backup key whenever a restore loads it (N16). So closing those rows doesn't help until the hypervisor
+row is closed too, or they sit on hardware outside PVE. The R8 record names every path that stays accepted.
+
+## 9. Rulings (mos-0978, mos-0984, mos-0991, mos-0996, mos-1004, mos-1006, mos-1009, mos-1013)
+
+1. Q1: human cross-access is the 10-27 slice (mos-0978). Duckworth's N8 put agent-to-agent's timing to
+   Jason through Mos. Jason answered "P2P federation is acceptable for 10-27" (mos-0991), and then "P2P is
+   person-to-person in this case" (DECISIONS Q180, mos-1013). The slice is human access only, with no
+   agent-to-agent rows.
+2. Q2, settled by row 193 (morgana-0002, to Sage too): access.json is the one user and grant store for
+   humans. Row 193 adds `home: "local"` users, uses the grant level as the human role, and keeps viewer and
+   collaborator. The owner stays outside the file. Thread shares go in a new append-only bus table,
+   `thread_shares`, not in access.json, and a share counts only while the named user's live grant covers
+   the thread's project and instance. The 10-27 slice ships collaborator only (W2), so when row 193 adds
+   viewer, R1's level check widens with it. `thread_shares` is append-only, so an unshare is an end row in
+   row 193's design. R3 assumes nothing about shares (N12).
+3. Q3 and B5: R8 never runs on a single uid (mos-0984 point 2). For 10-27 its isolation is the hub's own host,
+   .54 (Q181), the host form only (mos-0996). The uid form (row 190b) is a later option. Jason accepted
+   the factory paths, the hypervisor's included (Q182, Q183), so R8 records them (section 8).
+
+## 10. Notes
+
+- The r1 push used the repo-local credential helper `scripts/git-credential-mosaic.mjs` (set in the
+  canonical checkout's .git/config for git.mosaicstack.dev) with its default credential file,
+  `~/secrets/mosaic.gitea.json`, and no `MOSAIC_GITEA_CREDENTIAL_FILE` override. That file's user is
+  jason.woltje. The r2 push uses the same. Gizmoduck has no seat identity until T1 row 195 adds per-agent
+  git identity.

agents/gizmoduck/work/queue-210/DESIGN.md

@@ -1,538 +0,0 @@
-# Row 210 (#424, Gitea #1707): agent host access with sudo through the credential store
-
-Gizmoduck, 2026-10-20, r3. Design only, no code. Reviewer Duckworth, gate owner Sage. Due 2026-10-27 (Q184).
-
-- Brief: `docs/plans/2026-10-20_host-credentials.md` at 9db578ff5.
-- Base read: `origin/refactor` 9ba31b5b3. Row 199 read as DESIGN.md r6 (4d3007ec9) and its code and
-  BUILD.md at addee664a on `megavolt/row199`.
-- PRD: REQ-CRED-3 in Honker's 1.7 draft (`agents/honker/work/queue-194/PRD-1.7-DRAFT.md:111-115`, 11cb0423b).
-  Jason approved PRD 1.7 (d52febb5 yes at 20:36:47Z, mos-1089), so REQ-CRED-3 is in.
-- Scope (sage-1468): this row ships the `host.run` broker op, the grant check, the executor and the receipts,
-  all testable over `broker.sock`. The `host_run` harness tool is out, as 199 left its publish tool out
-  (199 BUILD.md deviation 12). Sage files one follow-up row for the agent-facing harness tools, publish and
-  `host_run`, in `packages/harness`. Duckworth's r2 N5 (the tool help says a gated call leaves stdin under
-  4 KiB) belongs to that row.
-- Branch `gizmoduck/row210`. Row claimed in-progress (rev 2361) after Sage cleared the after (rev 2359). It
-  lands only after 199, rebased onto 199's landing (Q177).
-
-Rounds:
-- r3 (duckworth-0043, REVIEW-r2.md at 52b5fee63, approved with C1, and sage-1468, sage-1472): C1 Q-J0's revoke
-  line now matches section 6, the connection is cut and a started command may keep running. Q-S3 answered,
-  the harness tool is out (scope line above, D10). N1 the runner list takes Duckworth's whole list, and D6
-  says the per-call decision is the control. N2 numeric shorthand, unspecified and mapped addresses and
-  `*.localhost` refuse (D3, T1). N3 the pids file records each pid's start time (D7, T27). N4 the mutant
-  table is in order.
-- r2 (sage-1450): no `"any"` grant. The command boundary is an argv allowlist per host grant, and load refuses
-  a wildcard (D6, T26, M6, M28). PRD 1.7 is frozen, so `host.sudo` stays a hard wait and Jason decides each
-  call. Section 5 now holds the proposed 1.8 routing requirement. D5 is confirmed against 199's deviation 11.
-  The seat network gap is a known limit with what closes it (section 6). Cites now point at 199's code.
-- r2 (duckworth-0042, REVIEW-r1.md at 8140b7f39): B1 events name host, user and argv in clear (D5 step 6,
-  T22, M30). B2 a gated call's question shows stdin in full (D4, T9, M31). B3 the key and processes die with
-  the bus, and bus start sweeps leftovers (D7, T27, M32 to M34). B4 Q-J0 for Jason in section 10, worded to
-  stand alone (mos-1088). Notes taken: N1 (E12, runGit's kill shape), N2 (loopback refused, own-host limit),
-  N3 (process groups), N4 (stdin can make a prefix root), N5 (`-l` and a separate address), N6 (D8 framing),
-  N7 (section 7).
-
-## 1. What the code does today
-
-| # | Fact | Cite |
-|---|---|---|
-| E1 | The bus reads credentials for two kinds only, `gitea` and `vikunja` | `bus/src/credentials.mjs:22`, `business/src/vocabulary.mjs:103` |
-| E2 | A credential value must match `^[-A-Za-z0-9._~]+\n?$`, at least 16 and at most 16384 bytes. An OpenSSH private key fails it at the first `-----BEGIN` space | `bus/src/credentials.mjs:84-87` |
-| E3 | `assertClean` searches `JSON.stringify(result)` for each token. JSON escapes a newline, so a multi-line secret is never found: `JSON.stringify("a\nb").includes("a\nb")` is `false` (run on node here) | `bus/src/credentials.mjs:95-103` |
-| E4 | `use()` turns any exception in the operation into `service-failed`, then runs `assertClean` | `bus/src/credentials.mjs:104-117` |
-| E5 | Host to bus-child IPC is serial, one request at a time, with a 10 s timeout. A slow reply breaks the channel | `cli/src/host.mjs:31`, `:270` |
-| E6 | The web verbs run in the bus child over `broker.sock`. `requestWeb` checks keys, runs `#secretCheck`, checks the grant `roles[s.role].web`, records `action.allowed` (requested), calls `onAdmit()` so the server raises the socket timeout, runs the service and records completion | `bus/src/broker.mjs:1492-1530`, `bus/src/server.mjs:87-95` |
-| E7 | `roles[role].web` comes from the resolved tool limit. A role entry in the bus holds `authority`, `web` and `credentials` | `bus/src/business.mjs:17-20` |
-| E8 | A business-file role entry takes `definition`, `holder`, `vars`, `tracker`, `credentials`. Anything else refuses at load | `business/src/business.mjs:89` |
-| E9 | The chief's `organization.set` takes only `ORGANIZATION_KEYS`. The human-only `instances.set` takes `INSTANCE_KEYS` and refuses any definition that declares a credential (`organization-credentials-out-of-scope`). Holder, credentials and tracker stay hand edits | `bus/src/broker.mjs:145-147`, `:1248-1298`, `business/src/instance-settings.mjs:1-5`, `:22-31` |
-| E10 | An action outside ROUTED is a hard wait and classifies `gated` for every role. No role file may grant one | `bus/src/broker.mjs:44-70`, `business/src/vocabulary.mjs:58-88`, PRD REQ-WAIT-2 and 3 |
-| E11 | The seat sandbox does not confine the network, abstract Unix sockets or the host UID | `seat/src/sandbox.mjs:29-31` |
-| E12 | On refactor the bus child spawns nothing. With 199 it spawns git: `publishRemote` (`bus/src/runtime.mjs:245` at addee664a) runs `runGit`, a detached group leader that gets SIGTERM at the limit, then SIGKILL to the group after a grace period | `seat/src/checkout.mjs:95-138` at addee664a |
-| E13 | Role networks are `none`, `api-only`, `open`. The bundle carries the value, and the sandbox's own comment says the network is not confined (E11) | `business/src/vocabulary.mjs:101`, `harness/src/bundle.mjs:252` |
-
-Row 199 gives, in code at addee664a: `useFor` (`bus/src/credentials.mjs:228`), `issue` (`:156`), `revoke`
-(`:197`), `remove` (`:211`), the kind list (`:49`), the token pattern (`:19`, `:143`), the store dir's file
-regex `^(gitea|vikunja)(\.tmp)?$` (`:222`) and `withGitea` (`bus/src/runtime.mjs:233`). From its design: the store at `<configDir>/secrets/agents/<business>/<agent>/<kind>` (D1), the `{store: true}`
-reference (D2), the read path (D3, D3a), `useFor(session, kind, op)` with the call-site allowlist test (D5),
-the `publish` grant shape, a list on the role entry plus a hard-wait action whose decision binds the commit
-(D9), and the human-only lifecycle verbs with `changes.jsonl` receipts (section 6).
-
-## 2. Probe (throwaway keys, scratch sshd on 127.0.0.1:22410, OpenSSH 10.5p1)
-
-Run in `/mnt/storage/scratch/gizmo-210-probe` with keys made for the probe and deleted after. No real key or
-host was touched.
-
-| Probe | Result |
-|---|---|
-| `ssh-add -` with the private key on stdin, to an agent on a private socket | works, "Identity added: (stdin)" |
-| `IdentityAgent=<sock>` with `IdentitiesOnly=yes` and `IdentityFile=none` | refused, `Permission denied (publickey)`. With `IdentitiesOnly`, ssh offers only agent keys that match a configured identity |
-| same with `IdentityFile=<the public key file>` | works, rc 0 |
-| `-i /dev/fd/3` with the key on fd 3 | fails, "Identity file /dev/fd/3 not accessible". ssh closes inherited fds, so the fd route is out |
-| a known_hosts file pinning the wrong key under `HostKeyAlias` with `StrictHostKeyChecking=yes` | refused, "Host key verification failed", rc 255 |
-| `printf '%s|'` with `'a b'` and `'it'\''s'` single-quoted, plus an unquoted `$((1+1))` as a control | prints `a b|it's|2|`. The quoted elements arrive whole, and only the unquoted control expanded |
-| remote `exit 7` | ssh exits 7 |
-| killing the agent | its socket file is gone |
-
-## 3. Decisions
-
-### D1. The kind and its naming
-
-One key per (agent, host). The kind name is `host.<hostId>`, so the store file is
-`<configDir>/secrets/agents/<business>/<agent>/host.<hostId>` (199 D1, unchanged). `hostId` matches
-`^[a-z0-9][a-z0-9-]{0,31}$`.
-
-The closed kind set becomes `gitea`, `vikunja` and the family `host.<hostId>`. One exported helper,
-`credentialKind(name)` in `vocabulary.mjs`, answers whether a name is a kind, and each place that checks
-kinds calls it: `SERVICES` users (`role.mjs:105-118`), 199's `bus/src/credentials.mjs:49` and the store
-file regex at `:222`, the broker's service
-check, the CLI `issue` date flag and 199's remove regex. A build test greps for literal `'gitea', 'vikunja'`
-lists outside `vocabulary.mjs` and fails on a new one.
-
-Why per host and not per agent. A key that leaks, or a host that is retired, is revoked for that host alone.
-ops-01 installs one public key per host, and an `authorized_keys` line names one agent. The cost is more keys
-for Jason to issue, one per grant.
-
-A role definition declares the kind once as `{"service": "host"}` with no scopes. The business file binds the
-concrete hosts (D3). A definition can't name a host, because hosts belong to one stack instance.
-
-The date is `--rotate-by DATE`, as for gitea. An ssh key doesn't expire on its own, so `status()` reports
-`rotation-due` or `valid`, the gitea branch.
-
-### D2. The value check
-
-`checkValue(kind, text)` replaces the one regex at `credentials.mjs:84`. For `gitea` and `vikunja` it is
-today's check, unchanged. For `host.*` the value must be:
-
-- PEM framed by `-----BEGIN OPENSSH PRIVATE KEY-----` and `-----END OPENSSH PRIVATE KEY-----`, LF line ends,
-  at most 16384 bytes (the existing cap).
-- An `openssh-key-v1` blob with cipher `none`, kdf `none`, exactly one key, type `ssh-ed25519`. Parsed in
-  node with `Buffer`, no ssh-keygen call, so the check runs at bus start without a process.
-- The two check integers equal, and the public key in the private section equals the one in the header.
-
-Anything else refuses `credential-format`. An encrypted key refuses, because the bus has no way to ask for a
-passphrase and `BatchMode=yes` would fail at use time instead of at load. The parsed public key is kept with
-the entry so `status` and D7 can print its fingerprint without touching the private part.
-
-### D3. The grant
-
-Four layers. Each must hold, and the code checks all four on every call.
-
-1. **Role definition, reviewed commit.** `roles/<def>.json` lists `{"service": "host"}` in `credentials`. That
-   is the "reviewed role change" in the brief. Once a PRD version routes `host.sudo` (section 5), the same
-   reviewed commit puts `host.sudo` in that definition's `authority.withinRole`.
-2. **Host registry, business file, hand edit.** A new top-level key:
-   ```
-   "hosts": { "<hostId>": { "address": "10.1.1.53", "port": 22, "user": "localadmin",
-                            "hostKeys": ["ssh-ed25519 AAAA..."] } }
-   ```
-   `address` is an IPv4 or IPv6 literal or a DNS name matching `^[a-z0-9]([a-z0-9.-]{0,251}[a-z0-9])?$`.
-   An address of this machine refuses at load (r2 N2, r3 N2). For an IP literal, which `net.isIP` decides,
-   that is `127.0.0.0/8`, `0.0.0.0/8`, `::1`, `::`, and an IPv4-mapped `::ffff:` form of either IPv4 range.
-   For a name, it is `localhost` and any name ending in `.localhost`. A name made only of digits and dots
-   refuses unless `net.isIP` reads it as IPv4, so the shorthand `127.1` and the integer `2130706433`, which
-   pass the DNS pattern and which the resolver reads as 127.0.0.1, refuse. A label starting `0x` refuses for
-   the same reason. `port` is 1 to 65535. `user` matches `^[a-z_][a-z0-9_-]{0,31}$`. `hostKeys` is a non-empty list of
-   `ssh-ed25519`, `ecdsa-sha2-nistp256` or `ssh-rsa` public key lines, type and base64 only, no comment.
-3. **Agent grant, business file, hand edit.** A new role-entry key beside 199's `publish`:
-   ```
-   "hosts": { "<hostId>": { "commands": [["systemctl", "status"], ["journalctl", "-u"]] } }
-   ```
-   Each `hostId` must be in the registry, and the role's definition must declare `host`. A role entry with
-   `hosts` whose definition lacks `host` refuses at load and names `roles.<agent>.hosts`. `commands` is the
-   command boundary (D6).
-4. **The key.** `credentials["host.<hostId>"] = {"store": true, "rotateBy": DATE}` with the file present
-   (199 D2, D3a). A grant without an issued key refuses `credential-unavailable` at call time, as 199 does.
-
-Who writes each layer is in section 4. Neither the chief nor any agent can reach layers 2 to 4: `hosts` is
-outside `ORGANIZATION_KEYS` and `INSTANCE_KEYS` (E9), `instances.set` already refuses a definition that
-declares credentials (E9), and 199's `issue` is human-only.
-
-### D4. The action and the decision binding
-
-`host.sudo` is a new action in ACTIONS and in neither ROUTED list. Until a PRD version routes it, it is a hard
-wait and classifies `gated` for every role (E10). Each call then needs a decision the human resolved. PRD 1.7
-is frozen (sage-1450, decision d52febb5 cites its sha256), so under 1.7 Jason decides every `host.run`.
-
-The decision binds one call, the way 199 D9 binds `pushCommit`. When the action is `host.sudo`, the
-`decision.raise` event body gets `hostRun = {host, argvSha256, stdinSha256}`, from the raise's own args. The
-question shown to the human ends with the host id, the user, the argv with each element JSON-quoted, and the
-stdin in full as one JSON string, so Jason sees all of what runs (B2). The broker appends that text itself, and
-the agent can't shape it. The whole question keeps the 4096-character cap (`broker.mjs:126`, `:1654`), so on a
-gated call stdin is as large as the cap allows and no larger. A raise that doesn't fit refuses
-`invalid-request`. `argv ["bash"]` can't be granted at all (D6), and `["tee", "/etc/x"]` with a stdin Jason
-can't see is ruled out by showing it. `#authorityFor` refuses `decision-mismatch` when the call's host, argv hash or stdin hash differs, as
-`holderRun` does at `broker.mjs:796`. A decision is spent once (`decision-consumed`).
-
-After routing, a definition that lists `host.sudo` within-role runs without a decision, and `decision` is
-optional for that class only. The grant layers in D3 still apply.
-
-### D5. The executor: a `broker.sock` verb in the bus child
-
-```
-host.run {"host", "argv": [..], "stdin"?, "timeout"?, "decision"?}
-  -> {"exit", "signal", "stdout", "stderr", "truncated": {"stdout", "stderr"}, "ms"} or a refusal
-```
-
-It runs in the bus child, shaped like `requestWeb` (E6), not as a host IPC op. A sudo command can take
-minutes and the host channel times out at 10 s and serves one request at a time (E5). The key is in the bus
-child's memory already (199 D3), so no ticket has to cross to the CLI host. Row 199's publish needs a ticket
-because git and the working repo live in the CLI host. ssh needs neither. 199's BUILD.md deviation 11
-(addee664a) keeps credential use in the bus child too: the push runs there under `withGitea`, and the host
-socket only checks and polls. Sage confirmed D5 matches that shape (sage-1450). `host.run` needs no host
-socket and no poll, because the agent calls `broker.sock` directly. The helper is `withHost(session, host,
-fn)`, beside `withGitea`, calling `useFor(session, "host." + host, fn)`.
-
-Order of checks. Each refusal goes through `broker.refuse()` and logs `action.refused`.
-
-1. `keys(args)`, then `#secretCheck(args)`, then identity from the cap.
-2. `host` is in the registry (`host-unknown`).
-3. `host` is in `roles[s.role].hosts` (`host-not-granted`). This is the REQ-CRED-3 check "a grant exists for
-   that agent and that host".
-4. `argv` shape (D6) and `commands` match (`command-not-granted`).
-5. `#checkAuthority(s, "host.sudo", {decision, target: host, context})` (D4).
-6. Record `action.allowed` phase `requested` with host, address, user and argv in clear (B1), and stdin as
-   size and sha256. Every arg already passed `#secretCheck` in step 1, as the web verbs log their url
-   (`broker.mjs:1521`). After routing, the event log is the record of what ran as root. Then `onAdmit()`, which
-   sets the socket timeout to the call's timeout plus 10 s, as the web branch does (`server.mjs:95`).
-7. `credentials.useFor(s, "host." + host, run)`, where `run` is D7.
-8. D8's leak check on the output, then `#secretCheck` on the result.
-9. Record phase `completed` with host, argv, exit, signal, ms, and size and sha256 of stdout and stderr. The
-   output itself never goes into an event. A failure records `host-failed` with the same fields.
-
-Only one `host.run` per (agent, host) runs at a time. A second refuses `host-busy`. That keeps a stuck call
-from piling up ssh processes and makes revoke (D9) simple.
-
-Spawns reuse `runGit`'s shape (E12): an argv array, never a shell, `detached: true` so each process leads its
-own group, SIGTERM to the group at the limit and SIGKILL after a grace period. If the helper can be shared, it
-is, rather than a second copy. `env` is `{PATH: "/usr/bin:/bin"}` only, plus `SSH_AUTH_SOCK` for `ssh-add`.
-Each spawn is wrapped in `setpriv --pdeathsig KILL --`, the prefix the seat sandbox already uses
-(`seat/src/sandbox.mjs:44`), so it dies when the bus child dies (B3).
-
-### D6. The command boundary
-
-`argv` is an array of 1 to 256 strings. Each is 1 to 4096 bytes of UTF-8 with no NUL, and the total is at most
-32768 bytes. `argv[0]` must not contain `/` unless it starts with `/`. `stdin` is optional, a string of at most
-65536 bytes, and goes through `#secretCheck` with the args.
-
-The remote command is built by the bus, never taken as a string:
-
-```
-sudo -n -- 'argv0' 'argv1' ...
-```
-
-Each element is POSIX single-quoted: wrap in `'`, and replace each `'` with `'\''`. The probe shows the
-remote shell gets each element back exactly (section 2). `sudo -n` fails instead of prompting, so a host
-without NOPASSWD returns sudo's error, not a hang. The host's login shell for `user` must be POSIX. That is a
-host precondition for ops-01, listed in section 7.
-
-`commands` in the grant is an argv allowlist and nothing else. It is a non-empty list of argv prefixes. An
-argv passes when its first N elements equal some prefix of length N, compared element by element as literal
-strings, with no globbing. `[["systemctl", "status"]]` admits `systemctl status nginx` and refuses
-`systemctl restart nginx`.
-
-There is no wildcard grant (sage-1450). Business-file load refuses, naming `roles.<agent>.hosts.<id>.commands`:
-
-- any value that isn't a list, including the strings `"any"` and `"*"`,
-- an empty list, an empty prefix, a non-string element, or a duplicate prefix,
-- an element containing `*`, `?` or `[`, so nobody writes a glob that the matcher would read literally,
-- a prefix whose first element, by basename, is a shell, a command runner or an interpreter. Shells: `sh`,
-  `bash`, `dash`, `zsh`, `ksh`, `fish`, `busybox`. Runners: `su`, `sudo`, `doas`, `pkexec`, `runuser`, `env`,
-  `xargs`, `nohup`, `setsid`, `timeout`, `nice`, `systemd-run`, `chroot`, `nsenter`, `unshare`, `setpriv`,
-  `capsh`, `flock`, `stdbuf`, `ionice`, `chrt`, `taskset`, `strace`, `script`, `watch`. Interpreters:
-  `python3`, `perl`, `ruby`, `node`, `awk` (Sage's ruling on duckworth-0043 N1). Each would turn the prefix
-  back into "any". T26 has one case per name.
-
-That list can't be complete, and it isn't the control. Under 1.7 the control is Jason's decision on each
-call, bound to host, argv and stdin (D4, Q-S1). The list only refuses the obvious cases at load, early. Many commands can still start a shell or an editor as root (`systemctl edit`,
-`find -exec`, interpreters). The allowlist limits mistakes and narrows what a grant means, but it is not a
-sandbox. Stdin goes to the command, so some prefixes are root on their own: `[["tee"]]` or `[["dd"]]` writes
-any file as root from stdin (N4). Section 6 says what remains.
-
-Output: stdout and stderr each capped at 1 MiB. Past the cap the bus keeps reading and drops the rest so the
-remote side doesn't block, and sets `truncated`. `timeout` defaults to 60 s, maximum 900 s. At the timeout
-the bus sends SIGTERM to the ssh process group, then SIGKILL after 5 s, and answers `signal`. ssh's own exit
-code 255 and a remote command exiting 255 can't be told apart. The result returns stderr so the agent can see
-which, and the doc says so.
-
-### D7. Handing the key to ssh
-
-Per call, inside `useFor`'s operation:
-
-1. `mkdtemp` a dir under `<configDir>/secrets/run/` with mode 0700. `<configDir>` is never bound into a sandbox
-   (199 D3). The socket path is checked against the 107-byte Unix socket limit before use, refusing
-   `host-failed` if over.
-2. Write two files in it, mode 0600: `known_hosts` with one line per pinned key, `mosaic-host-<hostId> <type>
-   <base64>`, and `id.pub` with the entry's public key (D2).
-3. Write `<dir>/pids` with the bus child's pid. Each line in it is a pid and that process's start time,
-   field 22 of `/proc/<pid>/stat`, so a reused pid never matches (duckworth-0043 N3). Start `ssh-agent -D -a <dir>/a.sock` as its own group leader,
-   append its pid, and wait for the socket. Run `ssh-add -t <timeout + 30> -` with `SSH_AUTH_SOCK` set and the
-   private key written to its stdin. The key never touches disk, argv or env. `-t` makes ssh-agent drop the key
-   at the call's timeout plus 30 s even if nothing else runs (B3). ssh is the second group leader, and its pid
-   is appended too. Timeout, revoke and the `finally` kill both groups, ssh-agent's and ssh's (N3).
-4. Run ssh with exactly these options and nothing from any config file:
-   ```
-   ssh -F /dev/null -T -p <port>
-     -o BatchMode=yes -o IdentitiesOnly=yes -o IdentityFile=<dir>/id.pub -o IdentityAgent=<dir>/a.sock
-     -o StrictHostKeyChecking=yes -o UserKnownHostsFile=<dir>/known_hosts -o GlobalKnownHostsFile=/dev/null
-     -o HostKeyAlias=mosaic-host-<hostId> -o UpdateHostKeys=no -o CheckHostIP=no -o VerifyHostKeyDNS=no
-     -o ForwardAgent=no -o ForwardX11=no -o ClearAllForwardings=yes -o PermitLocalCommand=no
-     -o ProxyCommand=none -o ProxyJump=none -o ControlMaster=no -o ControlPath=none
-     -o ConnectTimeout=10 -o ServerAliveInterval=15 -o ServerAliveCountMax=3
-     -l <user> -- <address> <remote command from D6>
-   ```
-   The user goes in `-l` and the address is its own argument, so nothing depends on how ssh splits `@` or on
-   an IPv6 literal (N5). `-F /dev/null` stops `~/.ssh/config` from adding a ProxyCommand, a different key or forwarding. The pin is
-   `StrictHostKeyChecking=yes` against a file the bus wrote from the registry, so there is no trust on first
-   use: an unknown or changed host key refuses with rc 255 (probe, section 2) and the bus answers
-   `host-key-mismatch` when stderr has "Host key verification failed".
-5. In a `finally`: kill both groups, remove the dir. A test asserts the dir is gone after success, refusal,
-   timeout and an exception thrown inside the operation.
-6. If the bus child is killed, the `finally` never runs. `--pdeathsig` kills ssh-agent and ssh with it, and
-   `-t` drops the key anyway. At bus start, before `broker.sock` listens, the bus sweeps
-   `<configDir>/secrets/run/`. A recorded pid counts as alive only when it exists and its start time matches.
-   For each dir whose bus pid is no longer alive, it sends SIGKILL to each recorded pid that is alive and
-   whose `/proc/<pid>/cmdline` names that dir, then removes the dir. A dir whose bus pid is alive is left
-   alone. Any other entry there refuses start, as 199 refuses a stray file
-   in the store (`credentials.mjs:222`). Revoke after a restart has nothing in flight to reach.
-
-The 0600 temp key file route the brief allows is not used. The agent route keeps the private key off disk,
-and the fd route doesn't work (probe).
-
-### D8. The leak check
-
-This is defense in depth (N6). The remote never holds the private key and forwarding is off, so output can
-carry the key only if the agent already had it. `assertClean` misses a multi-line key (E3). A `host.*` entry
-in the shared token map makes its loop compare against a value that never matches, which is harmless. For a `host.*` entry, `useFor` checks the result with
-`assertCleanKey(result, entry)`, which searches the JSON text for:
-
-- each base64 body line of the PEM of 24 characters or more,
-- the whole body with line breaks removed,
-- the 32-byte ed25519 private seed as lowercase hex and as base64 at each of the three byte offsets.
-
-A match refuses `credential-leak`. The output is dropped, and the event records only sizes and hashes. The
-existing `assertClean` still runs for the token kinds. The same function runs on `stdin` before the call, so
-an agent can't round-trip a key it somehow has back through the host.
-
-### D9. Lifecycle
-
-199's verbs carry over with `KIND = host.<hostId>`. Two additions:
-
-- `issue AGENT host.<id>` checks D2, then prints the public key line and a suggested `authorized_keys` line
-  for ops-01: `from="<stack host address>",restrict <type> <base64> mosaic-<business>-<agent>-<id>`. It
-  prints only public material.
-- `revoke` also kills a `host.run` in flight for that agent and host (process group SIGKILL) before it drops
-  the key. The call answers `credential-unavailable`. Remote processes that the killed ssh started may keep
-  running (section 6).
-
-`status` shows each host entry with its fingerprint (SHA256 of the public key), the rotate date and state.
-The tester gets `status` and `revoke` only, as in 199.
-
-### D10. Where the files change
-
-| File | Change |
-|---|---|
-| `business/src/vocabulary.mjs` | `host.sudo` in ACTIONS, `credentialKind`, host id pattern |
-| `business/src/business.mjs` | top-level `hosts` registry, role-entry `hosts`, load checks from D3 |
-| `business/src/role.mjs` | `{"service": "host"}` in `checkCredentials` with no scopes |
-| `business/src/credentials.mjs` | `host.*` refs take `rotateBy` |
-| `bus/src/credentials.mjs` | kind check via `credentialKind`, `checkValue` (D2), `assertCleanKey` (D8), busy and kill map |
-| `bus/src/host-run.mjs` (new) | D6 argv and quoting, D7 ssh-agent and ssh spawn, cleanup |
-| `bus/src/broker.mjs` | `host.run` verb (D5), `host.sudo` in `#authorityFor` with `hostRun` (D4) |
-| `bus/src/server.mjs` | `host.run` branch beside the web branch with `onAdmit` |
-| `bus/src/business.mjs` | carry `hosts` onto the bus role entry |
-| `cli` | 199's `credentials issue` accepts `host.<id>`, prints D9's lines |
-
-No `packages/harness` file changes. The `host_run` tool is Sage's follow-up row (sage-1468).
-
-Row 199's own kind and regex are not changed inside row 199. This row rebases onto 199's landing and changes
-them here.
-
-## 4. Who grants (brief item, "yours to propose with reasons")
-
-Proposal: **Jason, at every layer that widens access. No agent, chief included, and not the tester.**
-
-| Layer | Who | How | Why |
-|---|---|---|---|
-| Definition declares `host` (and later lists `host.sudo`) | Jason | reviewed commit to `roles/*.json`, as for any role authority (AGENTS.md invariant 7) | It decides which kinds of agent may ever hold a host key. Review puts a second seat on it |
-| Host registry and pins | Jason, with ops-01's key fingerprints | hand edit of the business file | The pin is the host identity. A wrong pin is a man-in-the-middle on root. It must come from the host side, not from a first connection |
-| Agent grant `roles.<agent>.hosts` | Jason | hand edit of the business file | Q183: "not all agents will need to have that access". The per-agent, per-host choice is his |
-| Key `issue` | Jason | 199's human-only `issue` | The key passes through the caller. The tester is an agent (199 section 6, duckworth N1) |
-| `authorized_keys` on the host | ops-01 | host side, from the line `issue` prints | ops-01 owns the hosts (brief) |
-| Revoke | Jason, Mos, or the tester | `revoke` | Taking access away should be quick and needs no new trust |
-
-Why not a reviewed commit for the agent grant too. The business file lives in `<configDir>`, outside the
-repository (AGENTS.md invariant 2), and per-instance grants already stay hand edits there (E9, 199 D9 step 2).
-Moving grants into the repo would put host addresses and the per-instance roster under review, which is a
-bigger change than this row. The definition layer is the reviewed one.
-
-Why not the chief. A chief with this power could hire an agent and grant it root. 199 already keeps hires
-uncredentialed (199 D13). `instances.set` refuses credentialed definitions today (E9), and this row keeps it
-that way.
-
-REQ-CRED-3 says the who-grants answer is set by this design and approved by Jason. The table above is that
-answer.
-
-## 5. The routing gap and a proposed 1.8 requirement
-
-PRD 1.7 routes `role.hire`, `role.fire` and `git.push.remote`, not `host.sudo`, and 1.7 is frozen (sage-1450).
-This row builds for 1.7 as it stands. `host.sudo` is a hard wait under REQ-WAIT-3, and Jason decides each
-`host.run`, bound to host, argv and stdin (D4). That is safe, and slower than Q183's "allow agents to perform
-their jobs". The routing goes in 1.8. Sage takes the line below to Mos for Jason. I don't edit the PRD.
-
-Proposed for PRD 1.8, beside REQ-CRED-3:
-
-> **REQ-CRED-4.** The action `host.sudo` is routed. A role whose definition lists it within-role may run a
-> command with sudo on a host without a decision for each call, but only when all of these hold: the
-> definition declares the host credential kind, the business file grants that agent that host, the command
-> matches the grant's argv allowlist, and the agent's key for that host is issued. A grant names exact
-> argv prefixes. A wildcard grant is refused. A role without `host.sudo` within-role still needs a decision
-> for each call. Jason adds `host.sudo` to a definition only through a reviewed role change.
-
-Routing is then one reviewed commit: `host.sudo` into both ROUTED lists and into the chosen definitions'
-`withinRole`, as 199 does for `git.push.remote`.
-
-The brief also says this row lands only after the PRD version holding REQ-CRED-3 is approved. Jason approved
-1.7 (d52febb5 yes at 20:36:47Z, mos-1089), so that holds. 1.7 doesn't route `host.sudo`, so Q-S1 stands.
-
-## 6. Limits, said plainly
-
-- **Known limit: the seat network isn't confined, so root can outlive the grant.** `seat/src/sandbox.mjs:29-31`
-  says the sandbox doesn't confine the network (E11). An agent whose allowlist admits any command that can
-  write a file as root, or start a shell, can add its own key to `authorized_keys` on the host. It can then
-  ssh straight from its sandbox, around the bus, the events and revoke. An `authorized_keys` `from=` option
-  doesn't help, because the sandbox shares the stack host's address. The allowlist (D6) narrows this but
-  doesn't close it.
-  What closes it: a seat sandbox with its own network namespace (`bwrap --unshare-net`), where the only way
-  out is the bus sockets and the model proxy, so role network `none` and `api-only` are enforced and not just
-  carried in the bundle (E13). With that in place, a planted key is useless from the sandbox. Until then,
-  ops-01's host-side audit (sudo log, `authorized_keys` changes) is the check after the fact. Sage is
-  reporting the gap to Mos as its own follow-up (sage-1450). It is not this row.
-- **The stack's own machine.** A registry entry for the machine the stack runs on, or any machine holding the
-  stack's `<configDir>`, gives an agent with a root-writing command every agent's keys and tokens, not only
-  root there (N2). Load refuses loopback addresses, but it can't know every address of the stack's machine.
-  Jason doesn't register it.
-- **Revoke stops the stack's path, not remote processes.** Killing ssh may leave a remote process running.
-  `-T` gives no tty, so there is no SIGHUP from a closing terminal.
-- **Same OS user.** Anything running as the stack's OS user outside a sandbox can read the key file, as 199 D6
-  says for every kind.
-- **Exit 255** is ssh's failure code and also a remote exit code (D6).
-- **The pin trusts the registry.** Whoever writes the business file controls which host key is trusted. That
-  is Jason (section 4).
-
-## 7. Host preconditions (ops-01, not this row)
-
-- `user` has NOPASSWD sudo and a POSIX login shell. `sudo` has no `requiretty` for that user.
-- The agent's key is in `authorized_keys` with `from="<stack host>",restrict`.
-- The host's public keys are handed to Jason for the registry.
-- Duckworth's #423 r5 condition (duckworth-0035) applies. If ops-01 changes #423 step 1 to fit this design,
-  for example per-agent `from=...,restrict` lines for localadmin, that change goes to Duckworth as a diff
-  before it runs. That is the live part, not this row (N7).
-
-## 8. Tests
-
-All tests use a scratch sshd on 127.0.0.1 started by the test, with keys made by the test, and a fake `sudo`
-on the test user's PATH that prints its argv as JSON and runs nothing as root. The sshd config sets
-`AuthorizedKeysFile` and `HostKey` in the test's `mkdtemp` dir. A helper skips the ssh tests with a visible
-reason only when `/usr/bin/sshd` is missing, and the gate fails if any of them skipped. No test reaches
-another host.
-
-| # | Test | Refusal or result |
-|---|---|---|
-| T1 | business load: `hosts` registry field checks, bad address, each own-machine form from D3 (`127.0.0.2`, `0.0.0.0`, `::1`, `::`, `::ffff:127.0.0.1`, `::ffff:0.0.0.0`, `localhost`, `a.localhost`, `127.1`, `2130706433`, `0x7f.1`), with `10.1.1.53` and `host.example` as controls, port, user, empty `hostKeys`, a key line with a comment | load refuses, names the key path |
-| T2 | role entry `hosts` naming an unknown host, or on a definition without `host` | load refuses `roles.<agent>.hosts` |
-| T3 | `organization.set` and `instances.set` with `hosts` in args | `invalid-request`, and the file is unchanged |
-| T4 | value check: a valid unencrypted ed25519 key loads. An encrypted key, an RSA key, two keys, CRLF, a gitea token in a `host.*` slot, and a PEM in a `gitea` slot each refuse | `credential-format` |
-| T5 | `host.run` with an unknown host | `host-unknown` |
-| T6 | `host.run` on a host not in the caller's grant, including a host granted to another agent | `host-not-granted` |
-| T7 | argv shape: empty, a NUL, too long, too many, a relative path with `/`, non-string | `invalid-request` |
-| T8 | allowlist: a matching argv runs, a longer argv runs, a shorter one and a differing element refuse | `command-not-granted` |
-| T9 | before routing: no decision refuses, a decision for another argv, another host or another stdin refuses, a spent one refuses. The stored question carries host, user, argv and the full stdin, and a raise whose question would pass 4096 characters refuses | `gated`, `decision-mismatch`, `decision-consumed`, `invalid-request` |
-| T10 | quoting: argv with spaces, quotes, `$()`, backticks, `;`, newline and glob characters reaches fake sudo unchanged | fake sudo's JSON equals argv |
-| T11 | the remote command starts `sudo -n --` | fake sudo sees `-n` and `--` first |
-| T12 | exit code and signal pass through, timeout kills the process group and answers `signal` | result fields |
-| T13 | output cap: 2 MiB of stdout returns 1 MiB and `truncated.stdout: true`, and the call doesn't hang | result fields |
-| T14 | host key pin: the sshd presents a key not in `hostKeys` | `host-key-mismatch`, and no command ran (fake sudo's marker file absent) |
-| T15 | a registry with the right key passes on a fresh dir with no `~/.ssh/known_hosts` in HOME. A HOME with a `~/.ssh/config` setting a ProxyCommand doesn't change the call | runs, and the proxy marker is absent |
-| T16 | leak: the fake sudo prints the private key file (multi-line), and in a second case prints only one body line, and in a third the seed in hex | `credential-leak`, the event has no output |
-| T17 | `stdin` containing a body line of the key | `credential-leak` before any spawn |
-| T18 | cleanup: after success, refusal, timeout and a thrown error, the run dir is gone and no `ssh-agent` or `ssh` with that dir in argv survives | dir absent, pgrep empty |
-| T19 | the private key never appears in the argv or env of any spawned process (read from `/proc/<pid>/cmdline` and `environ` while the fake sudo sleeps) | absent |
-| T20 | second concurrent call for the same agent and host | `host-busy` |
-| T21 | revoke during a sleeping call kills it, and the next call refuses | `credential-unavailable` |
-| T22 | events: `action.allowed` requested and completed carry host, address, user and argv in clear, and sizes and hashes of stdin, stdout and stderr. Never the output, the stdin or the key | event bodies |
-| T23 | `issue` of a `host.*` kind prints the public line and the `authorized_keys` suggestion and never the private key | stdout and stderr checked |
-| T24 | build grep: no literal `'gitea', 'vikunja'` kind list outside `vocabulary.mjs`, and 199's `credentials.use(` allowlist unchanged | grep |
-| T25 | no role file in `roles/` lists `host.sudo` while it is a hard wait (REQ-WAIT-2) | grep |
-| T27 | SIGKILL the bus child while fake sudo sleeps: the ssh and ssh-agent pids are gone within 2 s. A call with `timeout` 1 leaves an agent whose key is gone after 31 s (`ssh-add -l` on its socket, agent kept alive by the test). The next bus start removes the run dir, kills a planted live process whose cmdline names it, leaves a dir whose bus pid is alive, and leaves a live process whose pid matches but whose start time doesn't | pids, `ssh-add -l`, dir state |
-| T26 | load refuses `commands` as `"any"`, `"*"`, `{}`, `[]`, `[[]]`, a non-string element, a duplicate prefix, an element with `*`, `?` or `[`, and a prefix starting with each listed shell or runner, `/bin/bash` included | load refuses, names `roles.<agent>.hosts.<id>.commands` |
-
-## 9. Mutants
-
-One per refusal, plus the two the brief names. Each must be killed.
-
-| # | Mutant | Killed by |
-|---|---|---|
-| M1 | registry check skipped | T5 |
-| M2 | agent grant check skipped | T6 |
-| M3 | grant check reads any agent's `hosts` | T6 |
-| M4 | each argv shape check removed, one mutant each (5) | T7 |
-| M5 | prefix match compares only `argv[0]` | T8 |
-| M6 | load accepts a string `commands` (wildcard grant) | T26 |
-| M7 | `#checkAuthority` call removed | T9 |
-| M8 | `hostRun` argv hash not compared | T9 |
-| M9 | `hostRun` stdin hash not compared | T9 |
-| M10 | quoting drops the `'\''` replacement | T10 |
-| M11 | `sudo -n` loses `-n` | T11 |
-| M12 | **host key pin skipped**: `StrictHostKeyChecking=accept-new` | T14 |
-| M13 | **pin skipped another way**: `UserKnownHostsFile` set to the user's default | T14, T15 |
-| M14 | `-F /dev/null` removed | T15 |
-| M15 | **key leaks into output**: `assertCleanKey` not called | T16 |
-| M16 | leak check uses only the joined body | T16 (one-line case) |
-| M17 | stdin leak check removed | T17 |
-| M18 | `finally` cleanup removed | T18 |
-| M19 | key passed with `-i` from a temp file left on disk | T18, T19 |
-| M20 | output cap removed | T13 |
-| M21 | timeout kill removed | T12 |
-| M22 | busy check removed | T20 |
-| M23 | revoke doesn't kill the in-flight call | T21 |
-| M24 | event records stdout | T22 |
-| M25 | each value check removed, one mutant each (encrypted, type, count, CRLF) | T4 |
-| M26 | `organization.set` accepts `hosts` | T3 |
-| M27 | load check for a definition without `host` removed | T2 |
-| M28 | shell and runner check removed, and a second mutant compares `argv[0]` without taking the basename | T26 |
-| M29 | glob character check removed | T26 |
-| M30 | `requested` event drops argv | T22 |
-| M31 | the question omits stdin | T9 |
-| M32 | `--pdeathsig` dropped from the spawns | T27 |
-| M33 | `ssh-add` without `-t` | T27 |
-| M34 | start sweep removed, a second mutant sweeps without checking the bus pid, and a third ignores the start time | T27 |
-| M35 | loopback check removed | T1 |
-
-The mutant script follows row 201's shape: copy the packages to scratch, anchor each mutant once, run each
-test file in its own process group with a timeout, control first, exit 1 on any survivor. It runs on Sage's
-slot.
-
-## 10. Questions
-
-- Q-S1, answered (sage-1450): 1.7 is frozen. Hard wait under 1.7, and section 5 holds the 1.8 proposal.
-- Q-S1 still holds after 1.7's approval, which doesn't route `host.sudo` (sage-1468).
-- Q-S2, answered (sage-1450): 199's deviation 11 keeps credential use in the bus child, so D5 stays.
-- **Q-J0 (Jason, through Mos, before landing, B4, mos-1088).** Word for word:
-
-  > Q-J0 (#424). Who may give an agent sudo on another machine?
-  > Proposal: only you. No agent can, and that includes the chief of staff and the tester.
-  > You make a grant in four steps, all yours. A reviewed change to the agent's role allows machine keys at all.
-  > You list the machine and its fingerprint. You give that agent that machine with an exact list of allowed
-  > commands. You issue the key, and ops-01 installs it. Until a later PRD says otherwise, you also approve
-  > each command before it runs. You, Mos or the tester can revoke at once. The stack drops the key and cuts
-  > its connection. A command already started on the machine may keep running. A grant of "any" command is
-  > root on that machine, so the design refuses it. Some listed commands, such as a file writer, still reach
-  > root, so grant a machine only to an agent you'd trust as root there.
-  > Do you approve: only you grant machine access, as above? Yes or no. I recommend yes.
-
-  Mos records the answer in DECISIONS.md in jason-master-restart.
-- **Q-J1 (Jason, through Mos, at the live window):** the first grants, each an argv allowlist per agent and
-  host. Not needed for the build.
-- Q-S3, answered (sage-1468): the `host_run` harness tool is out of this row. Sage files a follow-up row for
-  publish and `host_run` in `packages/harness` (scope line at the top).

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/README.md

@@ -1,7 +0,0 @@
-# Honker
-
-Builder seat, Claude Opus 5.5, started by Sage for MVP T1 row 194 (agent lifecycle, #1692) under mos-0974 and mos-0977.
-
-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 `honker/*` 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/launchpad/README.md

@@ -1,7 +0,0 @@
-# Launchpad
-
-Builder seat, Claude Opus 5.5, started by Sage for MVP T1 row 192 (Q175 SSO phase 1, #1690) under mos-0974 and mos-0977.
-
-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 `launchpad/*` branches
-through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

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/morgana/README.md

@@ -1,7 +0,0 @@
-# Morgana
-
-Builder seat, Claude Opus 5.5, started by Sage for MVP T1 row 193 (human users and RBAC, #1691) under mos-0974 and mos-0977.
-
-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 `morgana/*` 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/q175-sso/DESIGN.md

@@ -1,42 +1,8 @@
 # Q175 design: the Console verifies SSO itself (Vikunja #412)
 
-Author Sage, 2026-10-20, r3. Reviewer Filbert, and the review comes before any code. Line numbers are at
-refactor 4ca8d6e94 unless a line says otherwise. This replaces Part B (row 178 proxy proof, #385 comments 345
-and 353). #385 stays open until the Console stops trusting `X-authentik-username`.
-
-## Changes from r2 (Filbert's r2 review, CHANGES)
-
-- C1: the `console` key goes into the shared loader, scripts/mosaic-config.mjs, which today refuses any
-  unknown top-level key (:113). Section 4 names the blast radius. Jason step 4 moves inside the phase 2
-  window, after the pin and before the Console starts. The phase 2 rollback removes `console` first. A
-  test-config.sh case covers it (test 25). Mos confirms the sequence before phase 1 (section 5).
-- C2: under `--sso` the page treats a 401 `sign-in required` as signed out and links to
-  `/auth/login?return=<path>` (section 5 phase 1, test 24).
-- Notes: tests 7 and 15 are built so that only the record rule refuses; test 9a is an alg test; Q-B's two
-  classes are defined, and test 23 adds a 200 HTML page; the phase 2 scratch Console uses a scratch config,
-  a dummy slot, no `--send` and no `--tester-port`.
-- r3 fix (Filbert r3 approve): D1, the loader checks the slot reference's shape only, and the file checks
-  run in the Console's `--sso` start; D2, the slot resolves from the config dir, and the scratch Console has
-  a scratch dataRoot and an unreachable issuer (section 5).
-- Q-E: settled as Filbert ruled. The `subject-unknown` line keeps iss and sub, JSON-escaped and capped
-  (section 1, tests 10 and 19).
-
-## Changes from r1 (Filbert's r1 review, CHANGES)
-
-- B1: the provider config moves to `~/.config/mosaic-dev/config.json` (section 4). Mos agreed (mos-0973). The
-  Console prints provider ids, issuers and subject counts at start. The rehearse-strip follow-up is dropped.
-- B2: one return-path rule, `new URL(ret, publicOrigin).origin === publicOrigin` (section 1 step 7), with
-  tests for `/\evil.example` and `/%09/evil.example`.
-- B3: refusals log a fixed code and the provider id, never the error or its cause (section 1).
-- B4: login records are capped at 32 (section 1 step 1), with a test.
-- B5: test 9 splits into a forged payload under a real kid and a kid missing from the JWKS, and a try/catch
-  mutant joins the list. Test 2 no longer claims the signature mutant (section 9).
-- B6: the phase 2 forged-header check runs on a scratch Console, or Mos or Jason runs it on live (section 5).
-- Rulings: Q-B start degraded (section 4), Q-C only the public Host on 7332 (section 3), Q-D keep 1 h idle
-  but polls don't count as activity (section 3).
-- Section 6: `startServer` throws on `tester && sso`, and `human` joins `tester` as a refused subject label.
-- The missing tests and nits N1-N5 are in sections 1, 3, 7 and 9.
-- Section 8: the human-cli statement stays as written (mos-0972). The recommendation is now Mos's ruling.
+Author Sage, 2026-10-20. Reviewer Filbert, and the review comes before any code. Line numbers are at refactor
+4ca8d6e94. This replaces Part B (row 178 proxy proof, #385 comments 345 and 353). #385 stays open until the
+Console stops trusting `X-authentik-username`.
 
 ## The ruling this implements
 
@@ -56,9 +22,7 @@ trust with verification" and confirmed five points (mos-0970):
 ## What exists today
 
 The live Console runs from copies/490e2771d3d0 with `--public-host mosaic.woltje.com --auth-header
-X-authentik-username --allow-user jason.woltje --send --tester-port 7333`. Row 189 (#1687, P19 #413) adds
-`stack-release.sh activate --no-send`, and Mos's ruling mos-0972 takes `--send` off the live Console until
-phase 2.
+X-authentik-username --allow-user jason.woltje --send --tester-port 7333`.
 
 - `previewOptions` (packages/webui/src/serve.mjs:205) builds `{ host, header, user }`.
 - A request is `named` when its Host equals the public name (:493). A named request passes sign-in when it
@@ -81,73 +45,41 @@ New module `packages/webui/src/sso.mjs`, used only by the human listener (7332).
 
 | Route | Method | What it does |
 |---|---|---|
-| `/auth/login` | GET | One provider configured: start its flow. Several: a plain page listing them, each a link to `/auth/login?provider=ID`. A provider whose discovery hasn't succeeded gets 503 (section 4). |
+| `/auth/login` | GET | One provider configured: start its flow. Several: a plain page listing them, each a link to `/auth/login?provider=ID`. |
 | `/auth/callback` | GET | Finish the flow, create the session, 303 to the saved return path. |
 | `/auth/logout` | POST | Same-origin checks, delete the session, 303 to the provider's `end_session_endpoint`. |
 | `/auth/signed-out` | GET | Static "signed out" page with a sign-in link. |
 
-Every URL the Console hands a provider is built from the configured `publicOrigin`: `redirect_uri` is
-`publicOrigin + '/auth/callback'` and `post_logout_redirect_uri` is `publicOrigin + '/auth/signed-out'`. No
-code path reads the request's Host to build them (N2).
-
 The flow per provider:
 
 1. Start. Generate a state, a nonce and a PKCE verifier (`generateRandomState`, `generateRandomNonce`,
    `generateRandomCodeVerifier`), and a challenge with `calculatePKCECodeChallenge` (S256 only). Put them, the
-   provider id, the return path and an expiry 10 minutes out in a server-side login record keyed by a random
-   id. The store holds at most 32 login records; a new one evicts the oldest (B4). Set `__Host-mosaic_login` to
-   that id. 303 to `authorization_endpoint` with `response_type=code`, `scope=openid profile email`,
-   `code_challenge_method=S256`, `redirect_uri`, `state` and `nonce`.
+   provider id and the return path in a server-side login record keyed by a random id. Set
+   `__Host-mosaic_login` to that id. 303 to `authorization_endpoint` with `response_type=code`,
+   `scope=openid profile email`, `code_challenge_method=S256`, `redirect_uri`, `state` and `nonce`.
 2. Callback. Read exactly one `__Host-mosaic_login` cookie, then take and delete its record (single use, so a
    replayed callback finds nothing). Expire the cookie in the response. The provider comes from the record,
-   never from the query, which stops a mix-up between providers. Two tabs signing in at once each set the
-   cookie, so the later one wins and the earlier tab's callback finds no record and gets the 403 page with a
-   sign-in link (N5). That costs one retry and keeps one cookie per browser.
+   never from the query, which stops a mix-up between providers.
 3. `validateAuthResponse(as, client, url, record.state)` checks state, refuses an error response, and checks
    the `iss` parameter when the provider advertises RFC 9207.
-4. `authorizationCodeGrantRequest(as, client, clientAuth, params, redirectUri, record.verifier)` returns a
-   `Response`. Keep that object. `processAuthorizationCodeResponse(as, client, response, { expectedNonce:
-   record.nonce, requireIdToken: true })` checks iss, aud (and azp when aud has several values), exp, iat and
-   nonce, and checks `alg` against `client.id_token_signed_response_alg`. That field gets the provider's whole
-   `algs` array, which the library's `checkSigningAlgorithm` accepts, so a provider listing RS256 and ES256
-   takes either and nothing else (N1). Test 16 pins this.
+4. `authorizationCodeGrantRequest(as, client, clientAuth, params, redirectUri, record.verifier)`, then
+   `processAuthorizationCodeResponse(as, client, response, { expectedNonce: record.nonce, requireIdToken: true })`.
+   That checks iss, aud (and azp when aud has several values), exp, iat and nonce, and checks `alg` against
+   `client.id_token_signed_response_alg`.
 5. Signature. oauth4webapi does not verify the signature of an ID token that came straight from the token
    endpoint over TLS (OIDC Core 3.1.3.7 allows that, and the library docs for
    `validateApplicationLevelSignature` say so). Point 2 asks for the JWKS check, so the callback always calls
-   `validateApplicationLevelSignature(as, response)` with the same `Response` object from step 4. It fetches
-   the JWKS from the discovered `jwks_uri`, picks the key by `kty`, `kid`, `alg` and `use`, and refuses HS*
-   outright. On a `kid` it doesn't have, it refetches the JWKS once if the cache is at least 60 s old, which
-   covers key rotation (test 18). The call is not wrapped in a catch that continues; its throw ends the
-   callback.
-6. Our own checks on top of the library: `header.alg` is in the provider's `algs`, the token's `iss` equals
-   the configured issuer as a raw string compare, with no URL normalising (N3; the library's discovery check
-   compares normalised hrefs, so this one is stricter), and `(iss, sub)` is in the provider's `subjects` list.
-7. Create the session (section 3), then 303 to the return path. The rule (B2): resolve
-   `u = new URL(ret, publicOrigin)`, and use `u.pathname + u.search` only when
-   `u.origin === publicOrigin`; otherwise use `/`. A missing or unparsable `ret` gives `/`.
+   `validateApplicationLevelSignature(as, response)` after step 4. It fetches the JWKS from the discovered
+   `jwks_uri`, picks the key by `kid` and `alg`, and refuses HS* outright.
+6. Our own checks on top of the library: `header.alg` is in the provider's configured `algs`, the token's
+   `iss` equals the configured issuer exactly, and `(iss, sub)` is in the provider's `subjects` list. Anything
+   else is a 403 that logs `refused sign-in iss=... sub=...` (never a token, code or cookie).
+7. Create the session (section 3) and 303 to the return path. The return path must start with one `/` and
+   is otherwise replaced with `/`.
 
 Every refusal in steps 2-6 ends at a 403 page saying sign-in failed, with a link back to `/auth/login`. No
 step falls back to a header.
 
-Logging (B3). A refusal logs one line: a fixed code from a closed list (`login-record-missing`,
-`state-mismatch`, `auth-error-response`, `grant-failed`, `id-token-invalid`, `signature-invalid`,
-`alg-refused`, `issuer-mismatch`, `subject-unknown`, `discovery-failed`, `jwks-failed`) and the provider id.
-It never logs the exception, its message or its `cause`. oauth4webapi's errors carry token bodies and claims
-in `cause`, so even a message can leak. The one extra field is on `subject-unknown`: it logs `iss` and `sub`,
-because Jason step 3 reads his `sub` from that line (Q-E, Filbert's ruling). Authentik's default subject mode
-is a hashed user id that its admin view doesn't show, so the line is the practical source. Neither value is a
-credential. Three conditions hold:
-
-- Only a token that passed steps 3-6 up to the subject check reaches this line. Every earlier refusal logs
-  its own code and the provider id only.
-- Both values are written with `JSON.stringify` and each is cut to 255 characters first. Any account at the
-  provider can get a signed token, so a `sub` may hold a newline, and an unescaped one would let a sign-in
-  forge a log line.
-- Test 10 uses a `sub` holding `\n` and a fake `refused sign-in` suffix and asserts one escaped line.
-
-Test 19 asserts that no log line holds a token, code, state, nonce, verifier, client secret or session id.
-It exempts only the `iss` and `sub` fields of the `subject-unknown` line.
-
 ### 2. Library: oauth4webapi 3.8.8, pinned exactly
 
 Mos's steer (mos-0971) was to prefer oauth4webapi over hand-rolled verification on `node:crypto` unless I
@@ -171,78 +103,34 @@ entry. Root is right because `scripts/stack-copy.sh:23-31` copies only the root
 webui's first runtime dependency. The root dependency rule (exact pins, never unversioned) applies to it.
 Upgrades are reviewed commits.
 
-### 3. Sessions, cookies, Host and logout
+### 3. Sessions, cookies and logout
 
-- Session id: 32 random bytes, base64url. The store keys on its sha256 and holds no raw id, so a heap dump
-  doesn't hold usable ids. Test 20 checks that the store's keys and values never contain the cookie value.
-- Cookie, exactly: `__Host-mosaic_session=<id>; Path=/; Secure; HttpOnly; SameSite=Lax`, no Domain, no
-  Max-Age (a browser-session cookie). The `__Host-` prefix makes the browser refuse it unless it was set over
-  https on this exact host. Test 21 asserts the whole Set-Cookie value, and a mutant drops `HttpOnly`.
-- Login cookie `__Host-mosaic_login`, the same attributes plus `Max-Age=600`. The login record also expires
-  at 10 minutes server-side.
+- Session id: 32 random bytes, base64url. The store keys on its sha256, so a heap dump doesn't hold usable ids.
+- Cookie `__Host-mosaic_session=<id>; Secure; HttpOnly; SameSite=Lax; Path=/`, no Domain, no Max-Age (a
+  browser-session cookie). The `__Host-` prefix makes the browser refuse it unless it was set over https on
+  this exact host.
+- Login cookie `__Host-mosaic_login`, same attributes plus `Max-Age=600`. The login record also expires at
+  10 minutes server-side.
 - Lax, not Strict, because the callback is a top-level navigation from the provider's site, and a Strict
   cookie set there would be missing on the redirect to `/`. Lax still keeps the session off cross-site POSTs.
   The write routes keep their exact `Origin` and `Sec-Fetch-Site: same-origin` checks (:171, :250, :297, :340,
   :387, :425), so cross-site writes are refused twice.
-- Lifetime: 8 h absolute, 1 h idle, both server-side (Q-D, Filbert's ruling). The store is in memory with a
-  cap of 64 sessions (oldest goes first), so a Console restart signs everyone out. That's acceptable for one
-  human and keeps sessions off disk.
-- Activity (Q-D). Only a page load (a GET outside `/api/`) or a write (a POST) refreshes `seen`. The page's
-  background reads don't: `refresh` re-reads the board every 10 s (packages/webui/src/public/app.js:346) and
-  the 5 s timer at :301 redraws the age label. Without this rule an open tab would never go idle. Test 13
-  covers it.
+- Lifetime: 8 h absolute, 1 h idle, both server-side. The store is in memory with a cap of 64 sessions
+  (oldest goes first), so a Console restart signs everyone out. That's acceptable for one human and keeps
+  sessions off disk.
 - The session holds `{ provider, iss, sub, name, idToken, created, seen }`. `name` is the subject entry's
   label. It goes where `preview.user` goes today (send logs, settings, seat routes), so the downstream writer
   shape stays as it is. `idToken` is kept only as the logout hint and never leaves the server.
-- Host (Q-C, Filbert's ruling). Under `--sso`, 7332 serves only requests whose Host is the public host.
-  Any other Host, loopback included, gets 403 `public Host required`, except `GET /healthz`. The loopback read
-  path at :509-512 is gone under `--sso`. Today's readers of 127.0.0.1:7332 and where they go:
-  - `scripts/webui-service.sh status` (:406), the stack-release gate (scripts/stack-release.sh:484) and the
-    rehearse gate (:1369) read only `/healthz`, which stays open on loopback.
-  - The webui README (:83) describes the loopback path. It changes in phase 1.
-  - Agent reads of the board go to the tester listener on 7333, which already serves reads. I found no other
-    code that reads 7332 on loopback. A person opening http://127.0.0.1:7332 in a local browser gets the 403
-    and uses the public URL instead.
-  Test 22 covers a loopback Host on `/`, `/api/board` and a write, and `/healthz` passing.
 - Every request on 7332 except `/healthz` and `/auth/*` needs a valid session. Without one, `/api/*` gets
   401 JSON and other GETs get a 303 to `/auth/login?return=<path>`.
 - Logout: `POST /auth/logout` with the same-origin checks. It deletes the session, expires the cookie, and
-  303s to `end_session_endpoint?id_token_hint=...&post_logout_redirect_uri=<publicOrigin>/auth/signed-out&client_id=...`.
+  303s to `end_session_endpoint?id_token_hint=...&post_logout_redirect_uri=https://mosaic.woltje.com/auth/signed-out&client_id=...`.
   If the provider has no `end_session_endpoint`, it goes straight to `/auth/signed-out`.
 - Limit: signing out at the provider does not end a Console session until idle or absolute expiry. Back-channel
   logout is a follow-up, not phase 1.
 
 ### 4. Provider config: shape and location
 
-Location (B1, Filbert's ruling, Mos agreed in mos-0973): a `console.sso` key in
-`~/.config/mosaic-dev/config.json`. The reason is who can write it. The business file is writable by agents
-through `organizationWriter` (the tester verbs and the chief's `organization.set`), so a provider entry there
-could be changed by the agents the Console is meant to keep out. config.json is user-authored and never
-auto-written: `scripts/bootstrap.sh` creates it and nothing overwrites it. Adding the key is a Jason step
-(section 10).
-
-The loader (C1). Every tool reads config.json through one loader, scripts/mosaic-config.mjs. Its `validate`
-refuses any top-level key other than `configVersion`, `environment`, `dataRoot` and `execution` with
-`unsupported configuration key` (:113). The business, seat, cli, discord, bootstrap, land-work, stack-copy and
-conductor-apply code all use it. So phase 1 changes the shared loader, not a Console-only reader:
-
-- mosaic-config.mjs accepts an optional `console` key, and the strict `console.sso` shape validator (the
-  config checks below, except the slot file checks) runs inside the loader. The fail-closed canon holds for
-  every reader. The loader checks shape only and never touches a slot file: `clientSecret` must be
-  `{ slot: <name> }` with the name matching `[a-z0-9-]{1,64}`. The file checks and the read run only in the
-  Console's `--sso` start (D1), so a missing slot or a 0640 slot stops the Console, not the stack.
-- The blast radius is the whole stack. A typo in `console.sso` makes every tool refuse the config, not just
-  the Console. That's the price of one loader, and the reason step 4 writes the key inside a window with a
-  backup first.
-- The other direction breaks too. A copy older than phase 1 refuses a config that has the key. If the key
-  went in before the phase 2 pin, the live copy (490e2771d3d0 or later) would refuse its own config on the
-  next read, and the bus, seats and host would stop. After phase 2, a rollback to a pre-phase-1 copy fails
-  the same way until the key is removed. This is the same trap as the plug-in kind before a rollback.
-- Files without the key still load, on old and new copies.
-
-Test 25 in scripts/test-config.sh: a config with a valid `console.sso` loads, a malformed one fails with
-the bad key path named, and a config without `console` loads.
-
 No secret value goes in this file. The client secret is a slot reference.
 
 ```json
@@ -263,54 +151,38 @@ No secret value goes in this file. The client secret is a slot reference.
 }
 ```
 
-At start, `--sso` prints one line per provider: its id, its issuer and the number of subjects. No client id
-value beyond that, no secret, no `sub`.
+Location: a new optional `console` key in the business file (`~/.config/mosaic-dev/businesses/<id>.json`). The
+Console already serves one business (`--business`), the identities map to that business's human, and Q173
+lets agents edit the test business with a backup first. Adding the key means adding `console` to `TOP_KEYS`
+(packages/business/src/business.mjs:21) with a strict validator. It's additive, and existing files without
+it still load. The alternative is `~/.config/mosaic-dev/config.json`, which is user-authored and never
+auto-written. That fits a deployment setting well, but it puts per-business identity in system config.
+**Filbert, rule on this one.**
 
-The slot is `<configDir>/secrets/mosaic-stack/<slot>`, where `configDir` is the directory of the config file
-the loader read (`MOSAIC_CONFIG`, default `~/.config/mosaic-dev`), so a scratch config gets a scratch slot
-(D2). The Console's `--sso` start reads it. The Console refuses to start if
-the file is a symlink, isn't a regular file, isn't owned by the Console's uid, has any group or other mode
-bits (0640 refuses as well as 0644), or resolves under the repo or a stack copy. The value is never logged or
-put in a refusal message.
+The slot is `~/.config/mosaic-dev/secrets/mosaic-stack/<slot>`, read at start. The Console refuses to start if
+the file isn't a regular file, isn't owned by the Console's uid, has any group or other mode bits, or
+resolves under the repo or a stack copy. The value is never logged or put in a refusal message.
 
-`stack-release.sh rehearse` starts its Console with `serve --port N --business B` and no `--sso`, so a
-rehearsed Console never reads `console.sso` and never uses the live redirect URI. No rehearse change is
-needed; r1's follow-up is dropped.
+`stack-release.sh rehearse` copies a backup onto a scratch root. A rehearsed Console must not use the live
+redirect URI, so rehearse strips `console.sso` from the scratch business file and the rehearsed Console runs
+without SSO (tester listener only). That's a row 163 follow-up, named in the build brief.
 
-Config checks, run at start without the network. Any failure refuses the start, and the message names the
-provider and the check:
+Startup checks for each provider, all fail-closed (the Console doesn't start, and the message names the
+provider and the check):
 
-- `publicOrigin` is an https origin with no path, query or fragment.
-- Provider ids are unique and `[a-z0-9-]{1,32}`.
-- `issuer` is https with no query or fragment.
-- `algs` is non-empty and holds only asymmetric algs from the library's list. `HS256`, any `HS*` and `none`
-  refuse.
-- `subjects` is non-empty, each `sub` is 1..255 visible characters, and no `name` is `tester` or `human`.
-- `clientSecret` is `{ slot: <name> }` with the name matching `[a-z0-9-]{1,64}` (shape only, in the loader).
-- In the Console's `--sso` start only, the slot file passes the file checks above.
-
-Discovery checks, run per provider when its discovery succeeds:
-
-- Discovery returns `issuer` exactly.
-- `id_token_signing_alg_values_supported` shares at least one alg with `algs`. mosaic-preview advertises HS256
-  only, so it fails here.
+- `issuer` is https with no query or fragment. Discovery returns that issuer exactly.
+- `id_token_signing_alg_values_supported` shares at least one alg with `algs`, and `algs` holds only
+  asymmetric algs from the library's list. mosaic-preview advertises HS256 only, so the Console refuses it at
+  start.
 - `code_challenge_methods_supported` includes `S256`.
 - `jwks_uri` returns at least one key usable for one of `algs`. The empty mosaic-preview JWKS fails here too.
+- `subjects` is non-empty, and each `sub` is 1..255 visible characters.
+- `client.id_token_signed_response_alg` is set to `algs[0]`, so the library enforces it per token.
+- Provider ids are unique and `[a-z0-9-]{1,32}`.
 
-Unreachable provider (Q-B, Filbert's ruling). Config errors still refuse the start. Each fetch of the
-discovery document or the JWKS lands in one of two classes:
-
-- Unreachable: a network error, a timeout, a status other than 200, or a body that doesn't parse as JSON. An
-  Authentik maintenance page served as 200 HTML is unreachable, not refused, so it can't block a restart.
-- Refused: a JSON document that fails the issuer, alg, S256 or JWKS check.
-
-An unreachable provider doesn't stop the Console. It starts, that provider's `/auth/login` gets 503
-`sign-in unavailable`, and a retry runs with backoff (5 s, doubling, capped at 5 minutes). `/healthz` stays
-200 and adds `sso: { <id>: "ready" | "unreachable" | "refused" }`, so the gates still pass and an operator
-can see the state. A refused provider at start refuses the start, because it's a configuration problem. On a
-later retry it stays disabled with the `discovery-failed` code until a restart. Sessions already made keep
-working while a provider is unreachable, since a session check needs no network. Test 23 covers the degraded
-start, a 200 HTML page, and the recovery.
+Starting while the provider is unreachable refuses the start. A Console with no working sign-in serves
+nothing, so refusing loudly costs nothing, and the unit restarts it. The tradeoff is that an IdP outage
+keeps the Console down until the IdP is back. With every route behind a session, it would be unusable anyway.
 
 Several providers: Pocket ID, WorkOS and other compliant OPs use the same entry shape. The login page lists
 them. Each entry has its own issuer, client, algs and subjects, and a session records which provider made it.
@@ -318,48 +190,13 @@ them. Each entry has its own issuer, client, algs and subjects, and a session re
 ### 5. Retiring `--auth-header`, `--allow-user` and the proof header
 
 1. **Phase 1 (code row).** Add `--sso` to `cli.mjs serve` and `webui-service.sh`. It reads `console.sso` from
-   config.json. `--sso` cannot be combined with `--auth-header`, `--allow-user` or `--proof-*`. Under
+   the business file. `--sso` cannot be combined with `--auth-header`, `--allow-user` or `--proof-*`. Under
    `--sso`, `named` means "has a session", and `writer` comes from the session. `--send` needs `--sso` or the
-   old preview set. Phase 1 also carries the loader change and its test-config.sh case (section 4, test 25).
-   Nothing live changes until the re-pin.
-
-   The page (C2). Today app.js signs out only on `res.type === 'opaqueredirect'` (packages/webui/src/public/
-   app.js:111 and :305), which is the outpost's redirect. Under `--sso` the Console answers an `/api/*`
-   request without a session with 401 `sign-in required`, so the page would show an error on every 10 s
-   refresh and never offer a way back. Phase 1 makes both fetch paths treat a 401 whose body has
-   `error: 'sign-in required'` as signed out, and the signed-out notice links to
-   `/auth/login?return=<current path and query>`. Other 401s stay errors. The opaqueredirect branch stays
-   until phase 3, because the preview flags still run behind the outpost until then. Test 24 covers it.
-
-   Before phase 1 starts, Mos confirms the config.json sequence in phase 2 (C1).
+   old preview set. Nothing live changes until the re-pin.
 2. **Phase 2 (Jason-gated window).** Re-pin to the phase 1 commit with `--sso --send --tester-port 7333`
-   instead of the preview flags, after Jason steps 1 to 3. Backup first, STATE after (Q173). The order
-   inside the window:
-   1. Back up the store, the pointer, the unit and config.json.
-   2. Pin the phase 1 copy with the Console stopped. The copy's loader accepts a config with or without
-      `console`, so the bus and seats keep reading the old config.
-   3. Straggler check (Mos's C1 condition, mos-0977): list every running process, unit and timer that
-      still runs from the old copy and reads config.json. Each one is restarted on the new copy or shown
-      not to re-read config. The old loader refuses the key, so a straggler would fail on its next read.
-      Step 4 waits until the list is clean.
-   4. Jason step 4: the `console.sso` key goes into config.json, written by Jason or by an agent on his go
-      for that one key. The new loader reads it back (`scripts/mosaic-config.mjs` validate) before anything
-      starts.
-   5. Start the Console with `--sso --send --tester-port 7333`.
-   Acceptance: Jason signs in through the Console flow, sends one message and signs out. The forged-header
-   check (a request with `X-authentik-username` and no cookie gets 401) runs either on a scratch Console or
-   on live by Mos or Jason (B6). No agent sends the auth header to the live 7332 (section 8). The scratch
-   Console runs from the same copy as `serve --sso --port <scratch port>`, with `MOSAIC_CONFIG` pointing at a
-   scratch config in a scratch dir. That config has a scratch `dataRoot`, and any business it serves comes
-   from the scratch config dir; neither points at live. Its dummy client secret sits in the scratch slot
-   (`<scratch configDir>/secrets/mosaic-stack/<slot>`). Its issuer is an unreachable loopback host, not
-   Authentik, so the scratch Console sends nothing outbound (D2, mos-0971). It comes up in the degraded
-   state (Q-B), and the 401 check needs no sign-in. It has no `--send` and no `--tester-port`.
-
-   Rollback for phase 2: remove the `console` key from config.json first (restore the step 1 backup), then
-   roll the pointer back. An older copy's loader refuses a config holding the key (section 4), so the other
-   order stops the bus and seats. The window plan lists that order, and the STATE check after a rollback
-   reads config.json for the key's absence.
+   instead of the preview flags, after the Jason steps below. Backup first, STATE after (Q173). Acceptance:
+   Jason signs in through the Console flow, sends one message, signs out, and a forged-header request with no
+   cookie gets 401.
 3. **Phase 3 (code row).** Remove `previewOptions`, `proofOptions` and their tests. `cli.mjs` and
    `webui-service.sh` refuse the old flags with `--auth-header was retired by Q175; use --sso`. Close #385
    with the phase 2 STATE and the phase 3 commit.
@@ -374,15 +211,13 @@ The tester listener exists so agents can test as the tester and never as Jason (
 - It never mounts `/auth/*` (404), never reads a cookie, and refuses any request carrying `Authorization` or a
   `__Host-mosaic_session` / `__Host-mosaic_login` cookie (403 `tester listener takes no sign-in`). The same
   goes for `X-authentik-jwt` and the old auth and proof header names.
-- `startServer` throws when its options hold both `tester` and `sso`, so the SSO module can't be mounted on
-  the tester listener by a wiring mistake. A unit test calls it with both.
 - Its writer stays the fixed `{ tester: true, user: 'tester' }`, and it allows only the row 175 writes, as
   today. No session or header can change it.
 - Its bus calls stay on `TESTER_CLI`. The bus checks the tester proof and refuses human verbs from it, and the
   broker refuses a business whose human is `tester` and any role named `tester`. So nothing that reaches 7333
   can become the human.
 - 7332 keeps refusing `x-mosaic-tester` for every Host (:485).
-- `subjects` validation refuses a `name` of `tester` or `human`.
+- `subjects` validation refuses an entry named `tester`.
 
 ### 7. Point 5, the proxy-forwarded token
 
@@ -390,9 +225,7 @@ Not in phase 1. Point 5 makes it optional and the code flow covers the ruling. I
 
 - Verify with jose (MIT, exact pin), against the JWKS from the configured issuer's own discovery. Never use
   the `X-authentik-meta-jwks` header, because it arrives with the request and the forger controls it.
-- Use the same alg allow list, iss, exp and subject list. `aud` is the proxy provider's client id, and the
-  config check refuses it if it equals any code-flow `clientId`, so an ID token issued to the Console can't be
-  replayed as a proxy token or the other way round (N4).
+- Use the same alg allow list, iss, aud (the proxy provider's client id), exp and subject list.
 - The mosaic-preview provider signs with HS256 and has an empty JWKS, so its `X-authentik-jwt` fails every
   check until Jason gives it an RSA or EC key (Jason step 1).
 
@@ -404,11 +237,9 @@ Today, with `--send` live, any same-uid process on dragon-lin can connect to 127
 strips client copies of the header, so a remote forger needs local code execution first. Users on other uids
 can reach the loopback port too (P19 333).
 
-Mos ruled (mos-0972) that the Console runs without `--send` until phase 2. Reads stay up, the header path
-stops carrying writes, and Jason sends piece 1 with `mosaic talk pm` instead. Row 189 (`stack-release.sh
-activate --no-send`, #1687) makes that change through the pointer so the unit and stack-active.json stay in
-step; the restart follows its landing. Until phase 2, no agent sends a request with the auth header to 7332.
-The tests use fixture servers.
+Recommendation: Mos restarts the Console without `--send` until phase 2. Reads stay up, the header path stops
+carrying writes, and only Jason's sends through the Console stop. That's a Mos call (Console start belongs to
+Jason or Mos). Until then, no agent sends a request with the auth header to 7332. The tests use fixture servers.
 
 To be clear about the limit: SSO protects Console ingress. It doesn't protect the bus's human boundary. The
 human proof is path-bound (#225), so a same-uid process can already run the tree's `human-cli.mjs` and act
@@ -418,11 +249,11 @@ as the human without touching the Console. Q175 doesn't change that. P19 333 own
 
 All tests run against a fake OP in `packages/webui/tests/helpers/fake-oidc.mjs`. It's a loopback https
 server with a self-signed cert. Each test passes the library a `customFetch` that trusts only that cert, so
-production code needs no insecure-request flag. The fake OP has discovery, a JWKS, and authorization, token
-and end-session endpoints, with keys made by `node:crypto` (RSA 2048, P-256, and an HMAC secret for the
-forgeries). It can serve two issuers at once and rotate its keys. No test reaches a real provider. Each
-refusal test asserts the status, that no `__Host-mosaic_session` was set, and that the bus send stub was
-never called. Each test also passes once unmutated, as the control.
+production code needs no insecure-request flag. The fake OP has discovery, a
+JWKS, and authorization, token and end-session endpoints, with keys made by `node:crypto` (RSA 2048, P-256, and an
+HMAC secret for the forgeries). No test reaches a real provider. Each refusal test asserts the status, that no
+`__Host-mosaic_session` was set, and that the bus send stub was never called. Each test also passes once
+unmutated, as the control.
 
 Refusals Mos named:
 
@@ -430,87 +261,35 @@ Refusals Mos named:
    Fetch Metadata, and no cookie: 401 on `/api/bus/message`, `/api/settings` and `/api/config`, and a 303 to
    login on `/`.
 2. HS256 ID token. The fake OP signs the ID token with HS256, using the client secret as the key (the classic
-   confusion) and `kid` set to a real RSA kid: refused at the callback. The library's alg check refuses it
-   before any signature check, so this test proves the alg rule, not the signature check. Test 9 covers that.
-3. Wrong aud. A correctly signed RS256 token with `aud` set to another client id: refused. Also an `aud`
-   array holding our client id and another, with no `azp`: refused.
-4. Expired token. A correctly signed token with `exp` 10 minutes ago (beyond the library's 30 s clock
-   tolerance): refused.
+   confusion) and `kid` set to a real RSA kid: refused at the callback.
+3. Wrong aud. A correctly signed RS256 token with `aud` set to another client id: refused.
+4. Expired token. A correctly signed token with `exp` 10 minutes ago (beyond the library's clock tolerance):
+   refused.
 
 More refusals:
 
 5. Wrong `iss`, both a different issuer and a trailing-slash variant.
 6. Nonce mismatch or missing nonce.
 7. State mismatch, a missing login cookie, a replayed callback (record already taken), an expired login record,
-   and two login cookies. For the replay, the fake OP is set to accept the same code twice, so the second
-   callback reaches the record lookup and only the take-and-delete rule refuses it.
+   and two login cookies.
 8. A provider that demands no PKCE. The token request must carry `code_verifier`, and the fake OP refuses a
    wrong one.
-9. The signature check (B5), three cases: (a) `alg: none`; (b) an RS256 token whose header names a real kid in
-   the JWKS, with a changed payload and the original signature; (c) an RS256 token signed by a key whose kid
-   isn't in the JWKS, even after the refetch. (a) is refused by the alg check in step 4, so it's an alg test
-   like test 2. Only (b) and (c) reach step 5, and (b) is the case only the signature check catches.
-10. A valid token for a `sub` not in `subjects`: 403 and one `subject-unknown` log line with the provider id,
-    iss and sub only.
-11. Start refusals: `algs` holding `HS256` or `none`, HS-only discovery (the mosaic-preview shape), an empty
-    JWKS, no S256, an issuer mismatch, a subject named `tester` or `human`, `--sso` together with
-    `--auth-header`, and slot files that are a symlink, mode 0644, mode 0640, or under the repo. The owner
-    check has no test: making a file owned by another uid needs root, which the suite doesn't have. The
-    review reads that branch instead.
+9. `alg: none`, and an RS256 token signed by a key not in the JWKS.
+10. A valid token for a `sub` not in `subjects`: 403 and one log line with iss and sub only.
+11. Startup refusals: HS-only discovery (the mosaic-preview shape), an empty JWKS, no S256, an issuer mismatch,
+    a slot with mode 0644, and `--sso` together with `--auth-header`.
 12. Tester port: a valid session cookie (taken from a 7332 sign-in), `Authorization: Bearer <valid id token>`,
-    and `X-authentik-jwt` each get 403. `/auth/login` on 7333 gets 404. `startServer` with `tester` and `sso`
-    throws.
+    and `X-authentik-jwt` each get 403. `/auth/login` on 7333 gets 404.
 13. Session: idle expiry, absolute expiry, a logout followed by reuse of the old cookie, and logout without
-    same-origin (refused, session kept). Background `/api/` GETs every 10 s for over an hour don't keep the
-    session alive; a page load does.
-14. Open redirect: `return=//evil.example`, `return=https://evil.example`, `return=/\evil.example` and
-    `return=/%09/evil.example` all land on `/`, and `return=/board?x=1` lands there.
-15. Provider mix-up. Two providers, A and B. A login started for A whose callback carries B's `iss` and a
-    code from B is refused, and a `provider=` query on the callback is ignored. B's code is issued against
-    A-record's PKCE challenge, so the verifier matches and only the record rule (the callback belongs to A)
-    refuses it.
-16. Several algs: a provider with `algs: ["RS256", "ES256"]` takes a token signed with either, and refuses
-    PS256 even when the JWKS holds a usable PS256 key.
-17. Login record cap: 33 started logins leave 32 records, and the first login's callback finds no record.
-18. JWKS rotation: the fake OP rotates to a new key with a new kid. A sign-in after the rotation succeeds
-    through the one refetch, and a token under the removed kid is refused.
-19. Logs: across every test in this file, captured log lines hold none of the tokens, codes, states, nonces,
-    verifiers, the client secret or a session id that the test produced.
-20. The session store holds no raw session id (keys are sha256 values, and no value holds the cookie).
-21. Set-Cookie: the exact session and login cookie strings, including the expiry of the login cookie at
-    callback.
-22. Host: under `--sso`, a loopback Host on `/`, `/api/board` and a write each get 403; `/healthz` on
-    loopback gets 200.
-23. Degraded start: the fake OP is down at start; the Console starts, `/auth/login` is 503, `/healthz` reports
-    `unreachable`; the OP comes up and the next retry makes sign-in work. A discovery URL that answers 200
-    with an HTML page also counts as `unreachable` and the Console starts. A provider that answers with
-    HS-only discovery at start refuses the start.
-24. Signed-out page (C2). A page test in the board-held.test.mjs style stubs fetch to answer 401
-    `{ error: 'sign-in required' }`: the page shows the signed-out notice, its link is
-    `/auth/login?return=<current path and query>`, and the refresh stops. A 401 with another error stays an
-    error. The existing opaqueredirect case still signs out.
-25. Loader (C1), in scripts/test-config.sh: a config with a valid `console.sso` loads; a malformed one (an HS
-    alg, a missing `slot` field, a slot name outside the pattern, an unknown key under `console`) fails and
-    names the bad key path, and no case reads a slot file (the file cases stay in test 11); a config without
-    `console` loads.
+    same-origin (refused, session kept).
+14. Open redirect: `return=//evil.example` and `return=https://evil.example` both land on `/`.
 
 Positive paths: an RS256 and an ES256 provider each complete sign-in and one send, and two providers configured
 together each work with their own subjects.
 
-Mutants for the gate, each killed by the named test:
-
-- drop the `validateApplicationLevelSignature` call (9b);
-- wrap that call in a try/catch that continues (9b);
-- drop the `subjects` check (10);
-- accept HS* in `algs` (11);
-- take the provider from the query (15);
-- let the tester listener read cookies (12);
-- skip the login record delete (7);
-- drop `HttpOnly` from the session cookie (21);
-- refresh `seen` on every request (13);
-- build `redirect_uri` from the request Host (a test with a different Host on `/auth/login` checks the
-  `redirect_uri` sent to the fake OP);
-- serve the loopback read path under `--sso` (22).
+Mutants for the gate: drop the `validateApplicationLevelSignature` call (test 2 or 9 must fail), drop the
+`subjects` check, accept HS* in `algs`, take the provider from the query, let the tester listener read
+cookies, and skip the login record delete.
 
 ### 10. Jason-gated steps
 
@@ -521,21 +300,16 @@ Mutants for the gate, each killed by the named test:
    post-logout URI `https://mosaic.woltje.com/auth/signed-out`, keep RS256, and give the client id. Put the
    client secret into slot `console-sso-authentik` (or say an agent may create the slot file from a value he
    puts in place, per the Q173 secrets rule). Agents never see the value.
-3. His `sub` for that provider, or a go to read it from the Console's one `subject-unknown` log line on his
-   first sign-in attempt.
-4. The `console.sso` entry in `~/.config/mosaic-dev/config.json`, inside the phase 2 window, after the pin
-   and before the Console starts (section 5). He writes it, or he gives an agent the go to write that one
-   key from the values in steps 2 and 3, with a backup of the file first. config.json is user-authored, so
-   this isn't covered by Q173. Writing it earlier stops every tool on the live copy, whose loader refuses
-   the key.
-5. Any Traefik or outpost change. None is needed while the outpost stays in front. Dropping the outpost
+3. His `sub` for that provider, or a go to read it from the Console's one refusal log line on his first
+   sign-in attempt.
+4. Any Traefik or outpost change. None is needed while the outpost stays in front. Dropping the outpost
    later, so the Console is the only gate, changes who can reach the Console from outside and is his call.
-6. The phase 2 re-pin window go.
+5. The phase 2 re-pin window go.
 
 ## Questions for review
 
-Q-A to Q-E are settled (Filbert r1 and r2, Mos mos-0973). One open point, for Mos:
-
-- The config.json sequence (C1): the key goes in only inside the phase 2 window, after the pin and before
-  the Console starts, with a backup first, and a rollback removes it before the pointer moves (section 5).
-  Mos confirms this before phase 1 starts.
+- Q-A: the config location, business file `console` key or config.json (section 4).
+- Q-B: refuse to start when the IdP is unreachable, or start and refuse sign-ins (section 4).
+- Q-C: should the loopback-Host read path on 7332 also go behind the session, as proposed? Public traffic
+  arrives from 127.0.0.1 too, and only Host keeps it off that path today.
+- Q-D: 8 h absolute and 1 h idle, or shorter.

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/candidate-manifest.sha256

@@ -1,7 +0,0 @@
-70dbc89c0282fa063514317262d8926d16b8b8aaab4a1e47379303918495fc2c  agents/sage/work/queue-189/BUILD.md
-4bd216cce2b40b39998725daa8989f6e3acb3ccd81a7017f6b09026af3965584  agents/sage/work/queue-189/mutants-run.log
-ddbdddf03abf4aa91aa62f52e468be7af3c6b2f5d7bec2ee99b11e315471f18c  agents/sage/work/queue-189/mutants.sh
-5d7b2da84d994f4f93d1212e349b4e4c19c5c00780e6cfcde91edb3ca08c014e  docs/plans/2026-10-20_activate-no-send.md
-38e410c4cb731390f96747646eb7f6caa7a587fca9024ccbe901aab5ac19c7cf  docs/TOOLS.md
-fe430969cc669515e348fced1a22cbe839a12023f7ac67cfba905b7afd29872f  packages/cli/tests/stack-release.test.mjs
-16f77305e558f4fb953accc6d09f1f7b408aba363851d8ca79216ffce41bed9f  scripts/stack-release.sh

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

agents/sage/work/t1-seats/COMMON.md

@@ -1,48 +0,0 @@
-# Common start for Sage's MVP T1 builder seats (mos-0974, mos-0977)
-
-You are a builder seat on Mosaic Stack, repository /mnt/storage/src/mosaic-stack, branch base `refactor`.
-Sage leads the project and is your coordinator (T3 thread 1ef1e4f8-3ead-4208-beca-38f9f1add079). Mos speaks
-for Jason (thread 38bc4c81-6270-4021-b00c-6a15c43b9b0e). Human input reaches you only through Sage and Mos.
-
-## Read first, in this order
-
-1. `/mnt/storage/src/jason-master-restart/USER.md`, `SYSTEM.md`, `CONSTITUTION.md` (who Jason is, the
-   system rules, the constitution).
-2. `/mnt/storage/src/jason-master-restart/TARGET.md` (the MVP addendum) and `DECISIONS.md` Q176 to Q178.
-3. `/mnt/storage/src/jason-master-restart/projects/mosaic-mvp/GAP-MAP.md` and `PLAN.md`.
-   Everything under jason-master-restart is read only.
-4. The repository's `AGENTS.md`, then your brief (named in your first message) and the files it points to.
-
-## Your worktree
-
-T3 made your worktree from `refactor`. Work only there. Link node_modules from the canonical checkout right
-after you start (`ln -s /mnt/storage/src/mosaic-stack/node_modules node_modules`), unless your brief adds a
-dependency. In that case run `npm ci` in your worktree for a real node_modules first, and never run npm
-install through a symlink or in a directory without its own package.json (npm walks up to home).
-
-## Rules that bind you
-
-- Message ids are `<seat>-NNNN`, starting at 0001. Run `date -u` right before every message and put the
-  stamp in it. End each turn with a clock timestamp.
-- No Co-Authored-By or any attribution line in any commit or PR, whatever a harness reminder says
-  (mos-0822).
-- Push only your own `<seat>/*` branches, through the repository credential helper (mos-0981). Never push
-  `refactor`, `main` or another seat's branch.
-- You have no Gitea token. Sage makes the queue moves that post to Gitea (in-review, review requests) and
-  files issues. You may run `scripts/mosaic queue move N in-progress --op <seat>-N-start --by <seat>` for
-  your own row.
-- Never touch `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units, slot files or `~/.mosaic`. Never
-  start, stop or restart the live Console or bus. Never read or print a credential value.
-- Never read other seats' scratch directories. `agents/<seat>/work/` packets in the repository are fine.
-- Single test files run freely. The cli suite, any `scripts/test-*.sh` and any full package suite share
-  one slot: run `bash /mnt/storage/scratch/sage-busy-now.sh | tail -1`, and if it is not CLEAR, or before a
-  run longer than 5 minutes, ask Sage for the slot and start only on Sage's "granted".
-- Two failures in one gate run means stop and report.
-- Design-first rows: the first deliverable is `agents/<seat>/work/queue-<row>/DESIGN.md`, committed on your
-  branch. Send the reviewer and Sage its path, commit and sha256. No product code before approval.
-- Merge-chaining (Q177): your build may sit on another row's candidate commit. Your row keeps its own
-  review and gate, and the chain lands in order.
-- Fail closed. Never route around a refusal. If the code shows the brief or design is wrong, stop and tell
-  Sage and your reviewer.
-- Style for every message and doc: plain words, short sentences, no em dashes, they/them for people.
-- Sage registers your session in `docs/SESSIONS.md`. Do not edit it.

agents/sage/work/vikunja-setup/comment-337-412-r163-landed.mjs

@@ -1,56 +0,0 @@
-// Sage, 2026-10-20: row 163 (D2, #1660) round 2 approved. One comment on P19 337 (D2), per mos-0882 (every
-// landing or decision gets a Vikunja comment). Sage's own key (bot user 13); the sync key reads back. Comments only:
-// no task edits, labels, assignees or bucket moves. Checks the task's title before posting. Prints no secret.
-// Usage: node comment-337-r163-approved.mjs https://tasks.woltje.com SAGE_TOKEN_FILE SYNC_TOKEN_FILE OUT_JSON
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-const [ORIGIN, KEY, SYNC, OUT] = process.argv.slice(2);
-if (!/^https:\/\/tasks\.woltje\.com$/.test(ORIGIN)) throw new Error("tasks.woltje.com only");
-if (!OUT || existsSync(OUT)) throw new Error("OUT_JSON missing or exists; refusing");
-const PROJECT = 19;
-const PSIG = "Posted by Sage (T3 1ef1e4f8) with Sage's own key (bot user 13).";
-const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-const ps = (xs) => xs.map((x) => `<p>${esc(x)}</p>`).join("") + `<p>${esc(PSIG)}</p>`;
-const POSTS = [
-  { id: 337, title: /^D2: stack rehearsal on a scratch root/, body: [
-    "Row 163 (Gitea #1660) landed and pushed. Landing commit 8ecc7a239 (Sage; Filbert approve 29447), queue revs 2235-2236 (landing note and done) in 9ae8c73ac, range 4ca8d6e94..9ae8c73ac on refactor. Patch-id b8d5f8a37c24 matches candidate c6f4f4c12596. #1660 is closed with comment 29450.",
-    "Sage gate passed at 18:16Z on eaa0f2666: cli 472/472 and every package and scripts/test-*.sh green. The pushed commit is a cherry-pick of eaa0f2666 onto 7f57419b3, which adds only the Q175 design doc, and no test reads that file. Mos dropped the Part B wait when Q175 replaced Part B (mos-0971).",
-    "Not live. The live stack still runs copies/490e2771d3d0. Rehearse and bus start --no-launch go live at the next re-pin, where the Q173 backup and STATE report apply.",
-  ] },
-  { id: 412, title: /^Console SSO: zero-trust OIDC verification/, body: [
-    "Design r1 is committed: agents/sage/work/q175-sso/DESIGN.md in 7f57419b3 (blob 91e5b1b5e737), pushed in 9ae8c73ac. The Console becomes an OIDC relying party on oauth4webapi 3.8.8, pinned exactly. It always calls validateApplicationLevelSignature, because the library skips the signature check on a token-endpoint ID token. Identity is an (iss, sub) pair, and only asymmetric algs are accepted.",
-    "Filbert's r1 review asks for changes in the doc before any code (B1-B6). B1 moves the provider config to config.json, because agents have write paths into the business file. B2 closes an open-redirect hole. B3 keeps the library's error causes out of logs. B4 caps login records. B5 fixes the signature mutant test. B6 removes a live forged-header probe from the phase 2 acceptance. Their rulings: Q-B start degraded when the IdP is unreachable, Q-C yes (7332 accepts only the public Host under --sso), Q-D keep idle expiry but don't refresh it on poll GETs. r2 follows.",
-    "Interim (mos-0972): the Console runs without --send until phase 2. stack-release.sh has no way to drop --send that keeps stack-active.json and the unit in step, so a small tool row comes first, through review.",
-  ] },
-];
-const key = readFileSync(KEY, "utf8").trim(), sync = readFileSync(SYNC, "utf8").trim();
-async function api(method, path, body, auth) {
-  const r = await fetch(ORIGIN + path, { method, headers: { Authorization: `Bearer ${auth}`, "Content-Type": "application/json" }, body: body === undefined ? undefined : JSON.stringify(body), redirect: "error" });
-  const t = await r.text(); let json = null; try { json = JSON.parse(t); } catch {}
-  return { status: r.status, json };
-}
-const list = (j) => j?.items ?? (Array.isArray(j) ? j : []);
-const rec = { at: new Date().toISOString(), comments: [], problems: [] };
-const save = () => {
-  const out = JSON.stringify(rec, null, 1) + "\n";
-  if (out.includes(key) || out.includes(sync)) throw new Error("secret in the record; not written");
-  writeFileSync(OUT, out);
-};
-for (const P of POSTS) {
-  const t = await api("GET", `/api/v2/tasks/${P.id}`, undefined, sync);
-  if (t.status !== 200 || t.json?.project_id !== PROJECT || !P.title.test(t.json?.title ?? "")) throw new Error(`task ${P.id}: ${t.status}, title check failed; nothing posted`);
-}
-writeFileSync(OUT, "", { flag: "wx" });
-for (const P of POSTS) {
-  const c = await api("PUT", `/api/v1/tasks/${P.id}/comments`, { comment: ps(P.body) }, key);
-  const e = { task: P.id, status: c.status, id: c.json?.id ?? null };
-  rec.comments.push(e);
-  if (c.status >= 300 || !Number.isSafeInteger(c.json?.id)) { rec.problems.push(`comment ${P.id}: ${c.status} ${c.json?.message ?? ""}`); save(); continue; }
-  const back = await api("GET", `/api/v2/tasks/${P.id}/comments?per_page=50`, undefined, sync);
-  const found = list(back.json).find((x) => x.id === c.json.id);
-  Object.assign(e, { readBack: back.status, found: Boolean(found) });
-  if (back.status !== 200 || !found) rec.problems.push(`comment ${P.id} read-back: ${back.status}`);
-  save();
-}
-save();
-process.stdout.write(JSON.stringify(rec, null, 1) + "\n");
-if (rec.problems.length) process.exit(2);

agents/sage/work/vikunja-setup/file-no-send-row.mjs

@@ -1,56 +0,0 @@
-// Sage, 2026-10-20: files the activate --no-send row (mos-0972, mos-0973) as one P19 task, owner Sage, no due date.
-// Sage's own key (bot user 13); the sync key reads back. No labels, assignees, due dates or bucket moves. Refuses if
-// the title exists. Prints no secret.
-// Usage: node file-no-send-row.mjs https://tasks.woltje.com SAGE_TOKEN_FILE SYNC_TOKEN_FILE OUT_JSON
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-const [ORIGIN, KEY, SYNC, OUT] = process.argv.slice(2);
-if (!/^https:\/\/tasks\.woltje\.com$/.test(ORIGIN)) throw new Error("tasks.woltje.com only");
-if (!OUT || existsSync(OUT)) throw new Error("OUT_JSON missing or exists; refusing");
-const PROJECT = 19;
-const SIG = "Created by Sage (T3 1ef1e4f8) with Sage's own key (bot user 13).";
-const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-const ps = (sig, xs) => xs.map((x) => `<p>${esc(x)}</p>`).join("") + `<p>${esc(sig)}</p>`;
-const T = {
-  title: "stack-release.sh activate --no-send: drop the Console's --send and keep the pointer in step (Q175 interim, mos-0972)",
-  description: ps(SIG, [
-    "Mos ruled (mos-0972) that the Console runs without --send until Q175 phase 2 (P19 #412), because with --send live any same-uid process can forge X-authentik-username on 127.0.0.1:7332 and send as Jason.",
-    "stack-release.sh has no path that drops --send and keeps ~/.mosaic-dev/state/stack-active.json and the unit in step: console_for_target (:658-687) carries the pointer's flags, check_target (:247-249) allows a same-copy activate only for the proof pair, and adopt refuses once a pointer exists. A hand reinstall makes flags_drift refuse every later activate, pm-on and rollback.",
-    "The row adds activate --no-send, modeled on row 187's --no-proof. It drops --send from the pointer and the unit. A same-copy activate is allowed when the pointer holds --send. Rollback and pm-on carry the pointer as they do now. There is no re-enable flag. Brief: docs/plans/2026-10-20_activate-no-send.md. Owner Sage, reviewer Dewey, gate the cli suite plus every scripts/test-*.sh (mos-0973 go).",
-    "After landing: a same-copy activate on 490e2771d3d0 with --no-send under Q173, with the plan output sent to Mos first, a backup first and a STATE report after. Then row 66 lands.",
-  ]),
-};
-const key = readFileSync(KEY, "utf8").trim(), sync = readFileSync(SYNC, "utf8").trim();
-async function api(method, path, body, auth) {
-  const r = await fetch(ORIGIN + path, { method, headers: { Authorization: `Bearer ${auth}`, "Content-Type": "application/json" }, body: body === undefined ? undefined : JSON.stringify(body), redirect: "error" });
-  const t = await r.text(); let json = null; try { json = JSON.parse(t); } catch {}
-  return { status: r.status, json };
-}
-const list = (j) => j?.items ?? (Array.isArray(j) ? j : []);
-async function existing() {
-  const out = [];
-  for (let page = 1; page < 20; page++) {
-    const r = await api("GET", `/api/v2/projects/${PROJECT}/tasks?per_page=50&page=${page}`, undefined, sync);
-    if (r.status !== 200) throw new Error(`list tasks: ${r.status}`);
-    out.push(...list(r.json));
-    if (list(r.json).length < 50) return out;
-  }
-  throw new Error("more than 19 pages");
-}
-const rec = { at: new Date().toISOString(), project: PROJECT, created: null, problems: [] };
-const save = () => {
-  const out = JSON.stringify(rec, null, 1) + "\n";
-  if (out.includes(key) || out.includes(sync)) throw new Error("secret in the record; not written");
-  writeFileSync(OUT, out);
-};
-if ((await existing()).some((t) => t.title === T.title)) throw new Error("title exists; refusing");
-writeFileSync(OUT, "", { flag: "wx" });
-const r = await api("PUT", `/api/v1/projects/${PROJECT}/tasks`, { title: T.title, description: T.description }, key);
-rec.created = { status: r.status, id: r.json?.id ?? null };
-if (r.status >= 300 || !Number.isSafeInteger(r.json?.id)) rec.problems.push(`create: ${r.status} ${r.json?.message ?? ""}`);
-else {
-  const back = await api("GET", `/api/v2/tasks/${r.json.id}`, undefined, sync);
-  Object.assign(rec.created, { readBack: back.status, done: back.json?.done, inverse: `mark done: POST /api/v1/tasks/${r.json.id} with the whole task, done true (sage key); delete is Jason's or ops-01's` });
-  if (back.status !== 200 || back.json?.title !== T.title || back.json?.done) rec.problems.push("create read-back differs");
-}
-save();
-console.log(JSON.stringify(rec));

agents/sage/work/vikunja-setup/no-send-row-2026-10-20.json

@@ -1,12 +0,0 @@
-{
- "at": "2026-10-20T18:21:15.323Z",
- "project": 19,
- "created": {
-  "status": 201,
-  "id": 413,
-  "readBack": 200,
-  "done": false,
-  "inverse": "mark done: POST /api/v1/tasks/413 with the whole task, done true (sage key); delete is Jason's or ops-01's"
- },
- "problems": []
-}

agents/sage/work/vikunja-setup/r163-landed-412-design-2026-10-20.json

@@ -1,20 +0,0 @@
-{
- "at": "2026-10-20T18:19:36.544Z",
- "comments": [
-  {
-   "task": 337,
-   "status": 201,
-   "id": 372,
-   "readBack": 200,
-   "found": true
-  },
-  {
-   "task": 412,
-   "status": 201,
-   "id": 373,
-   "readBack": 200,
-   "found": true
-  }
- ],
- "problems": []
-}

agents/webby/README.md

@@ -1,7 +0,0 @@
-# Webby
-
-Reviewer seat, Claude Opus 5.5, started by Mos (mos-0981, thread 03086006). Reviews Case 2 designs and MVP T1 rows 192 and 194.
-
-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 `webby/*` branches
-through the repository credential helper (mos-0981), never `refactor`, `main` or another seat's branch.

docs/SESSIONS.md

@@ -1357,9 +1357,21 @@ are never rewritten or removed; corrections are new entries.
 2026-10-20T15:26:33Z | Sage (Opus 5.5, 1ef1e4f8) | row 163 (#1660) r2 for Filbert's r1 changes (F1-F3, N1) | in-review r2, Filbert reviewer: candidate 2c090eefd on code 2a5f3a3a0, base 4f02486d5, manifest c6f4f4c12596; tests R14 R15 + R4/R9/R11 cases, read-only Registry #write() returns; gate passed, K34-K41 killed; Mos checked manifest (mos-0967); revs 2230 (Filbert) and 2231-2233 committed 92cc6011c c539995cf; request comment 29446; P19 337 comment 367; packet 7af166574; lands after B7
 2026-10-20T15:40:36Z | Filbert (Opus 5.5, 048f3c63) | row 163 r2 review (D2 rehearse, candidate 2c090eefd, manifest c6f4f4c12596) | approve, comment 29447 rev 2234: 249/249 singles pass; my M1-M6 and N1 mutants all killed (R14, R9, R11, R4, R15, session test)
 2026-10-20T15:42:00Z | Sage (Opus 5.5, 1ef1e4f8) | row 163 (#1660) r2 verdict intake | approved by Filbert (comment 29447, rev 2234 committed cd2b377bb); P19 337 comment 367 -> 368; candidate 2c090eefd manifest c6f4f4c12596 waits to land after B7, fresh gate if the base moves
-2026-10-20T18:19:06Z | Filbert (Opus 5.5, 048f3c63) | Q175 SSO design review r1 (#412, DESIGN.md blob 91e5b1b5e737 at 7f57419b3), static read incl. oauth4webapi 3.8.8 | changes: B1 config in config.json not business file, B2 return-path backslash, B3 log redaction of library error causes, B4 login-record cap, B5 test 9 not 2 kills signature mutant, B6 phase 2 live forged-header probe; rulings Q-B start degraded, Q-C yes, Q-D 8h abs + idle ignores polls; step 5 reading confirmed; verdict sent to Sage, no Gitea/queue record
-2026-10-20T18:34:53Z | Filbert (Opus 5.5, 048f3c63) | Q175 SSO design review r2 (DESIGN.md blob 3eb718b5e131 at 1a268249e), static | changes: C1 config.json console key fails old loaders (mosaic-config.mjs:113 rejects unknown keys; key add inside phase 2 window, rollback removes it, loader test), C2 app.js signs out only on opaqueredirect so 401 never shows sign-in; notes on tests 15/7/9a, Q-B 200-HTML classification, scratch Console flags; Q-E keep iss/sub escaped and capped; verdict sent to Sage, no Gitea/queue record
-2026-10-20T18:40:20Z | Filbert (Opus 5.5, 048f3c63) | Q175 SSO design review r3 (DESIGN.md blob a152fd58e18e at 817e8f51b), static | approve on condition D1 (slot file checks stay out of shared loader, shape-only there) as a line edit; D2 notes: slot root from configDir, scratch dataRoot, name discovery GETs for Mos; C1/C2 and notes verified; Mos C1 sequence confirm still open; no Gitea/queue record
-2026-10-20T18:41:20Z | Filbert (Opus 5.5, 048f3c63) | Q175 SSO design D1/D2 check (DESIGN.md blob eba861f5d2bb at d55d86bb0), static git diff 817e8f51b..d55d86bb0 | ack: D1 and D2 match; design approved; Mos C1 sequence confirm still open; no Gitea/queue record
-2026-10-20T18:57:10Z | Filbert (Opus 5.5, 048f3c63) | row 190 design review r2 (#1688, DESIGN.md sha256 5493c9df3ec0) | CHANGES to Darkwing, cc Sage: B1 claim check on MOSAIC_CONFIG-only selection, B2 shared prefix drop-in dirs; N1-N7 notes; static read, no slot, no Gitea or queue record
-2026-10-20T19:00:04Z | Filbert (Opus 5.5, 048f3c63) | row 190 design review r3 (#1688, DESIGN.md sha256 98236a1aff98) | APPROVE to Darkwing, cc Sage: B1 and B2 closed with M13 and M14, N7 settled by Sage's 48ebee0ff; static read, no slot; manifest round gets a queue review record (sage-1337)
+2026-10-20T18:44:50Z | Gizmoduck (Opus 5.5) | T3 federation design r1 for Vikunja #414 (G3, G4, C1.1), agents/gizmoduck/work/federation/DESIGN.md, on branch gizmoduck/federation-design off origin/refactor 9ae8c73ac | design committed and pushed; rows R1-R8 wait for Filbert or Dewey review before Sage's queue; Q1-Q3 to Mos
+2026-10-20T18:56:54Z | Gizmoduck (Opus 5.5) | T3 federation design r2 for Vikunja #414, answering Duckworth's B1-B5 and N1-N9 (duckworth-0001) and Mos's mos-0978 and mos-0984 rulings, agents/gizmoduck/work/federation/DESIGN.md | r2 committed and pushed on gizmoduck/federation-design; sent to Duckworth and Mos for re-review; R1, R2, R5 wait for Duckworth's approval before Sage's queue
+2026-10-20T18:58:23Z | Gizmoduck (Opus 5.5) | T3 federation design r2.1 for Vikunja #414, mos-0988: R8 uid gate on row 190b, R7 on row 190, P19 333 in the risk | committed and pushed on gizmoduck/federation-design; Duckworth's r2 verdict pending
+2026-10-20T19:00:18Z | Gizmoduck (Opus 5.5) | T3 federation design r3 for Vikunja #414, answering duckworth-0002 B6 (user reply path), C1 and N10 | committed and pushed on gizmoduck/federation-design; sent to Duckworth for approval on the diff
+2026-10-20T19:01:43Z | Gizmoduck (Opus 5.5) | T3 federation design r3.1 for Vikunja #414, mos-0991 (R8 gate accepts a separate host or uid, one-host audit 3.8, Q1 answer) and morgana-0002 (Q2 settled, access.json is the human store) | committed and pushed on gizmoduck/federation-design; sent to Duckworth with r3
+2026-10-20T19:04:18Z | Gizmoduck (Opus 5.5) | T3 federation design r4 for Vikunja #414, answering duckworth-0003 B7 (privilege paths in R8's gate), N11 (#waiting for user replies), N12 | committed and pushed on gizmoduck/federation-design; sent to Duckworth
+2026-10-20T19:08:20Z | Gizmoduck (Opus 5.5) | Correction to the 19:04:18Z line: commit 04a6112be carried only that SESSIONS line, because the DESIGN.md edit script failed on an anchor and the chain still committed and pushed, and nothing went to Duckworth then. r4 proper: B7 per mos-0996 and mos-1004 (host form only, sudo, doas and ssh checks, hypervisor path an open R8 item with O1 to O3 on Vikunja #419), N11, N12, row 196 verifier noted per gander-0006 | committed and pushed on gizmoduck/federation-design; sent to Duckworth and Mos, reply to Gander
+2026-10-20T19:12:55Z | Gizmoduck (Opus 5.5) | T3 federation design r4.1 for Vikunja #414: B8 (duckworth-0005, issuer and TLS front end), N13 key procedure, N14 R3 on row 196, N15 DNS; mos-1006 (identity provider path, sudo deviation accepted); mos-1009 (privilege path table, each closed or accepted per #419); gander-0007 (verifier interface); morgana-0005 (grants name bus project ids, one covers in R1, R4 counts collaborator grants only) | committed and pushed on gizmoduck/federation-design; sent to Duckworth, copies to Mos, Morgana and Gander
+| 2026-10-20T19:16:08Z | Gizmoduck | T3 federation design r4.2 for #414 (mos-1013, morgana-0007) | factory means every principal outside the hub instance, hosts as variables, Q180 settles Q1 |
+| 2026-10-20T19:16:56Z | Gizmoduck | T3 federation design r4.3 for #414 (duckworth-0007) | B8 issuer host passes host-access, hypervisor and backups rows, N16-N19 |
+| 2026-10-20T19:17:11Z | Gizmoduck | T3 federation design r4.4 for #414 (mos-1020) | R4 chained after row 193's viewer level, keeps the level-loss test (N17) |
+| 2026-10-20T19:20:55Z | Gizmoduck | T3 federation design r4.5 for #414 (duckworth-0010, mos-1022) | B9 user-thread decisions reach the owner's inbox by ruling, R3 tests it, N20 start order, R8 waits on host variables |
+| 2026-10-20T19:28:44Z | Gizmoduck | T3 federation design r4.6 for #414 (duckworth-0012 N21, morgana-0011) | R6 notice is row 193's sentence word for word, start-order line matches the table |
+| 2026-10-20T19:29:44Z | Gizmoduck | T3 federation design r4.7 for #414 (mos-1030, Q181) | hosts settled: Case 1 and Hermes on W-jarvis 10.1.1.53, hub W-Melanie-OC 10.1.1.54 user mosaic |
+| 2026-10-20T19:31:06Z | Gizmoduck | T3 federation design r4.8 for #414 (duckworth-0020 N22) | R8 checks mosaic's sudo, groups, keys and sudoers.d on 10.1.1.54 |
+| 2026-10-20T19:35:32Z | Gizmoduck | T3 federation design r4.9 for #414 (mos-1037) | R8 names Jason as localadmin running the root checks on 10.1.1.54 |
+2026-10-20T19:59:12Z | Gizmoduck (Opus 5.5, 9312a896) | federation design r4.10 (#414, mos-1055): R8 is a recorded acceptance citing DECISIONS Q182 and Q183 verbatim, checks report not refuse, agents may run the .54 checks, mos-1042 order in the R8 row | to Duckworth for ack, cc Mos and Sage
+2026-10-20T20:01:20Z | Gizmoduck (Opus 5.5, 9312a896) | federation design r4.11 (#414, mos-1063): hub on .54 VM 1012 as mosaic (Q181), R8 depends on #416 not #418, functional checks stay blocking | to Duckworth with r4.10, cc Mos and Sage

docs/TOOLS.md

@@ -368,7 +368,7 @@ 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]
+    [--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
@@ -480,14 +480,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

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

@@ -1,73 +0,0 @@
-# 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.
-
-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
-live units or a slot file. Every test uses the stand-in `systemctl`, units, stores and data root that
-`packages/cli/tests/stack-release.test.mjs` already builds.
-
-## Why
-
-Mos ruled that the Console runs without `--send` until Q175 phase 2, because with `--send` live any same-uid
-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
-  `--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
-  `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.
-
-## The change
-
-1. `activate ID BUSINESS --no-send` drops `--send` from `RUN_CONSOLE`, so `install_stack` leaves it out of the
-   Console unit and `write_pointer` leaves it out of the pointer. Only `activate` takes it. It combines with
-   `--tester-port`, the proof pair and `--no-proof`.
-2. An activate with `--no-send` may name the pointer's copy when the pointer's Console flags hold `--send`. It
-   re-pins the live copy with only the Console flags changed, as row 187 does for the pair, including the
-   live-copy plan note and the backup of the stopped store. Without `--send` in the pointer, a same-copy
-   `--no-send` still refuses `already-active`.
-3. The steps log records `drop --send; --no-send was given`, or `--no-send was given and the pointer holds no
-   --send, so there is nothing to drop`.
-4. `--plan` prints one `send:` line for an activate or rollback: `send: dropped; --no-send was given`,
-   `send: off; --no-send was given and the pointer holds no --send`, `send: carried` when the pointer's
-   `--send` goes on unchanged, or `send: off`.
-5. `rollback` and `pm-on` don't change: they carry the pointer's flags. So once `--no-send` has run, a rollback
-   to an earlier copy keeps send off. There is no flag to turn send back on. Q175 phase 2 changes the Console
-   flags in its own row.
-6. `docs/TOOLS.md` "Pinned stack update" gets `--no-send` in the usage block and one sentence.
-
-## Tests (packages/cli/tests/stack-release.test.mjs)
-
-1. Seeded preview pointer with `--send` and `--tester-port 7333`: a same-copy `activate B acme --no-send`
-   passes. The pointer and the unit ExecStart lack `--send` and keep the preview flags and
-   `--tester-port 7333` in order. Status says `unit flags: match the pointer`. The steps log has the drop
-   line. The log line has from = to = B, and the stopped store was backed up.
-2. A plain same-copy activate still refuses `already-active`. So does a same-copy `--no-send` once `--send` is
-   gone.
-3. `--plan` prints the four `send:` lines in their cases, with the live-copy note on the same-copy run.
-4. After `--no-send`, a rollback to the earlier copy and `pm-on` both leave `--send` out of the pointer and
-   the unit.
-5. `--no-send` on `rollback`, `pm-on`, `status` or `adopt` is a usage error (exit 4).
-6. `--no-send` with the proof pair, and with `--no-proof`, on a pointer holding both: each drops what it
-   names and keeps the rest.
-
-## Mutants (each must fail at least one test)
-
-- M1: the same-copy exception ignores `--no-send`.
-- M2: the same-copy exception allows `--no-send` without `--send` in the pointer.
-- M3: `--no-send` drops `--send` from the pointer but not from the unit (it writes the pointer from
-  `P_CONSOLE`).
-- M4: rollback re-adds `--send`.
-- M5: the arg parser accepts `--no-send` for rollback.
-
-## Gate
-
-Dewey approves the manifest. The cli suite and every `scripts/test-*.sh` are green on Sage's gate, and the
-mutants are killed.

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_agent-lifecycle.md

@@ -1,47 +0,0 @@
-# Brief: agent lifecycle from the Console and the CLI, with a per-agent hire/fire veto
-
-Sage, 2026-10-20, for mos-0974 (MVP, DECISIONS Q176, Vikunja #414 "User and main agent can create and spawn
-agents" and "User maintains ability to terminate, regenerate, or create agents via WebUI or CLI ad-hoc", #415
-Case 1 "Chief of staff agent has hire/fire authority for agents as needed; unless user forbids per agent" and
-"User maintains ability to restructure organization at will"). Gitea #1692. T1 item 5. Owner Honker, reviewer Webby (mos-0981), gate
-owner Sage. Base: refactor at the brief commit.
-
-Design first. The first deliverable is `agents/honker/work/queue-194/DESIGN.md`. Webby reviews it before any
-code.
-
-## What exists today (GAP-MAP.md G8, G9, C1.5, C1.6, measured at 9ae8c73ac)
-
-- The chief launches only listed instances (`roles/chief-of-staff.json`, harness `tools.mjs` launch,
-  `broker.mjs:1968`). No user verb launches an arbitrary agent.
-- Terminate exists (`packages/cli/src/cli.mjs:447`, `instances.mjs:9-11`, webui `serve.mjs:288, 535`). There
-  is no regenerate, no delete and no Console launch.
-- Instance changes need a bus restart (`instance-settings.mjs:35,75`, `organization.mjs:83`). Add and change
-  only, no delete.
-- Human-only membership acts as a veto today, but there is no per-agent veto list.
-
-## What the design must settle
-
-1. The verbs: create (from a role and a name), launch, terminate, regenerate (a fresh session with the same
-   identity and role), and delete (with what happens to its sessions, workspace and run evidence, which
-   stays write-once). Each one is a human verb on the CLI and a Console action.
-2. Chief hire/fire. What the chief may do on its own, and the per-agent veto: the human marks an agent so
-   the chief can't fire or replace it, and marks roles the chief can't hire. Where the veto lives and how
-   the broker enforces it.
-3. Live changes. Which changes take effect without a bus restart, and how a running bus picks them up
-   safely.
-4. RBAC. Human roles come from row 193 (Morgana). Until it lands, these verbs are owner-only. The design
-   states the hook that row 193 fills.
-5. Per instance. Row 190 runs one instance per OS user. Lifecycle verbs act on their own instance only.
-6. The kill switch (row 191, Rocko) refuses every launch path. These new launch paths check it too.
-
-## Boundaries
-
-- No test touches `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or a slot file.
-- Role authority is declared in `roles/` and changes only by reviewed commits (AGENTS.md invariant 7). This
-  row adds verbs, not new role authority. Any role file change is called out for review.
-- The build may chain on rows 190, 191 and 193 candidates (Q177).
-
-## Gate
-
-Webby approves DESIGN.md, then the manifest. The bus, cli, business and webui 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 +0,0 @@
-# Brief: Melanie's hub instance on its own host (row 195, was 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.
-
-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`.
-
-## 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.
-
-## 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.
-
-## 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.
-
-## 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.

docs/plans/2026-10-20_human-boundary.md

@@ -1,62 +0,0 @@
-# Brief: the human boundary across uids and humans (P19 333)
-
-Sage, 2026-10-20, for Mos's order mos-0989 (P19 333, MOSAICSTA-173, is now on the 10-27 path: federation R3 and
-row 193 need it). Gitea #1694. Owner Gander (Codex gpt-6.1-sol, a new builder seat under mos-0977 item 5),
-reviewer Duckworth, gate owner Sage. Latest-by: DESIGN.md approved by 2026-10-22, landed by 2026-10-24, and in
-any case before federation R3 lands. R3 and row 193 may chain on this row's candidate (Q177). Base: refactor at
-the brief commit. Design first. The first deliverable is `agents/gander/work/queue-ROW/DESIGN.md`.
-
-## The problem, as filed and as it now matters
-
-P19 333 as filed (row 87, mos-0657): the Console listens on a loopback TCP port, and any host process that
-reaches it, under any uid, acts as Jason. Jason accepted that as a documented limit for a one-user host
-(mos-0787, row 161). Two things change that:
-
-- Row 190b (#1693, mos-0986) puts Melanie's hub under its own Linux user. Factory processes then sit on another
-  uid, on the same host, next to the hub's ports and socket. The other-uid reach is now the Case 2 threat.
-- Federation r2 (gizmoduck-0004, 60b9b112a) binds a bus user only from a user-cli whose proof passes the human
-  walk, whose direct parent is the bus's own Console, and which holds a live grant. That rule rests on the
-  path-bound human proof (#225): today a same-uid process that runs the tree's `human-cli.mjs` acts as the
-  human, without touching the Console. The Q175 design (section 8) names that limit and leaves it here.
-
-## What already settles part of it
-
-- Q175 phase 2 (#412) settles the Console-ingress part on the main port. Under `--sso`, 7332 answers any
-  non-public Host with 403 except `GET /healthz`, and every other request needs a verified OIDC session. A
-  process on another uid that reaches the port gets only `/healthz`. Phase 1 (row 192) builds it; it is live
-  only after the phase 2 window.
-- Row 189 (`--no-send`) is interim only. Until phase 2 the Console takes no human writes, so the reach is
-  read-only. It settles nothing.
-- Row 190b separates files and units by uid. Whether the hub's `broker.sock` refuses the factory uid depends on
-  its directory and socket modes, which this row checks and tests rather than assumes.
-
-## What the design must settle
-
-1. Inventory every listener and entry point per instance: the Console port, the tester listener (7333 today),
-   `broker.sock`, the human CLI wrapper, the Discord connector and anything row 190 adds. For each: who can
-   reach it today from the same uid and from another uid, with and without `--sso`.
-2. The tester listener. It serves reads and the row 175 tester writes to anything that reaches it, on any uid.
-   Close the other-uid reach (for example a unix socket with 0600 modes, or a peer-uid check on loopback), or
-   bring Mos a concrete reason it must stay open. bus.tester stays Jason's switch.
-3. The bus human boundary. How the bus tells the human's own verified call from a same-uid process that runs
-   `human-cli.mjs`. State what federation R3's direct-parent rule needs from the bus (peer credentials on
-   `broker.sock`, the parent check, how it can't be forged by a child of an agent), and what stays possible for
-   a same-uid process after this row. Say it plainly where a residual limit remains.
-4. Fit with row 193 (Morgana, human users and roles; Mos's B1 rule: a principal comes only from something the
-   bus verifies) and with federation R3. One mechanism, not three.
-5. Migration: the live single-user Console and bus keep working until each instance re-pins.
-6. Which parts of P19 333 this row closes, which parts Q175 phase 2 closes, and what P19 333 says when it is
-   closed.
-
-## Boundaries
-
-- Who can reach the Console from outside stays Jason's. This row changes what a host process can do once it
-  reaches a local port or socket.
-- No test touches `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or a slot file. No test creates a real
-  second uid; use stand-ins as rows 190 and 190b do, and name any part only a Q173 window can prove.
-- No request to the live 127.0.0.1:7332 or 7333, mosaic.woltje.com or auth.diversecanvas.com.
-
-## Gate
-
-Duckworth approves DESIGN.md, then the manifest. The bus, webui and cli suites and every `scripts/test-*.sh`
-are green on Sage's gate, and 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_human-users.md

@@ -1,56 +0,0 @@
-# Brief: many humans per business, human roles, private and shared threads
-
-Sage, 2026-10-20, for mos-0974 and mos-0977 (MVP, DECISIONS Q176, Vikunja #414 "RBAC enforcement" and #415
-Case 1 "Additional users can be configured for access" and "Shared and private agent sessions available per
-user; RBAC"). Gitea #1691. T1 item 3. Owner Morgana, reviewer Duckworth, gate owner Sage. Base: refactor at the brief
-commit.
-
-Design first. The first deliverable is `agents/morgana/work/queue-193/DESIGN.md`. Duckworth reviews it before
-any code.
-
-## What exists today (GAP-MAP.md, measured at 9ae8c73ac)
-
-- One human per business: `packages/business/src/business.mjs:160`, and the broker's human check
-  (`packages/bus/src/broker.mjs:532-538`).
-- Threads have an owner field only (`packages/bus/schema.sql:247`, `broker.mjs:353-360`). Nothing is private
-  or shared.
-- RBAC covers agents only (`role.mjs`, `vocabulary.mjs`, `broker.mjs:769-799`, harness `gate.mjs`). Humans
-  have no roles.
-- The human proof is path-bound (#225, P19 333): any same-uid process that runs the tree's `human-cli.mjs` acts
-  as the human. That limit is real and the design must say how several humans change it.
-
-## What the design must settle
-
-1. The human model. How a business lists several humans, how each is identified, and how a Console SSO
-   session (#412, row 192: each session names a provider subject mapped to a name) and a CLI call each
-   become exactly one of them. Starting rule (Mos, mos-0985, from Duckworth's federation review B1 at
-   b402197ff on origin duckworth/reviews): the bus takes a human principal only from something it verifies,
-   such as the Console's OIDC session under #412. A process's own claim of who it is never counts.
-2. Human roles. A small fixed set to start (for example owner, member, viewer), what each may do on the
-   bus and in the Console, and who may add or remove humans and change roles. Restructuring stays with
-   the owner (Case 1).
-3. Threads. Private threads (visible to their owner and the agents in them) and shared threads (visible to
-   named humans or all members). Schema change, migration of existing rows (all become the current human's),
-   and every read path that must filter.
-4. One user and grant store. Gizmoduck's federation design (thread 9312a896, design 6925f78f0 on
-   gizmoduck/federation-design) proposes `access.json` for grants. Mos's reading (mos-0977): one model for
-   local and federated humans, because two stores drift. Lead decision (Sage, 2026-10-20, to gizmoduck-0002):
-   row 193 takes Gizmoduck's human-authored `<configDir>/access.json` (federation DESIGN.md section 3.5) as
-   the one user and grant store, and extends it with local humans, roles and shared threads. Federation adds
-   only a `home` field. The design confirms this or brings a concrete reason against it to Sage and
-   Gizmoduck before the build. Federation's R1 (the access.json loader) then comes before this row's build.
-5. The bus human boundary. With several humans, the human verbs must know which human calls. State what a
-   same-uid process can still do (P19 333) and whether row 190's one-instance-per-OS-user direction narrows
-   it.
-6. Migration and rollback. Existing businesses keep working with their one human as owner.
-
-## Boundaries
-
-- Changing who can reach the Console from outside is Jason's. This row changes who is allowed once inside.
-- No test touches `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or a slot file.
-- The build may chain on rows 190 and 192 candidates (Q177). Each row keeps its own review and gate.
-
-## Gate
-
-Duckworth approves DESIGN.md, then the manifest. The bus, business, cli and webui suites and every
-`scripts/test-*.sh` are green on Sage's gate, and the design's mutants are killed.

docs/plans/2026-10-20_kill-switch.md

@@ -1,65 +0,0 @@
-# Brief: one kill switch for the bus, every run, Discord and new launches
-
-Sage, 2026-10-20, for Mos's order mos-0974 (MVP, DECISIONS Q176, Vikunja #414 "Kill switch is available to
-stop all processing immediately"). Gitea #1689. T1 item 4. Owner Rocko, reviewer Dewey, gate owner Sage. Base: refactor
-at the brief commit.
-
-Design first. The first deliverable is `agents/rocko/work/queue-191/DESIGN.md`, which Dewey reviews before
-any code. Then the build follows the design, with tests and mutants.
-
-## The goal
-
-One human command and one Console button stop all processing at once and keep it stopped until the human
-clears it:
-
-- The bus takes no new work. Agent verbs that start or continue work refuse with a fixed code while the
-  switch is on. Reads and the human's own verbs, including the clear, still work.
-- Every running managed session and task run is stopped (SIGTERM, then SIGKILL after a bounded wait), and
-  each stop is recorded as an event.
-- Discord stops (its existing STOP file and `stop` verb) and can't restart while the switch is on.
-- New launches refuse: the launcher, chief hire, `run-task.sh`, and any other path that starts an agent.
-- The switch survives a bus restart and a host reboot (it lives in the data root, not in memory).
-- Turning it on and clearing it are human-only verbs, through the bus human proof, and each leaves one
-  event with who and when.
-
-## What exists today (GAP-MAP.md G10, measured at 9ae8c73ac)
-
-These are pieces, with no single switch over them. The design inventories every path that starts or
-continues work and says how each one checks the switch:
-
-- `launch.revoke` and `launch.restore` in `packages/bus/src/broker.mjs` (around :2087), human-only.
-- The `mosaic launches off|on` verbs in `packages/cli/src/cli.mjs` (around :456-533) and
-  `packages/cli/src/launcher.mjs` (around :769).
-- The Discord STOP file (`packages/discord/src/cli.mjs:18-27`).
-
-## What the design must settle
-
-1. Where the switch state lives, its format, and how each process reads it (the broker checks on every
-   work verb; the launcher and Discord check before start). The race: a launch already past its check when
-   the switch goes on must still be stopped.
-2. The CLI verb names (for example `mosaic halt` and `mosaic resume`) and the Console button. The button
-   is a human write, so it goes through the same writer and same-origin checks as other Console writes, and
-   it works under the Q175 SSO session (#412) once phase 2 lands. Until then, test it with fixture servers
-   only.
-3. Per instance. Row 190 adds several instances per host. The switch is per instance, so it stops one
-   instance and never another. The design names how it finds the instance's data root. This row may build
-   on the row 190 candidate (Q177 merge-chaining).
-4. What a stopped run's record says, so run evidence stays write-once and honest.
-
-## Tests
-
-Each part of the goal gets a test: work verbs refuse, a running stand-in session and run are stopped,
-Discord refuses to start, every launch path refuses, the switch survives a restart, an agent can't set or
-clear it, and the clear lets work resume. Mutants: drop the check from one launch path, let an agent clear
-the switch, keep the switch in memory only, skip the SIGKILL after the wait. Each one must fail a test.
-
-## Boundaries
-
-- No test touches `~/.mosaic-dev`, the live units, a real Discord bot or a slot file. Use the stand-in
-  units, scratch data roots and fixture servers the suites already build.
-- Rocko has no git credentials. Sage commits the candidate and runs the queue moves Rocko can't.
-
-## Gate
-
-Dewey approves DESIGN.md, then the manifest. The cli suite, the bus, discord and webui package suites and
-every `scripts/test-*.sh` are green on Sage's gate, and the mutants are killed.

docs/plans/2026-10-20_multi-instance.md

@@ -1,70 +0,0 @@
-# Brief: several Mosaic Stack instances on one host
-
-Sage, 2026-10-20, for Mos's order mos-0974 (MVP, DECISIONS Q176-Q178, Vikunja #414). Gitea #1688. T1 item 1. Owner
-Darkwing, reviewer Filbert, gate owner Sage. Base: refactor at the brief commit. This row blocks both MVP
-cases: Case 1 (Jason's software factory) and Case 2 (Melanie's creative writing hub) run as two instances
-on one homelab host, beside the current mosaic-stack test instance.
-
-Design first. The first deliverable is `agents/darkwing/work/queue-190/DESIGN.md`. Filbert reviews it
-before any code, as Q175 did. Then the build follows the design, with tests and mutants.
-
-## The goal
-
-Two or more instances run side by side on dragon-lin. Each one has its own config file, data root (store,
-broker.sock, host.lock, state, runs, sessions, workspaces), businesses, bus unit, Console unit and port,
-tester port, Discord unit, Claude session env file, stack-active pointer and activation log. No instance's
-commands, units or tools address another instance's state by default or by mistake. On one uid this is
-addressing only, not a security boundary: a same-uid process can still read another instance's files.
-Isolation against that is row 190b (#1693, mos-0986), one Linux user per instance. The current instance keeps working unchanged: its
-config path, data root, unit names and ports stay as they are, and no re-pin is needed for it.
-
-## Known single-instance points (GAP-MAP.md, measured at 9ae8c73ac)
-
-The design starts with a full inventory. Grep every script and package, not only these:
-
-- `packages/cli/systemd/mosaic-bus.service.in`: `mosaic-bus@<business>` sets no `MOSAIC_CONFIG` and reads the
-  fixed `EnvironmentFile=-%h/.config/mosaic-dev/secrets/claude-session.env`.
-- `packages/webui/systemd/mosaic-webui.service.in` and `scripts/webui-service.sh`: one `mosaic-webui.service`.
-- `packages/discord/systemd/[email protected]` and `scripts/discord-service.sh`.
-- `scripts/stack-copy.sh:8` hardcodes `BUSINESS=mosaic-stack`, and `:95` reads `mosaic-webui.service`.
-- `scripts/stack-release.sh`: unit names, the Console port and the tester port default, `COPIES` (:28), the
-  pointer under `$DATA/state` (:1474), and `rehearse`.
-- `scripts/mosaic-config.mjs`, `scripts/bootstrap.sh`, `scripts/reset.sh`, `scripts/land-work.sh`,
-  `packages/webui/src/cli.mjs`, `packages/business/src/{business,vars}.mjs`, and
-  `packages/conversation/src/guard.mjs` each name the default config path or data root.
-
-## What the design must settle
-
-1. Instance identity. How a name maps to its config file and how every tool picks the instance (an
-   `--instance NAME` flag, `MOSAIC_CONFIG`, or both), and what happens with neither (the current default,
-   unchanged). Name rules, and refusal of a name that collides.
-2. Config canon. AGENTS.md invariant 2 says `~/.config/mosaic-dev/config.json` is the sole system config,
-   created only by `scripts/bootstrap.sh`. Several instances mean several config files. The design proposes
-   the exact wording change and how bootstrap creates an instance config without overwriting one. Mos rules
-   on the canon change before the build.
-3. Unit names and templates. The bus, Console and Discord units per instance, how `MOSAIC_CONFIG` and the
-   Claude env file reach each unit, and how the current unit names stay valid for the default instance.
-4. Ports. Each instance's Console and tester ports, with a refusal when two instances claim the same port.
-5. Stack copies and the pointer. Whether copies are shared between instances (read-only trees, so sharing
-   may be fine) and how the pointer, activation log, backups and `flags_drift` stay per instance.
-   `stack-release.sh` and `stack-copy.sh` take the instance.
-6. Secrets. The per-instance Claude session env file and the secrets slot root, resolved from the instance's
-   config dir (the Q175 design resolves its slot the same way: `<configDir>/secrets/mosaic-stack/<slot>`).
-7. Isolation proof. What the tests show: two instances started side by side on stand-in units and scratch
-   roots, each reads only its own config and data root, a command aimed at one never touches the other, and
-   the default instance's paths and unit names are byte-identical to today.
-
-## Boundaries
-
-- No test touches `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or a slot file. Use the stand-in
-  systemctl, units and scratch roots that `packages/cli/tests/stack-release.test.mjs` already builds.
-- Standing up a real second instance on dragon-lin is a later window under Q173, with a backup first and a
-  STATE report after. Exposing a new Console through the tunnel or Traefik changes who can reach it from
-  outside, so it waits for Jason. SSO (Q175, #412) comes first for any instance a second user can reach.
-- Merge-chaining (Q177): rows that need instances (human users, kill switch, lifecycle) may build on this
-  row's candidate. This row keeps its own review and gate.
-
-## Gate
-
-Filbert approves DESIGN.md, then the manifest. The cli suite and every `scripts/test-*.sh` are green on
-Sage's gate, and the design's 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_sso-phase1.md

@@ -1,47 +0,0 @@
-# Brief: Q175 phase 1, the Console verifies SSO itself (--sso)
-
-Sage, 2026-10-20, for Q175 (Jason's ruling), mos-0971/0973/0977 and Vikunja #412. Gitea #1690. MVP T1 item 2. Owner
-Launchpad, reviewer Webby (mos-0981), gate owner Sage. Base: refactor at the brief commit.
-
-The design is approved: `agents/sage/work/q175-sso/DESIGN.md` at d55d86bb0 (blob eba861f5d2bb), Filbert r3
-approve plus the D1/D2 ack, Mos C1 confirmation in mos-0977, whose straggler-check condition is in the phase 2 window at b416d2ede. Build phase 1 exactly as the design says. If
-the code shows the design is wrong somewhere, stop and tell Sage, Webby and Filbert before building around it.
-
-## Scope (phase 1 only, design section 5 item 1)
-
-- oauth4webapi 3.8.8, pinned exactly (design section 2). No other new dependency.
-- The OIDC relying party in the Console: `/auth/login`, `/auth/callback`, `/auth/logout`, `/auth/signed-out`,
-  the callback steps 1-7, our own checks on top of the library, and sessions, cookies and Host rules
-  (design sections 1 and 3).
-- The shared loader, `scripts/mosaic-config.mjs`, accepts an optional `console` key and checks only its
-  shape. The slot file checks and the read run in the Console's `--sso` start, and the slot resolves from
-  the config dir (section 4, D1, D2).
-- The degraded start for an unreachable provider, and the unreachable/refused classes (Q-B, section 4).
-- `--sso` for `cli.mjs serve` and `webui-service.sh`, with its refusals against the old flags.
-- The tester listener rules (section 6).
-- The page: both fetch paths in `packages/webui/src/public/app.js` (:111 and :305) treat a 401
-  `sign-in required` as signed out, and the notice links to `/auth/login?return=<path>` (C2).
-- Logging as the design says, including the Q-E `subject-unknown` line.
-
-Out of scope: the phase 2 window, the live config.json key, phase 3 removals, the proxy-forwarded token
-(section 7), and any change to the live Console.
-
-## Tests and mutants
-
-Design section 9: tests 1-25, the positive paths, and every listed mutant, each killed by its named test.
-All tests run against the fake OP in `packages/webui/tests/helpers/fake-oidc.mjs`. No test reaches a real
-provider or Authentik, and no test touches `~/.mosaic-dev`, `~/.config/mosaic-dev`, the live units or a
-slot file. Test 25 goes in `scripts/test-config.sh`.
-
-## Boundaries
-
-- No request of any kind to auth.diversecanvas.com, mosaic.woltje.com or the live 127.0.0.1:7332 (mos-0971,
-  design section 8).
-- No credential value is read, printed or logged.
-- `npm install` runs only inside the worktree that has its own package.json, never in a directory that would
-  walk up to home.
-
-## Gate
-
-Webby approves the manifest. Filbert approved the design and answers design questions. The webui and cli suites, `scripts/test-config.sh` and every
-`scripts/test-*.sh` are green on Sage's gate, and the design's mutants are killed.

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).

docs/plans/QUEUE.md

@@ -33,7 +33,7 @@ Gaps found while working go to `docs/plans/DEFERRED.md`, not here.
 
 <!-- mosaic-queue:begin -->
 
-Generated from `docs/plans/queue.json` revision 2247 by `queue render`. Do not edit between the markers; change the queue with `scripts/mosaic queue`.
+Generated from `docs/plans/queue.json` revision 2236 by `queue render`. Do not edit between the markers; change the queue with `scripts/mosaic queue`.
 
 | # | Piece | Owner | Issues | State | After | Gate | Brief | Note |
 |---|---|---|---|---|---|---|---|---|
@@ -225,9 +225,6 @@ Generated from `docs/plans/queue.json` revision 2247 by `queue render`. Do not e
 | 186 | stack-release --plan: the backup line says what the run will do (P19 404, row 185 N1/N2) | darkwing; reviewers filbert | #1684 | done | — | Filbert approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the three brief mutants killed (sage) | `docs/plans/2026-10-20_plan-backup-line.md` § Brief: the activate plan's backup line says what the run will do | Landed 269134d8d (author Darkwing) on 3c5da3a91. Patch-id c97b9f6e25cd matches the r1 candidate (manifest 449e9121, Filbert approve 29419). Sage gate on b367f5730+patch 09:00:20Z-09:08:59Z: node 2681/0, scripts 422/0, queue 156, network removed; 3c5da3a91 adds only a SESSIONS line. Not live: the stack runs copy 490e2771d3d0. Follow-ups on P19 404: Filbert M6 gap, store-unclean reading. |
 | 187 | stack-release activate carries the row 178 proof pair (mos-0928 Part B A0) | darkwing; reviewers filbert | #1685 | done | 186 done | Filbert approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the brief mutants killed (sage) | `docs/plans/2026-10-20_activate-proof-pair.md` § Brief: activate carries the row 178 proof pair | Landed 9a71e4e80 (author Darkwing) on d17328a55; patch-id 6b57c47bc661 matches candidate 52a5ecc1d143 and Filbert's r1 reading. Sage gate passed 10:21:55Z: cli 446/446 and every package and scripts/test-*.sh green. Filbert approve 29424, rev 2204; follow-ups N1-N4 filed on P19. |
 | 188 | stack-release tests: a carried proof pair and a proof file inside the repository (P19 409, 410; gates Part B) | darkwing; reviewers filbert | #1686 | done | 187 settled | Filbert approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the brief mutants killed (sage) | `docs/plans/2026-10-20_proof-test-gaps.md` § Brief: tests for the two proof-file paths row 187 left open | Landed 8fc0ee216 (author Darkwing) on 23a609c5c; patch-id c9a56b167c07 matches candidate 86aa549bad75 and Filbert's r1 reading; stack-release.sh blob 2586a2a37cd2 unchanged. Sage gate passed 10:58Z: cli 453/453 and every package and scripts/test-*.sh green. Filbert approve 29433, rev 2212; N1 (REPO logical path) to P19 after Part B (mos-0959). |
-| 189 | stack-release activate --no-send drops the Console's --send and keeps the pointer in step (Q175 interim, mos-0972, P19 413) | sage; reviewers dewey | #1687 | in-review, round 1, request posted | 163 done | Dewey approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the brief mutants killed (sage) | `docs/plans/2026-10-20_activate-no-send.md` § Brief: activate --no-send drops the Console's --send | — |
-| 190 | several Mosaic Stack instances on one host: per-instance config, data root, units and ports (MVP T1.1, mos-0974, Vikunja #414) | darkwing; reviewers filbert | #1688 | in-progress | — | Filbert approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the design mutants killed (sage) | `docs/plans/2026-10-20_multi-instance.md` § Brief: several Mosaic Stack instances on one host | — |
-| 191 | one kill switch for the bus, every run, Discord and new launches, from the CLI and the Console (MVP T1.4, mos-0974, Vikunja #414) | rocko; reviewers dewey | #1689 | in-progress | — | Dewey approves DESIGN.md then the manifest; cli, bus, discord and webui suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_kill-switch.md` § Brief: one kill switch for the bus, every run, Discord and new launches | — |
 
 <!-- mosaic-queue:end -->
 

docs/plans/queue.json

@@ -1,7 +1,7 @@
 {
   "version": 1,
   "canonicalRoot": "/mnt/storage/src/mosaic-stack",
-  "revision": 2247,
+  "revision": 2236,
   "rows": [
     {
       "id": 1,
@@ -19820,153 +19820,6 @@
       "createdAt": "2026-10-20T10:31:30.403Z",
       "updatedAt": "2026-10-20T11:11:25.098Z",
       "updatedBy": "sage"
-    },
-    {
-      "id": 189,
-      "piece": "stack-release activate --no-send drops the Console's --send and keeps the pointer in step (Q175 interim, mos-0972, P19 413)",
-      "owner": "sage",
-      "issues": [
-        1687
-      ],
-      "closes": [
-        1687
-      ],
-      "state": "in-review",
-      "previousState": null,
-      "required": false,
-      "requiredSince": null,
-      "gate": "Dewey approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the brief mutants killed",
-      "gateOwner": "sage",
-      "brief": {
-        "path": "docs/plans/2026-10-20_activate-no-send.md",
-        "anchor": "Brief: activate --no-send drops the Console's --send",
-        "blob": "0444b774faf09084311357fdd59b0ef3a3d347eb"
-      },
-      "after": [
-        {
-          "id": 163,
-          "when": "done"
-        }
-      ],
-      "reviewers": [
-        "dewey"
-      ],
-      "review": {
-        "rounds": [
-          {
-            "n": 1,
-            "op": "sage-189-inreview-1",
-            "by": "sage",
-            "at": "2026-10-20T18:46:06.124Z",
-            "issue": 1687,
-            "candidate": {
-              "kind": "manifest",
-              "digest": "67af69bd579561fd8c20be2a47695240a9f09f119dbfff88a8e72e2a7416e668",
-              "text": "70dbc89c0282fa063514317262d8926d16b8b8aaab4a1e47379303918495fc2c  agents/sage/work/queue-189/BUILD.md\n4bd216cce2b40b39998725daa8989f6e3acb3ccd81a7017f6b09026af3965584  agents/sage/work/queue-189/mutants-run.log\nddbdddf03abf4aa91aa62f52e468be7af3c6b2f5d7bec2ee99b11e315471f18c  agents/sage/work/queue-189/mutants.sh\n5d7b2da84d994f4f93d1212e349b4e4c19c5c00780e6cfcde91edb3ca08c014e  docs/plans/2026-10-20_activate-no-send.md\n38e410c4cb731390f96747646eb7f6caa7a587fca9024ccbe901aab5ac19c7cf  docs/TOOLS.md\nfe430969cc669515e348fced1a22cbe839a12023f7ac67cfba905b7afd29872f  packages/cli/tests/stack-release.test.mjs\n16f77305e558f4fb953accc6d09f1f7b408aba363851d8ca79216ffce41bed9f  scripts/stack-release.sh\n"
-            },
-            "request": "comment",
-            "attempts": [
-              {
-                "op": "sage-189-inreview-1",
-                "by": "sage",
-                "at": "2026-10-20T18:46:06.124Z",
-                "state": "posted",
-                "comment": 29457,
-                "transport": {
-                  "outcome": "posted",
-                  "status": 201,
-                  "comment": 29457,
-                  "detail": "created"
-                },
-                "resolutions": []
-              }
-            ],
-            "duplicateRisk": false,
-            "receipts": []
-          }
-        ]
-      },
-      "claim": {
-        "seat": "sage",
-        "op": "sage-189-start"
-      },
-      "note": null,
-      "blockedReason": null,
-      "createdAt": "2026-10-20T18:21:38.646Z",
-      "updatedAt": "2026-10-20T18:46:24.267Z",
-      "updatedBy": "sage"
-    },
-    {
-      "id": 190,
-      "piece": "several Mosaic Stack instances on one host: per-instance config, data root, units and ports (MVP T1.1, mos-0974, Vikunja #414)",
-      "owner": "darkwing",
-      "issues": [
-        1688
-      ],
-      "closes": [
-        1688
-      ],
-      "state": "in-progress",
-      "previousState": null,
-      "required": false,
-      "requiredSince": null,
-      "gate": "Filbert approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the design mutants killed",
-      "gateOwner": "sage",
-      "brief": {
-        "path": "docs/plans/2026-10-20_multi-instance.md",
-        "anchor": "Brief: several Mosaic Stack instances on one host",
-        "blob": "79fa60fbf17a352edc5431d6aabc77c72ec5c48f"
-      },
-      "after": [],
-      "reviewers": [
-        "filbert"
-      ],
-      "review": null,
-      "claim": {
-        "seat": "darkwing",
-        "op": "darkwing-190-start"
-      },
-      "note": null,
-      "blockedReason": null,
-      "createdAt": "2026-10-20T18:42:48.052Z",
-      "updatedAt": "2026-10-20T18:45:23.430Z",
-      "updatedBy": "darkwing"
-    },
-    {
-      "id": 191,
-      "piece": "one kill switch for the bus, every run, Discord and new launches, from the CLI and the Console (MVP T1.4, mos-0974, Vikunja #414)",
-      "owner": "rocko",
-      "issues": [
-        1689
-      ],
-      "closes": [
-        1689
-      ],
-      "state": "in-progress",
-      "previousState": null,
-      "required": false,
-      "requiredSince": null,
-      "gate": "Dewey approves DESIGN.md then the manifest; cli, bus, discord and webui suites and every scripts/test-*.sh green on Sage's gate; the mutants killed",
-      "gateOwner": "sage",
-      "brief": {
-        "path": "docs/plans/2026-10-20_kill-switch.md",
-        "anchor": "Brief: one kill switch for the bus, every run, Discord and new launches",
-        "blob": "aed33125fa67ae69af73c18ffc9e2a83481421f3"
-      },
-      "after": [],
-      "reviewers": [
-        "dewey"
-      ],
-      "review": null,
-      "claim": {
-        "seat": "rocko",
-        "op": "rocko-191-start"
-      },
-      "note": null,
-      "blockedReason": null,
-      "createdAt": "2026-10-20T18:43:05.222Z",
-      "updatedAt": "2026-10-20T18:45:05.621Z",
-      "updatedBy": "rocko"
     }
   ],
   "log": [
@@ -78903,329 +78756,6 @@
         "receipt": "ok sage-163-done rev 2236 row 163 in-review→done round 2"
       },
       "viewSha": "e44815d32d46b91ee37d4c3c4701716956ba35d29c16c24c89020cce345bd61b"
-    },
-    {
-      "rev": 2237,
-      "op": "sage-189-add",
-      "verb": "add",
-      "args": {
-        "piece": "stack-release activate --no-send drops the Console's --send and keeps the pointer in step (Q175 interim, mos-0972, P19 413)",
-        "gate": "Dewey approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the brief mutants killed",
-        "brief": "docs/plans/2026-10-20_activate-no-send.md#Brief: activate --no-send drops the Console's --send",
-        "issues": [
-          1687
-        ],
-        "note": null,
-        "owner": "sage",
-        "gateOwner": "sage",
-        "after": [
-          {
-            "id": 163,
-            "when": "done"
-          }
-        ],
-        "reviewers": [
-          "dewey"
-        ],
-        "required": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:21:38.646Z",
-      "semantics": 2,
-      "result": {
-        "row": 189,
-        "from": null,
-        "to": "queued",
-        "brief": {
-          "path": "docs/plans/2026-10-20_activate-no-send.md",
-          "anchor": "Brief: activate --no-send drops the Console's --send",
-          "blob": "0444b774faf09084311357fdd59b0ef3a3d347eb"
-        },
-        "receipt": "ok sage-189-add rev 2237 row 189 none→queued"
-      },
-      "viewSha": "70bf9967156881afecaba9ccf4edf8cbc63a344eb7c6407b3453c950781f34c5"
-    },
-    {
-      "rev": 2238,
-      "op": "sage-189-briefed",
-      "verb": "move",
-      "args": {
-        "id": 189,
-        "to": "briefed",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:22:01.437Z",
-      "semantics": 2,
-      "result": {
-        "row": 189,
-        "from": "queued",
-        "to": "briefed",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok sage-189-briefed rev 2238 row 189 queued→briefed"
-      },
-      "viewSha": "27ee8a26722d3eaf4c4b346e06ffdb853037aad2d1a7fe14f440cbe1bb9a2a27"
-    },
-    {
-      "rev": 2239,
-      "op": "sage-189-start",
-      "verb": "move",
-      "args": {
-        "id": 189,
-        "to": "in-progress",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:22:18.476Z",
-      "semantics": 2,
-      "result": {
-        "row": 189,
-        "from": "briefed",
-        "to": "in-progress",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok sage-189-start rev 2239 row 189 briefed→in-progress"
-      },
-      "viewSha": "230578585341fcfc9429364332ca8b78988ffd669d3c1bb5e2e94a74d9916649"
-    },
-    {
-      "rev": 2240,
-      "op": "sage-190-add",
-      "verb": "add",
-      "args": {
-        "piece": "several Mosaic Stack instances on one host: per-instance config, data root, units and ports (MVP T1.1, mos-0974, Vikunja #414)",
-        "gate": "Filbert approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the design mutants killed",
-        "brief": "docs/plans/2026-10-20_multi-instance.md#Brief: several Mosaic Stack instances on one host",
-        "issues": [
-          1688
-        ],
-        "note": null,
-        "owner": "darkwing",
-        "gateOwner": "sage",
-        "after": null,
-        "reviewers": [
-          "filbert"
-        ],
-        "required": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:42:48.052Z",
-      "semantics": 2,
-      "result": {
-        "row": 190,
-        "from": null,
-        "to": "queued",
-        "brief": {
-          "path": "docs/plans/2026-10-20_multi-instance.md",
-          "anchor": "Brief: several Mosaic Stack instances on one host",
-          "blob": "79fa60fbf17a352edc5431d6aabc77c72ec5c48f"
-        },
-        "receipt": "ok sage-190-add rev 2240 row 190 none→queued"
-      },
-      "viewSha": "b4319dbd993254b58e4db8be18769b04322028903e325c0c8cadcfdec527929f"
-    },
-    {
-      "rev": 2241,
-      "op": "sage-191-add",
-      "verb": "add",
-      "args": {
-        "piece": "one kill switch for the bus, every run, Discord and new launches, from the CLI and the Console (MVP T1.4, mos-0974, Vikunja #414)",
-        "gate": "Dewey approves DESIGN.md then the manifest; cli, bus, discord and webui suites and every scripts/test-*.sh green on Sage's gate; the mutants killed",
-        "brief": "docs/plans/2026-10-20_kill-switch.md#Brief: one kill switch for the bus, every run, Discord and new launches",
-        "issues": [
-          1689
-        ],
-        "note": null,
-        "owner": "rocko",
-        "gateOwner": "sage",
-        "after": null,
-        "reviewers": [
-          "dewey"
-        ],
-        "required": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:43:05.222Z",
-      "semantics": 2,
-      "result": {
-        "row": 191,
-        "from": null,
-        "to": "queued",
-        "brief": {
-          "path": "docs/plans/2026-10-20_kill-switch.md",
-          "anchor": "Brief: one kill switch for the bus, every run, Discord and new launches",
-          "blob": "aed33125fa67ae69af73c18ffc9e2a83481421f3"
-        },
-        "receipt": "ok sage-191-add rev 2241 row 191 none→queued"
-      },
-      "viewSha": "2cdc7c37430226f1ea01ed9f3d60a2c12be16eddac38d18dc16f889c7b54b14e"
-    },
-    {
-      "rev": 2242,
-      "op": "sage-190-brief",
-      "verb": "move",
-      "args": {
-        "id": 190,
-        "to": "briefed",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:43:25.630Z",
-      "semantics": 2,
-      "result": {
-        "row": 190,
-        "from": "queued",
-        "to": "briefed",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok sage-190-brief rev 2242 row 190 queued→briefed"
-      },
-      "viewSha": "6203315b484302369ce5ea7d854082a6bca4a95f9793e14ec123f57381234c95"
-    },
-    {
-      "rev": 2243,
-      "op": "sage-191-brief",
-      "verb": "move",
-      "args": {
-        "id": 191,
-        "to": "briefed",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:43:43.042Z",
-      "semantics": 2,
-      "result": {
-        "row": 191,
-        "from": "queued",
-        "to": "briefed",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok sage-191-brief rev 2243 row 191 queued→briefed"
-      },
-      "viewSha": "9cc7dda5fa676258e864dedfdf2f4e3904c8723ba9c36474cff76757f52e5c07"
-    },
-    {
-      "rev": 2244,
-      "op": "rocko-191-start",
-      "verb": "move",
-      "args": {
-        "id": 191,
-        "to": "in-progress",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "rocko",
-      "at": "2026-10-20T18:45:05.621Z",
-      "semantics": 2,
-      "result": {
-        "row": 191,
-        "from": "briefed",
-        "to": "in-progress",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok rocko-191-start rev 2244 row 191 briefed→in-progress"
-      },
-      "viewSha": "cd2423e53ac82a667c737852bef6adfdafba82987f37cd090f5484b15b3a0e0c"
-    },
-    {
-      "rev": 2245,
-      "op": "darkwing-190-start",
-      "verb": "move",
-      "args": {
-        "id": 190,
-        "to": "in-progress",
-        "reason": null,
-        "candidate": null,
-        "evidence": null,
-        "issue": null
-      },
-      "by": "darkwing",
-      "at": "2026-10-20T18:45:23.430Z",
-      "semantics": 2,
-      "result": {
-        "row": 190,
-        "from": "briefed",
-        "to": "in-progress",
-        "round": null,
-        "issue": null,
-        "candidate": null,
-        "receipt": "ok darkwing-190-start rev 2245 row 190 briefed→in-progress"
-      },
-      "viewSha": "014db845fb2e380678ab1250f2cd3c0d7b192dc39909416515482c810440149b"
-    },
-    {
-      "rev": 2246,
-      "op": "sage-189-inreview-1",
-      "verb": "move",
-      "args": {
-        "id": 189,
-        "to": "in-review",
-        "reason": null,
-        "candidate": "agents/sage/work/queue-189/candidate-manifest.sha256",
-        "evidence": null,
-        "issue": null
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:46:06.124Z",
-      "semantics": 2,
-      "result": {
-        "row": 189,
-        "from": "in-progress",
-        "to": "in-review",
-        "round": 1,
-        "issue": 1687,
-        "candidate": {
-          "kind": "manifest",
-          "digest": "67af69bd579561fd8c20be2a47695240a9f09f119dbfff88a8e72e2a7416e668",
-          "text": "70dbc89c0282fa063514317262d8926d16b8b8aaab4a1e47379303918495fc2c  agents/sage/work/queue-189/BUILD.md\n4bd216cce2b40b39998725daa8989f6e3acb3ccd81a7017f6b09026af3965584  agents/sage/work/queue-189/mutants-run.log\nddbdddf03abf4aa91aa62f52e468be7af3c6b2f5d7bec2ee99b11e315471f18c  agents/sage/work/queue-189/mutants.sh\n5d7b2da84d994f4f93d1212e349b4e4c19c5c00780e6cfcde91edb3ca08c014e  docs/plans/2026-10-20_activate-no-send.md\n38e410c4cb731390f96747646eb7f6caa7a587fca9024ccbe901aab5ac19c7cf  docs/TOOLS.md\nfe430969cc669515e348fced1a22cbe839a12023f7ac67cfba905b7afd29872f  packages/cli/tests/stack-release.test.mjs\n16f77305e558f4fb953accc6d09f1f7b408aba363851d8ca79216ffce41bed9f  scripts/stack-release.sh\n"
-        },
-        "receipt": "ok sage-189-inreview-1 rev 2246 row 189 in-progress→in-review round 1 on #1687; request sage-189-inreview-1 requesting"
-      },
-      "viewSha": "d8a3aa936a9a819329e86679d0bfcf658d773d0f7cfd29c10587c6447f78e968"
-    },
-    {
-      "rev": 2247,
-      "op": "sage-189-inreview-1.outcome",
-      "verb": "review-outcome",
-      "args": {
-        "id": 189,
-        "attempt": "sage-189-inreview-1",
-        "outcome": "posted",
-        "status": 201,
-        "comment": 29457,
-        "detail": "created"
-      },
-      "by": "sage",
-      "at": "2026-10-20T18:46:24.267Z",
-      "semantics": 2,
-      "result": {
-        "row": 189,
-        "round": 1,
-        "attempt": "sage-189-inreview-1",
-        "state": "posted",
-        "receipt": "ok sage-189-inreview-1.outcome rev 2247 row 189 round 1 request sage-189-inreview-1 posted comment 29457"
-      },
-      "viewSha": "6d7e91ae3cab0b76e5c5d791fb821b97c9da7db16389ff2d531d7b77d2a069f1"
     }
   ]
 }

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

@@ -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

scripts/stack-release.sh

@@ -3,7 +3,7 @@
 # Moves the bus, the Console and the human CLI from the pointer's copy to another copy together,
 # behind a health gate, and puts the old stack back inside the same run when the gate fails.
 # Console tester listener flags follow target support (row 176, #1674); so does the row 178 proof
-# pair, which activate sets or drops (row 187, #1685). activate --no-send drops --send (row 189, #1687).
+# pair, which activate sets or drops (row 187, #1685).
 # Design and tests: agents/darkwing/work/queue-162/BUILD.md.
 #
 # Who runs it. Decision 96 (Mos, mos-0716) lets this script stop and start the live units under
@@ -30,13 +30,13 @@ BIN="$HOME/.npm-global/bin"
 UNIT_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user"
 CONSOLE_UNIT=mosaic-webui.service
 TIMEOUT=60 WANT_PM=0 AFTER_HARNESS=0 MIGRATE=0 PLAN=0 RESTORE="" EVENTS="" TESTER_PORT=""
-PROOF_HEADER="" PROOF_FILE="" NO_PROOF=0 NO_SEND=0 R_BACKUP="" R_PORT=""
+PROOF_HEADER="" PROOF_FILE="" NO_PROOF=0 R_BACKUP="" R_PORT=""
 
 usage() {
     cat >&2 <<'USAGE'
 usage: stack-release.sh adopt BUSINESS
        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]
+           [--proof-header NAME --proof-file PATH | --no-proof] [--timeout S] [--plan]
        stack-release.sh pm-on BUSINESS [--timeout S]
        stack-release.sh rollback BUSINESS [--restore ACTIVATION [--events N]] [--timeout S] [--plan]
        stack-release.sh status BUSINESS
@@ -85,7 +85,6 @@ parse_opts() {
             --proof-header) [ "$OP" = activate ] && [ $# -ge 2 ] && [ -n "$2" ] || usage; PROOF_HEADER="$2"; shift 2 ;;
             --proof-file) [ "$OP" = activate ] && [ $# -ge 2 ] && [ -n "$2" ] || usage; PROOF_FILE="$2"; shift 2 ;;
             --no-proof) [ "$OP" = activate ] || usage; NO_PROOF=1; shift ;;
-            --no-send) [ "$OP" = activate ] || usage; NO_SEND=1; shift ;;
             --migrate) [ "$OP" = activate ] || usage; MIGRATE=1; shift ;;
             --restore) [ "$OP" = rollback ] && [ $# -ge 2 ] && [[ "$2" =~ ^[0-9]{8}T[0-9]{6}Z-[0-9a-f]{12}(-[1-9])?$ ]] || usage; RESTORE="$2"; shift 2 ;;
             --backup) [ "$OP" = rehearse ] && [ $# -ge 2 ] && { [[ "$2" =~ ^[0-9]{8}T[0-9]{6}Z-[0-9a-f]{12}(-[1-9])?$ ]] || [[ "$2" =~ ^/[A-Za-z0-9/._+-]*$ ]]; } || usage; R_BACKUP="$2"; shift 2 ;;
@@ -245,16 +244,14 @@ target_schema() {
 in_chain() { local v; for v in "${T_CHAIN[@]}"; do [ "$v" != "$1" ] || return 0; done; return 1; }
 
 # The item 3 checks on the target copy, in order: copy, schema, already-active. An activate that
-# sets a proof pair, drops the pointer's pair with --no-proof, or drops the pointer's --send with
-# --no-send, may name the pointer's copy: it re-pins the live copy with new Console flags (row 187,
-# Part B's B3 and B-R1; row 189, mos-0972).
+# sets a proof pair, or drops the pointer's pair with --no-proof, may name the pointer's copy: it
+# re-pins the live copy with new Console flags (row 187, Part B's B3 and B-R1).
 check_target() {
     copy_exists "$TO" 2>/dev/null || refuse copy-missing "no copy $TO in $COPIES"
     copy_ok "$TO" 2>/dev/null || refuse copy-unreachable "$TO is not reachable from refactor and origin/refactor"
     target_schema "$TO" || refuse copy-schema-unknown "cannot read SCHEMA_VERSION and its chain from $COPIES/$TO/packages/bus/src/store.mjs"
     [ "$TO" != "$P_COPY" ] || [ -n "$PROOF_HEADER" ] ||
         { [ "$NO_PROOF" = 1 ] && [[ " ${P_CONSOLE[*]} " == *" --proof-header "* ]]; } ||
-        { [ "$NO_SEND" = 1 ] && [[ " ${P_CONSOLE[*]} " == *" --send "* ]]; } ||
         refuse already-active "$TO is the pointer's copy"
 }
 
@@ -693,33 +690,6 @@ console_for_target() {
         DROP_TESTER="--tester-port $inherited"
     fi
     proof_for_target
-    send_for_target
-}
-
-# Row 189 (mos-0972): --no-send drops --send from RUN_CONSOLE, so the unit and the pointer both lose
-# it; without the flag the pointer's --send goes on unchanged. Rollback and pm-on never take it, so
-# they carry the pointer as it is. Sets SEND_PLAN (the plan's send: line) and SEND_STEP.
-send_for_target() {
-    local had=0 i
-    local -a without_send=()
-    for ((i = 0; i < ${#RUN_CONSOLE[@]}; i++)); do
-        if [ "${RUN_CONSOLE[i]}" = --send ]; then had=1; else without_send+=("${RUN_CONSOLE[i]}"); fi
-    done
-    SEND_STEP=""
-    if [ "$NO_SEND" = 1 ]; then
-        RUN_CONSOLE=("${without_send[@]}")
-        if [ "$had" = 1 ]; then
-            SEND_PLAN="send: dropped; --no-send was given"
-            SEND_STEP="drop --send; --no-send was given"
-        else
-            SEND_PLAN="send: off; --no-send was given and the pointer holds no --send"
-            SEND_STEP="--no-send was given and the pointer holds no --send, so there is nothing to drop"
-        fi
-    elif [ "$had" = 1 ]; then
-        SEND_PLAN="send: carried"
-    else
-        SEND_PLAN="send: off"
-    fi
 }
 
 # Row 187: the row 178 proof pair in RUN_CONSOLE. A new pair replaces the pointer's and goes last;
@@ -973,7 +943,6 @@ plan() {
     echo "bus: scripts/bus-service.sh install --copy $TO --copies $COPIES$([ "$RUN_PM" = 0 ] || echo ' --pm') --claude $P_CLAUDE"
     [ -z "$DROP_TESTER" ] || echo "drop $DROP_TESTER; the target Console does not support it"
     echo "$PROOF_PLAN"
-    echo "$SEND_PLAN"
     echo "Console: scripts/webui-service.sh install --copy $TO --copies $COPIES${RUN_CONSOLE[*]:+ ${RUN_CONSOLE[*]}}"
     echo "CLI: scripts/stack-copy.sh wrapper $TO --copies $COPIES --bin $BIN"
     local r
@@ -987,7 +956,6 @@ run_steps() {
     capture || refuse capture-failed "could not write the rollback set $RS; nothing was stopped"
     [ -z "$DROP_TESTER" ] || say "drop $DROP_TESTER; the target Console does not support it"
     [ -z "$PROOF_STEP" ] || say "$PROOF_STEP"
-    [ -z "$SEND_STEP" ] || say "$SEND_STEP"
     trap 'after_fail signal' INT TERM HUP
     stop_both || rollback_in_run stop-timeout
     if [ -e "$STORE" ]; then
@@ -1510,7 +1478,7 @@ STORE="$DATA/bus/bus.sqlite"
 BUS_UNIT="mosaic-bus@$BUSINESS.service"
 FROM="" TO="" ACT="" RS="" POST="" BACKUP="" TAKEN="" RESTORED="" STEPS="" COUNT="" UNCLEAN="" FAIL=""
 STORE_SCHEMA="" START_EPOCH="" START_MS=0 GATE="" GATE_WHY="" S_CHANGED=""
-P_COPY="" P_PM=0 P_PENDING=0 P_SCHEMA="" P_CLAUDE="" P_CONSOLE=() RUN_PM=0 RUN_PENDING=0 RUN_CONSOLE=() DROP_TESTER="" PROOF_PLAN="" PROOF_STEP="" SEND_PLAN="" SEND_STEP="" PLAN_REFUSE=()
+P_COPY="" P_PM=0 P_PENDING=0 P_SCHEMA="" P_CLAUDE="" P_CONSOLE=() RUN_PM=0 RUN_PENDING=0 RUN_CONSOLE=() DROP_TESTER="" PROOF_PLAN="" PROOF_STEP="" PLAN_REFUSE=()
 R="" R_RC=0 R_EARLY=() R_BK="" R_HOST_PID="" R_CONSOLE_PID="" R_STARTED="" LIVE_CFG="" LIVE_BIZ=""
 case "$OP" in
     adopt) do_adopt ;;