agents: row 195 Case 1 install design r6 (#1693): Duckworth r5 B1 (confirm's result lines carry the activation's op, from, to and the rollback set's BACKUP, so from_log reads .53's log; sequence 7), B2 (MIGRATING recorded after backup_store and before migrate-schema.mjs, as TAKEN today; sequence 8), N1 marker step makes $RS, N2 gate --since, N3 apparmor.d word grep baseline, N4 item 4 under systemd-run with NoNewPrivileges, N5 plan --expect-from OLD

agents/darkwing/work/queue-195/DESIGN.md

@@ -0,0 +1,872 @@
+# Row 195 design: the Case 1 install on 10.1.1.53 (r6)
+
+Darkwing, 2026-10-20. Brief: `docs/plans/2026-10-20_hub-own-uid.md`, blob 45be7f09afc1 (f24f2cd40,
+sage-1439). Gitea #1693. Reviewer Duckworth, gate owner Sage. Chained on row 190's candidate (round 3,
+df65a3d4c on `darkwing/row190-r3`, rebased on row 192; the config canon) and on row 230's candidate
+(C2-13a, #1732, Gosalyn: `scripts/case2-unit.sh` and `case2-precheck.sh`), Q177, sage-1499. Row 230's
+brief is `docs/plans/2026-10-20_case2-rows.md` "C2-13a" at 5b8def2f1, from Gosalyn's design r11
+(eac92d956 on `gosalyn/case2-design`, approved webby-0038). It has no candidate yet, so I read that
+brief as the interface and expect a rebase. Section 2 lists what Case 1 needs from it that the brief
+doesn't give.
+
+Changes from r5 (Duckworth's REVIEW-r4.md at 62200362b on `duckworth/reviews`, duckworth-0054). This
+round changes only B1's and B2's lines, their section 7 cases and the notes:
+
+- B1. The result line `confirm` writes said op `confirm`, because `log_line` (:58) writes `$OP` and
+  `OP="$1"` (:1493). `from_log` (:169) reads only `adopt`, `activate` and `rollback`, so it would have
+  skipped every .53 activation: after adopt C0 and re-pins to C1 and C2, `from_log previous` returns
+  C0. Now A5's `ok` line and R4's line carry the op, from and to of the activation's `started` line,
+  and the backup that A3 records in the rollback set. Real sequence 7 and a mutant that writes op
+  `confirm`. Section 4.
+- B2. r5 recorded the migration after the migrate, while today's run sets TAKEN before
+  `migrate-schema.mjs` (:1004-1005). A migrate that changed the store and then exited 1 would have
+  left no record, so R2 would skip the restore and R4 would gate OLD on a half-migrated store. A3 now
+  writes `MIGRATING` after `backup_store` returns and before the migrate. Real sequence 8 and a mutant
+  that records after the migrate. Section 4.
+- N1. The marker step makes `$RS` with capture's exclusive `mkdir` (:416), and capture under
+  `--units external` makes none. N2. `gate` takes `--since T`, root's clock before its A2f start, as
+  its start floor. N3. Section 0 now has a read-only grep of `/etc/apparmor.d` for the word `bwrap`,
+  and item 3 matches the word against a list of exactly one file. N4. Item 4 runs under
+  `systemd-run` with the units' `NoNewPrivileges=yes`, as 2a' does. N5. A1's plan takes
+  `--expect-from OLD` and refuses `pointer-differs`.
+- Not in this round: claude's path. gosalyn-0058 proposes that `--claude`, like `--node`, takes only a
+  root-owned path outside the home, and `/srv/mosaic/.local/bin/claude` fails that. I asked Sage to
+  rule and recommended moving claude under `/opt/mosaic-stack`. That change gets its own round.
+
+Changes from r4 (Duckworth's REVIEW-r3.md at 9f4d5556b on `duckworth/reviews`; mos-1098; mos-1101;
+gosalyn-0049):
+
+- B1. An activation now has exactly one result line, written at the end. A5's gate failure and A3's
+  failure after its capture write no log line. Each writes a `FAILED` file next to `AWAITING-UNITS` and
+  exits 1, so the activation stays open for R2 and R4, and R4 writes the result. A3 writes
+  `AWAITING-UNITS` right after `started`. Refusals by `confirm`, `revert` and `gate` log no activation
+  id, so a refused `confirm` can't close one either. There are real-sequence tests on one log, and
+  mutants that put back r4's interim line, r4's marker order and a refusal that names the activation.
+  Section 4 and section 7.
+- B2. The bwrap profile has an owner and a stop. `scripts/case1-hostcheck.sh` checks the profile file
+  against the pin in `scripts/case1-pins.sh`, the two loaded profiles, the live label of a process
+  bwrap runs, the statoverride and mode, that no other profile names bwrap, two sysctls and the port
+  floor. It has three callers:
+  1. A1 of every re-pin refuses `profile-drift`.
+  2. A root apt hook runs it after every package run, unattended ones included.
+  3. A boot unit runs it before the bus starts.
+
+  On drift, callers 2 and 3 unload the profile and close `/usr/bin/bwrap` to `mosaic`, so every role
+  session refuses to start. They write `DRIFT` and log it, and only root clears it. ops-01 owns the host
+  side under a Mos go: it reads the log in each STATE report and, before each re-pin window, compares
+  the upstream profile to the pin. A changed upstream profile becomes a new pin, which is its own review
+  round. Section 1 has the details. The facts behind it are in section 0: unattended-upgrades runs daily
+  on .53 with the security pocket, and the pinned bubblewrap is in that pocket.
+- N1 and mos-1098 point 2. P9 has a seventh item: no `mosaic-bwrap` profile is loaded, and no profile
+  other than Ubuntu's attaches to `/usr/bin/bwrap`. r4 never installed `mosaic-bwrap`. F5 now compares
+  exact strings. P9 reads `accepted mos-1096` only while all seven items hold.
+- N2: a role session gets no capabilities, so a nested bwrap fails. Section 1. N3: A3 refuses "before
+  it logs `started`". N4: the stale-start rule and its fixtures handle `ActiveEnterTimestamp`'s whole
+  seconds.
+- The port squat (mos-1101 item 5, gosalyn-0049). It applies: role sessions share the host's network
+  namespace (`packages/seat/src/sandbox.mjs:67` unshares no net), so while the Console is down a
+  session can bind its loopback port. The Console moves to 127.0.0.1:732 with
+  `CAP_NET_BIND_SERVICE` on its unit (row 230's line), so no session can take it. The tester port stays
+  7333, because serve refuses a tester port below 1024. That residue is P10, accepted under Mos's
+  reading. Case 1 can't meet the preview trio or the proof pair, because .53 has no proxy. Section 2
+  names the factory serve set for row 230.
+- Jason's Q9 (Vikunja #429) is still open. If install and upgrade become product commands, these
+  steps become that installer's configuration and row 195 rebases on its row (sage-1491). Section 6.
+
+## 0. What I checked on the host
+
+Read only, as `localadmin` over ssh, 2026-10-20 between 20:40Z and 21:00Z, and again at 21:27Z for the
+last seven rows (the brief allows this):
+
+| Item | 10.1.1.53 today | Needed |
+|---|---|---|
+| OS | Ubuntu 24.04.5, kernel 6.8.0-124, x86_64, 12 cores, 94 GiB, 217 GiB free on `/` | fits |
+| `mosaic` user, group, `/srv/mosaic` | absent | step 2a creates them |
+| node | `/usr/local/bin/node` v22.22.2, root-owned | 24 or later (every `packages/*/package.json` engines line); dragon-lin runs 26.8.1 |
+| bwrap | absent, no statoverride; apt candidate `bubblewrap 0.9.0-1ubuntu0.3` | every role session runs under `/usr/bin/bwrap` (`packages/seat/src/sandbox.mjs:43`) |
+| user namespaces | `kernel.apparmor_restrict_unprivileged_userns = 1`, apparmor 4.0.1, no bwrap profile loaded | bwrap needs a user namespace, which this setting refuses unless a profile allows it |
+| `apparmor-profiles` | not installed; candidate `4.0.1really4.0.1-0ubuntu0.24.04.9`, whose `/usr/share/apparmor/extra-profiles/bwrap-userns-restrict` has sha256 `11d39094f044f0cda0febb3ad517b830301da6b2ce929664af09ee9e4dd264f9` (read from the deb on dragon-lin) | section 1 |
+| `fs.protected_hardlinks`, `fs.protected_symlinks` | 1, 1 | mos-1096 item 2 |
+| journald | `SplitMode=uid` (the default) | section 4, B2 |
+| `useradd` | `USERGROUPS_ENAB yes` | 2a passes `--user-group` anyway |
+| claude | not on localadmin's PATH | the factory's harness; dragon-lin runs 2.1.304 |
+| ports 7330-7333 | free (no listener) | tester |
+| `localadmin` | NOPASSWD sudo (#423 step 1, applied 20:05:47Z, mos-1066, mos-1077) | the root steps run through it |
+| `jarvis` | groups sudo, docker, lxd, adm | #423 step 4 removes all four (section 5, P5) |
+| unattended-upgrades | on: `APT::Periodic::Unattended-Upgrade "1"`, `apt-daily-upgrade.timer` enabled. Allowed origins `${distro_id}:${distro_codename}`, `-security`, ESM apps-security and ESM infra-security. No `Package-Blacklist` | B2: packages change daily without a window |
+| bubblewrap's pocket | `0.9.0-1ubuntu0.3` is in both `noble-updates` and `noble-security`, so its later security updates install unattended | B2 |
+| apparmor | installed `4.0.1really4.0.1-0ubuntu0.24.04.8`. The `.9` candidate is in `noble-updates` only, which unattended-upgrades doesn't take. `aa-status --json` works | B2 |
+| profiles that name bwrap | at 21:51:46Z `grep -rlw bwrap /etc/apparmor.d` and `grep -rlF /usr/bin/bwrap /etc/apparmor.d` both find nothing (exit 1). After 2a' the word grep lists only `bwrap-userns-restrict` | N1, P9 item 7, hostcheck item 3 |
+| `net.ipv4.ip_unprivileged_port_start` | 1024 | the port squat |
+| listeners below 1024 | 22 (sshd) and 53 (the resolver) only; 732 is free | the Console's port (section 1) |
+| other listeners | 4003, 6052, 6055, 8123, 8765, 14242, 18555, and on loopback 1933, 5905, 6085, 6379, 6380, 9119, 9225, 18554, 18789, 38147 | none in 7330-7333 |
+
+## 1. The install as inputs to the Case 2 scripts
+
+Instance. Row 190's canon with the default name, `dev`, as Case 2 uses it (Gosalyn design 9). `~` is
+`mosaic`'s home, `/srv/mosaic`, so:
+
+| Input | Value |
+|---|---|
+| user | `mosaic`, primary group `mosaic` with no other member |
+| home | `/srv/mosaic`, 0700, owner `mosaic` |
+| config dir | `/srv/mosaic/.config/mosaic-dev` |
+| data root | `/srv/mosaic/.mosaic-dev`, marker `instance.json` `{"instanceVersion":1,"name":"dev"}` |
+| business | `mosaic-stack`, file `<configDir>/businesses/mosaic-stack.json` (section 2) |
+| profile | `--profile factory` (row 230, C2-13b) |
+| roles | the factory set in section 2 |
+| human id | Jason's id, given in the window's go. Not `tester` (`broker.mjs:245`) |
+| model credential | `<configDir>/secrets/claude-session.env`, 0600 (row 190's `SESSION_ENV` for the default instance) |
+| token slot path | none for this row (section 2) |
+| Console port | 127.0.0.1:732, below the port floor, bound through the Console unit's `CAP_NET_BIND_SERVICE` (row 230). The port squat below says why |
+| tester port | 127.0.0.1:7333 (P10) |
+| board | none. UNITS has no board unit, and the Console gets no `--board` |
+| harness | claude at `/srv/mosaic/.local/bin/claude`, pinned through `MOSAIC_CLAUDE_BIN` (decision 91), which the bus unit's `@CLAUDE_ENV@` line sets (section 2) |
+| node | `/opt/mosaic-stack/node-<version>/bin/node`, a pinned 26.x release, `root:root`. Row 230 refuses a `--node` under the home or not owned by root |
+| PM | on: the bus unit's `@PM_FLAGS@` renders ` --pm` (section 2, section 4) |
+| source | `/srv/mosaic/src/mosaic-stack` (`mosaic`'s checkout, section 4) and `/root/mosaic-stack` (root's) |
+
+Why `dev` and not a named instance: one instance per OS user, and Case 2's rows already assume
+`/srv/mosaic/.config/mosaic-dev`. A second instance under `mosaic` on .53 would need a name, and row 190
+makes that a flag, not a move.
+
+Why node lives under `/opt/mosaic-stack`: changing `/usr/local/bin/node` would change what Hermes and
+anything else on the host runs, and Q181 keeps Hermes running. r4 put node under `/srv/mosaic`, but row
+230 requires a root-owned `--node` outside the home. Nothing else on the host puts `/opt/mosaic-stack`
+on its PATH.
+
+PATH for `mosaic`'s steps. `sudo -u mosaic -H` resets PATH to sudo's `secure_path`, which finds
+`/usr/local/bin/node`, v22. The precheck would then refuse, and `scripts/mosaic` would run v22 (it runs
+`exec node` from PATH, `scripts/mosaic:22-40`). So every `mosaic` step in the run sheet and in
+`case1-repin.sh` runs as `sudo -u mosaic -H env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin ...`, the
+list row 230 renders as the units' `@PATH@`. `case1-repin.sh` builds it from the `--node` in
+`case1-unit.args`.
+
+The units (row 230, design r11). Two system units, from the existing templates, in start order:
+`[email protected]` from `packages/cli/systemd/mosaic-bus.service.in`, then
+`mosaic-webui.service` from `packages/webui/systemd/mosaic-webui.service.in`. Root stops them in the
+reverse order. `@REPO@` is the copy dir, and `%h` becomes the literal home. Row 230 adds
+`ProtectSystem=strict`, `ReadWritePaths=/srv/mosaic`, `ProtectHome=yes` and `PrivateTmp=yes` to both, and
+`AmbientCapabilities=CAP_NET_BIND_SERVICE` with `CapabilityBoundingSet=CAP_NET_BIND_SERVICE` to the
+Console only. The Console unit has no `[Install]`, so root starts it by hand after a reboot until Jason
+rules (mos-1097). The install call is:
+
+```
+case2-unit.sh --profile factory --user mosaic --home /srv/mosaic --business mosaic-stack --copy ID \
+  --node /opt/mosaic-stack/node-<version>/bin/node --pm --claude /srv/mosaic/.local/bin/claude \
+  -- --port 732 --business mosaic-stack --tester-port 7333
+```
+
+`--pm` and `--claude` are the two inputs row 230's brief doesn't have yet (section 2). A re-install
+must pass the same `--node`, flags and serve flags, and only the copy id may change (row 230's
+re-install check). So 2c writes the whole argument list, without `--copy`, to
+`/etc/mosaic-stack/case1-unit.args`, `root:root` 0644, one argument per line. Every later
+`case2-unit.sh` call in section 4 reads that file and adds `--copy`. `mosaic` can't write it. Changing
+a serve flag is a re-install with its own go, not a re-pin.
+
+The port squat (mos-1101 item 5). Role sessions share the host's network namespace:
+`packages/seat/src/sandbox.mjs:67` unshares the user, PID and IPC namespaces and not the network. So
+while the Console is down, which A2 to A4 of every re-pin and any crash before `Restart=on-failure`
+brings it back both cause, a session can bind 127.0.0.1:7332. It would then receive Jason's `ssh -L`
+traffic, and it would answer the gate's `/healthz` (`stack-release.sh:485-487`) in the Console's place.
+At 732 that can't happen. The floor is 1024 (section 0), a session has no capabilities (below), and
+`mosaic`'s own processes outside the sandbox have none either. Only the Console unit holds
+`CAP_NET_BIND_SERVICE`. Its children, the human-cli and read scripts it spawns
+(`packages/webui/src/bus.mjs:31`, `reads.mjs:79`), inherit the ambient capability. No role session
+descends from the Console: sessions are children of the bus unit, which has no capability line. The
+gate needs no change, because `console_port` (`stack-release.sh:213-215`) reads the Console's `--port`
+from the pointer. Row 230's precheck refuses when the floor is at or below the Console's port, and
+`case1-hostcheck.sh` checks it after every package run (B2). The tester port can't go below 1024,
+because serve refuses that (`packages/webui/src/cli.mjs:33`), so P10 records it.
+
+Node download (N4). The run sheet pins one release, its tarball name and its sha256. As root, in a
+root-owned temp dir: fetch the tarball, `SHASUMS256.txt` and `SHASUMS256.txt.asc`; `gpg --verify` the
+`.asc` against the Node release keys listed in the nodejs/release-keys repository, imported into a
+keyring under `/etc/mosaic-stack/node-keys`; check that the tarball's line in the verified file is the
+pinned sha256; then `sha256sum -c` the tarball and unpack it to `/opt/mosaic-stack/node-<version>`,
+`root:root`, no file writable by group or other. Any mismatch stops the step. Rollback: `rm -r` that
+dir.
+
+Claude (N5). The run sheet pins the version, 2.1.304 unless the window's plan names a newer one. As
+`mosaic`: `npm install --prefix /srv/mosaic/.local @anthropic-ai/claude-code@<pin>`, with `@<pin>`
+exact. `/srv/mosaic/.local/bin/claude` is the path `MOSAIC_CLAUDE_BIN` names. The autoupdater stays off
+through `/etc/claude-code/managed-settings.json`, `root:root` 0644, holding
+`{"env":{"DISABLE_AUTOUPDATER":"1"}}`. Root writes it in 2a'. Why there:
+
+- `ENV_ALLOW` (`packages/seat/src/session.mjs:83-88`) doesn't pass `DISABLE_AUTOUPDATER`, so a unit
+  `Environment=` line never reaches a role session (gosalyn-0046 item 3).
+- A role session's HOME is the run's own `home/`, and the sandbox doesn't show `~/.claude`
+  (`session.mjs:92-93`, `sandbox.mjs:16`). So `mosaic`'s claude settings file doesn't reach one either.
+- The sandbox mounts `/etc` read-only (`sandbox.mjs:85`), and Claude Code reads managed settings from
+  `/etc/claude-code/` whatever HOME is. `mosaic`'s own CLI runs, like the precheck's marker prompt
+  and F6, read it too.
+
+The pinned binary is a read-only bind inside the sandbox (`sandbox.mjs:9-10`), so a session can't
+rewrite it anyway. The managed file covers `mosaic`'s runs outside the sandbox. If the installed
+version doesn't honour `env` there, F6 catches the drift. Rollback: `rm` the file.
+
+bwrap and the user namespace (mos-1091 4a, 4b; mos-1096 item 2; N1). Three root steps in 2a', in this
+order, each with its rollback. The `mosaic` group must exist first (2a).
+
+1. `apt-get install bubblewrap=0.9.0-1ubuntu0.3`, the version the run sheet pins. Then record
+   `stat -c '%U:%G %a' /usr/bin/bwrap` to `/etc/mosaic-stack/bwrap.orig` (I expect `root:root 755`).
+   Rollback: `apt-get remove bubblewrap`.
+2. Ubuntu's own `bwrap-userns-restrict`, one file, not the package. `apt-get download
+   apparmor-profiles=4.0.1really4.0.1-0ubuntu0.24.04.9` into a root-owned temp dir, extract
+   `./usr/share/apparmor/extra-profiles/bwrap-userns-restrict` with `dpkg-deb --fsys-tarfile`, check
+   its sha256 is `11d39094f044f0cda0febb3ad517b830301da6b2ce929664af09ee9e4dd264f9`, and install it as
+   `/etc/apparmor.d/bwrap-userns-restrict`, `root:root` 0644. Load it with `apparmor_parser -r
+   /etc/apparmor.d/bwrap-userns-restrict`. `aa-status` then lists `bwrap` and `unpriv_bwrap` in
+   enforce mode. Why one file: the package also installs 20 profiles under `/etc/apparmor.d`
+   (`usr.sbin.dnsmasq`, `bin.ping`, `usr.sbin.smbd` and more), which would load at the next boot and
+   could change services on the host that have nothing to do with Mosaic.
+   What the profile does: `bwrap` gets `userns`, `capability` and `mount` for its own setup, and
+   every program it runs is stacked under `unpriv_bwrap`, which has the same file and network rules
+   with `audit deny capability`. So a role session gets a user namespace and no capabilities in it.
+   The sysctl stays at 1, so nothing else on the host gains user namespaces.
+   One consequence (N2): a bwrap that a session starts inside its own sandbox fails, because it needs
+   capabilities in the namespace. Claude Code's own sandbox is such a bwrap, and it's off by default,
+   so a role session doesn't use it. F3 shows a session still answers under the profile.
+   Rollback: `apparmor_parser -R /etc/apparmor.d/bwrap-userns-restrict`, then `rm` it.
+3. `dpkg-statoverride --update --add root mosaic 0750 /usr/bin/bwrap` (Mos). Only root and the
+   `mosaic` group can read or run bwrap, and package upgrades keep the mode. Rollback:
+   `dpkg-statoverride --remove /usr/bin/bwrap`, then `chown` and `chmod` to the values in
+   `bwrap.orig`.
+4. The drift stop (B2, below): `case1-hostcheck.sh` and `case1-pins.sh` from `/root/mosaic-stack` to
+   `/usr/local/lib/mosaic-stack/`, `root:root` 0755 and 0644; the apt hook
+   `/etc/apt/apt.conf.d/80mosaic-hostcheck`; the boot unit `mosaic-hostcheck.service`, enabled. Then
+   `case1-hostcheck.sh --check` exits 0. Rollback: disable and remove the unit, `rm` the hook file and
+   the dir.
+
+Full rollback runs 4, 3, 2, 1. Tests after 2a' and again in section 5: as `mosaic`, `bwrap --unshare-all
+--ro-bind / / true` exits 0 (row 230's precheck line, F4); as `jarvis`, `/usr/bin/bwrap --version`
+fails with "Permission denied" (P9); `getent group mosaic` lists no member and no other account has
+gid `mosaic` (P9); `fs.protected_hardlinks` is 1 (P9). A role session running under the profile is F5.
+
+One more test runs in 2a', because I can't settle it from here. Row 230's units keep the templates'
+`NoNewPrivileges=yes`, and AppArmor limits profile changes for a task with no-new-privs set. The
+`bwrap` attach happens on exec from an unconfined task, and the child's change is a stack
+(`bwrap//&unpriv_bwrap`), which only narrows. I expect both to pass under no-new-privs, since bwrap
+sets no-new-privs on itself before it runs the child, and Ubuntu's profile works with that. But I
+haven't seen it run, and .53 is read-only to me. So as root, after step 4: `systemd-run --wait --pipe
+--uid=mosaic --gid=mosaic -p NoNewPrivileges=yes -p ProtectSystem=strict -p ProtectHome=yes -p
+PrivateTmp=yes /usr/bin/bwrap --unshare-user --unshare-pid --ro-bind / / cat /proc/self/attr/current`
+prints `bwrap//&unpriv_bwrap (enforce)`. If it fails, the window stops at 2a' and rolls back 4 to 1,
+before any `mosaic` step. That beats finding it at F5.
+
+The drift stop (B2, Duckworth's REVIEW-r3 B2, mos-1098 point 1). r4 installed a profile file that no
+package owns, from a pinned deb, onto a host where unattended-upgrades changes packages every day
+(section 0). Three things can move under it: bubblewrap (its security updates install unattended), the
+`apparmor` package and its parser, and any new profile a package ships that attaches to
+`/usr/bin/bwrap`. Two more host values matter to this design: the user-namespace sysctl and the port
+floor. So:
+
+- `scripts/case1-pins.sh` holds the pins, sourced by the scripts below: the `apparmor-profiles` version
+  the file came from, the file's sha256, and the bubblewrap version 2a' installs. Changing a pin is a
+  reviewed commit and its own round. The bubblewrap version is an install pin, not a drift item:
+  a security update to bubblewrap keeps the statoverride, and the profile attaches by path.
+- `scripts/case1-hostcheck.sh` checks seven items and prints one line each:
+  1. `/etc/apparmor.d/bwrap-userns-restrict` has the pinned sha256, and `dpkg -S` finds no package
+     that owns it.
+  2. `aa-status --json` lists `bwrap` and `unpriv_bwrap` in enforce mode, and no loaded profile named
+     `mosaic-bwrap`.
+  3. `grep -rlw bwrap /etc/apparmor.d` lists exactly `/etc/apparmor.d/bwrap-userns-restrict`. The word
+     match also catches a path written as `/{usr/,}bin/bwrap`. Section 0's read found no file today.
+  4. The live label: 2a' line `systemd-run --wait --pipe --uid=mosaic --gid=mosaic -p NoNewPrivileges=yes
+     -p ProtectSystem=strict -p ProtectHome=yes -p PrivateTmp=yes /usr/bin/bwrap --unshare-user
+     --unshare-pid --ro-bind / / cat /proc/self/attr/current` prints exactly `bwrap//&unpriv_bwrap
+     (enforce)`. It runs under the units' no-new-privs, so it reads the label a role session gets.
+     This catches a profile that attaches by a glob that item 3's search misses.
+  5. `dpkg-statoverride --list /usr/bin/bwrap` reads `root mosaic 0750`, and `stat` agrees.
+  6. `kernel.apparmor_restrict_unprivileged_userns` is 1 and `fs.protected_hardlinks` is 1.
+  7. `net.ipv4.ip_unprivileged_port_start` is above the Console's `--port` in the installed unit.
+
+  `--check` exits 0 when all hold and 1 otherwise. `--enforce` runs the same check and always exits 0.
+  On a failure, or while `/etc/mosaic-stack/DRIFT` exists, it applies the stop:
+  `apparmor_parser -R` on the profile if loaded, then `chown root:root` and `chmod 0700` on
+  `/usr/bin/bwrap`. It writes the failed items to `DRIFT` and appends a line to
+  `/var/log/mosaic-stack/hostcheck.log`. With bwrap closed to `mosaic`, every role session refuses
+  to start. That's the fail-closed state, and the stack needs no change for it. The chmod is undone by
+  the next bubblewrap upgrade, which reapplies the statoverride. But the apt hook runs again right
+  after that upgrade and finds `DRIFT`, so it closes bwrap again. Only root removes `DRIFT`, in a
+  reviewed step with a new pin or a Mos go. I don't call `dpkg-statoverride` from inside the hook,
+  because I haven't confirmed it can take dpkg's lock while apt holds the frontend lock.
+- Three callers. A1 of every re-pin runs `--check` and refuses `profile-drift` on exit 1. The apt hook
+  is `DPkg::Post-Invoke { "/usr/local/lib/mosaic-stack/case1-hostcheck.sh --enforce || true"; };`, so it
+  runs after every package run, unattended ones included, and can't fail one. The boot unit,
+  `mosaic-hostcheck.service` (`Type=oneshot`, `After=apparmor.service`,
+  `Before=mosaic-bus@mosaic-stack.service`, `WantedBy=multi-user.target`), runs `--enforce` before the
+  bus starts, which covers a kernel or parser change that takes effect at boot.
+- Owner. ops-01 owns the host side under a Mos go. It reads `hostcheck.log` in each STATE report and
+  sends any `DRIFT` to Mos. Before each re-pin window it also runs `--upstream`, which downloads the
+  current `apparmor-profiles` candidate into a temp dir and compares its `bwrap-userns-restrict` to the
+  pin. A difference goes to Mos as a new-pin request and refuses nothing. The pins and the scripts are
+  this row's, and later changes go through review like any other.
+
+Who runs what:
+
+| Step | Runs as | Through |
+|---|---|---|
+| 2a: `useradd --system --user-group --home-dir /srv/mosaic --shell /usr/sbin/nologin mosaic`, `/srv/mosaic` 0700, `/etc/mosaic-stack` `root:root` 0755, `/var/log/mosaic-stack` `root:root` 0750 | root | ops-01, `ssh localadmin@10.1.1.53`, `sudo` (#423 step 1) |
+| 2a': node under `/opt/mosaic-stack`; bubblewrap, the AppArmor profile, the statoverride, the drift stop and the managed settings file, each with the test and rollback above; the no-new-privs test | root | ops-01, same path, R27 (mos-1091) |
+| 2a'': a `git bundle` of the reviewed commit copied to .53; root clones it to `/root/mosaic-stack` and checks HEAD is the commit the go names; it installs the bundle as `/srv/mosaic/incoming/<sha>.bundle`, owner `mosaic`, 0600 | root | ops-01, same path |
+| 2b: claude under `~/.local` (above); `git clone` of the bundle to `/srv/mosaic/src/mosaic-stack`; `scripts/bootstrap.sh`; `stack-copy.sh copy`; the install with the inputs above (C2-13b's `case2-install.sh --profile factory` if it has landed, else the run sheet's steps) | `mosaic` | `sudo -u mosaic -H env PATH=...` from `localadmin` (PATH above). `mosaic` gets no key and no login shell |
+| 2b': place `claude-session.env` | Jason, or who he names (Q173 secrets rule) | section 3 |
+| 2c: write `case1-unit.args`; `case2-unit.sh` with those arguments and `--copy <id>`, from `/root/mosaic-stack`; then `case2-precheck.sh --profile factory` as `mosaic`, which reads the Console's `--port` from the installed unit for its port-floor line, so it runs after the render; `systemctl enable` the bus unit; the first start of UNITS. The Console unit has no `[Install]` until Jason rules (C2-13a), so it isn't enabled, and after a host reboot root starts it by hand until then. The run sheet says so | root | ops-01, same path |
+| 2c': `stack-release.sh adopt mosaic-stack --units external`, which records the running copy as the pointer (`do_adopt`, `scripts/stack-release.sh:856`) | `mosaic` | `sudo -u mosaic -H` |
+| every later re-pin or rollback | root, with its `mosaic` steps through `sudo -u mosaic -H` | ops-01 runs `case1-repin.sh` (section 4) |
+| acceptance (section 5) | `localadmin`, with `sudo -u mosaic -H` for the in-instance checks | the agent the window names |
+
+No git credential lands on .53. Both checkouts come from bundles that ops-01 copies in, and a re-pin
+brings a new bundle that `mosaic` fetches into its checkout.
+
+## 2. Where Case 1 differs from Case 2
+
+| Case 2 item (row 230 brief) | Case 1 | Reason |
+|---|---|---|
+| business file with the library mapping | business `mosaic-stack` with no `library` key; `--profile factory` refuses a `kind: "library"` project (`profile-library-business`) | the factory has no books repo |
+| `bean`, `chet`, persona vars and files, specialists | factory roles from `roles/`, with a chief that has a harness var | Jason names the set in the go. I haven't read his live business file and won't. The acceptance needs only the chief (F3), since a chief with no harness var answers `no-route`. Others are added later by the human with `instances.set`, no new row |
+| token slot `library-gitea` | none | the factory's per-agent git identity is row 199's credential store (Megavolt, #1697). Until it lands, git work stays on dragon-lin (Q182) |
+| precheck: `bus.tester` is not on | `bus.tester` is on; `factory` requires it | the acceptance and the Q173 test system need the tester (agents act as tester, never Jason) |
+| precheck: persona file modes and digests | skipped under `factory` | no persona files |
+| precheck: `library.sync`, `library.status` | skipped under `factory` | no library |
+| precheck: `ZAI_API_KEY` in the key file | doesn't run | no instance has provider `zai` |
+| precheck: no Discord binding | kept | the factory's Discord connector stays on dragon-lin. Two connectors on one bot token would split its events |
+| precheck: claude marker prompt with `--system-prompt-file` | runs, since the chief's harness is claude-code | |
+| precheck: `sudo -n true` fails, `id -G` one entry, run root 0700, config validates, node 24 or later, `bwrap` exits 0, free memory, HOME | kept | node and bwrap are in row 230 (gosalyn-0034) |
+| Console serve flags: `--port` 1..1023, `--business`, the preview trio, `--send`, the proof pair, no `--tester-port` | `--port 732`, `--business mosaic-stack`, `--tester-port 7333`. No preview trio, no `--send`, no proof pair | below |
+| bus: `@PM_FLAGS@` and `@CLAUDE_ENV@` render empty | ` --pm`, and `Environment=MOSAIC_CLAUDE_BIN=/srv/mosaic/.local/bin/claude` | below |
+
+All of these are inputs. Nothing in the Case 2 scripts hardcodes a Case 1 value (gosalyn-0034 item 4).
+Row 230's brief says the factory profile takes the library serve set plus an optional `--tester-port`,
+and that row 195 names any other difference (gosalyn-0049). .53 can't meet the library set, and the bus
+needs two lines the brief renders empty. The factory profile I need from row 230:
+
+1. Serve flags. `--port N` with N in 1..1023 and `--business ID` are required, and `--tester-port N` in
+   1024..65535, not equal to `--port`, is optional. The preview trio (`--public-host`, `--auth-header`,
+   `--allow-user`) and the proof pair (`--proof-header`, `--proof-file`) are refused. Both exist for a
+   proxy in front of the Console: the proxy signs the user in and adds the header, and the proof shows
+   the request came through it. .53 has no proxy. Jason reaches the Console with `ssh -L` (sage-1451
+   Q3), so there is no header to trust and no proxy to hold the proof. `--send` is refused too, since
+   serve takes it only with the trio or `--sso` (`packages/webui/src/cli.mjs:15`). When Q175 SSO reaches
+   .53, `--sso` with an optional `--send` (row 192) would be the factory's sign-in, and adding it is a
+   re-install with its own go. Row 230 can accept `--sso [--send]` under factory now or later. Either
+   way it needs a `console.sso` block in `mosaic`'s config, which this row doesn't write. `--checkout`
+   and `--board` stay refused, as in the library set.
+2. `--pm` (factory only) renders the bus unit's `@PM_FLAGS@` as ` --pm`. The factory's PM dispatches its
+   work on .53 as on dragon-lin (section 4). With the token empty the bus never launches the PM, and
+   A5's PM check fails every re-pin.
+3. `--claude PATH` (factory only) renders `@CLAUDE_ENV@` as `Environment=MOSAIC_CLAUDE_BIN=PATH`, the
+   line `scripts/bus-service.sh:79` renders today. PATH must be absolute. Without it the bus runs
+   `claude` from the unit's PATH, which is the node dir, `/usr/local/bin`, `/usr/bin` and `/bin`, and
+   holds no claude on .53. The chief's first launch would then fail. The precheck's claude marker
+   prompt should run the same binary, so it reads the path from the installed bus unit.
+4. Row 190's two template tokens, if row 190 lands before row 230. Row 190 adds `@CONFIG_ENV@` to both
+   templates and `@SESSION_ENV@` to the bus template's `EnvironmentFile=` line. For the default
+   instance, `@CONFIG_ENV@` is deleted (`scripts/instance.sh`) and `@SESSION_ENV@` is
+   `<home>/.config/mosaic-dev/secrets/claude-session.env`. Row 230's "every token has one value" list
+   and its `EnvironmentFile=` check need both. This applies to the library profile too.
+
+I've sent these to Gosalyn. If row 230's candidate lacks any of them, row 195's manifest names the
+change to `case2-unit.sh` or `case2-precheck.sh`, reviewed by Duckworth with Webby told.
+
+## 3. Model access
+
+Q185: Case 1 uses the account the factory uses today, the Claude subscription behind dragon-lin's
+`claude-session.env`. The install never copies that file from dragon-lin. In the window, Jason (or the
+person he names under the Q173 secrets rule) makes a credential for .53 from that account and writes it
+to `/srv/mosaic/.config/mosaic-dev/secrets/claude-session.env` as `mosaic`, mode 0600. Nobody prints it,
+and no script reads its value. The precheck checks only its mode, owner and that the variable name is
+present (a `grep -c` on the name, output a count).
+
+Quota: the factory on dragon-lin and on .53 share one subscription. Q185's "use existing" accepts that.
+Case 2 shares nothing with it (Mos's reading of Q185).
+
+The pi harness stays off on .53 until P19 #383 settles (mos-0865). The business file names claude only.
+
+## 4. Re-pin, rollback and backup on .53
+
+Unit form (ruled, sage-1451 Q1): system units that root writes, with `User=mosaic`. `mosaic` can't
+start or stop them, and root never runs code that `mosaic` can write. `stack-release.sh activate` today
+does everything in one run under `systemctl --user` and puts the old stack back inside that run
+(`rollback_in_run`, `scripts/stack-release.sh:561`). On .53 the same run needs two users. So one
+re-pin is one ordered list, and one root command drives all of it: `scripts/case1-repin.sh`, run by
+ops-01 from `/root/mosaic-stack`. Each `mosaic` step is `sudo -u mosaic -H` running
+`/srv/mosaic/src/mosaic-stack/scripts/stack-release.sh` with `--units external`. Copies carry no
+`stack-release.sh` (`COPY_PATHS`, `scripts/stack-copy.sh:23-30`), so the `mosaic` steps run from that
+checkout, as dragon-lin's run from the canonical one.
+
+What root holds, and where each value comes from (r4's B1):
+
+| Value | Source |
+|---|---|
+| ID, the target copy | the go |
+| TO, a rollback's target | the go, as `--to ID` |
+| `--restore ACT --events N` | the go, when the rollback restores |
+| OLD, the running copy | the `ExecStart=` of the two unit files root installed. If the bus and Console units name different copies, A1 refuses `units-disagree` |
+| the `case2-unit.sh` arguments | `/etc/mosaic-stack/case1-unit.args` (section 1) |
+| each `mosaic` step's result | its exit code |
+
+Root parses nothing `mosaic` wrote and runs nothing under `/srv/mosaic` except through `sudo -u mosaic
+-H`. It never needs the activation id: the `mosaic` steps find it themselves.
+
+One result line per activation (B1). The stack log closes an activation on the first line after
+`started` that names it, whatever the result (`interrupted`, :146-156). r4 wrote an interim
+`... rollback pending` line at A3's and A5's failures. That line closed the activation, so R2 and R4
+then refused `open-activation` against an activation the log no longer held open. The rollback could
+never run as designed, and nothing tested the steps in sequence. r5 keeps an activation open from A3's
+`started` line until its single result line, and A5 or R4 writes that line:
+
+| Activation ends at | Result line | Written by |
+|---|---|---|
+| A3 fails before its rollback set exists (marker or capture) | `refused code marker-failed` or `refused code capture-failed`, as `capture || refuse` does today (:987). Nothing has changed, so there is nothing to roll back | A3 itself, exit 3, after it removes the marker. Root runs A2f |
+| A5 passes | `ok` | A5 |
+| A3 (after capture), A4 or A5 fails, and the rollback passes | `failed code <c> rollback ok` for A3 and A4, `gate-failed code <c> rollback ok` for A5 | R4 |
+| the rollback fails at R4's gate | `rollback-failed code <c> rollbackCode <r>` | R4 |
+| R1, R2 or R3 fails, or the run dies | none. The activation stays open, and the next activate refuses `interrupted-run` (:603-606), which Jason or Mos settles as on dragon-lin | |
+
+What the result line carries (r5's B1). `log_line` (:58) writes `op "$OP"`, and `from_log` (:169)
+reads only lines whose op is `adopt`, `activate` or `rollback`. So `confirm` doesn't log under its own
+op. Before A5's `ok` line or any line R4 writes, it sets OP, FROM and TO from the open activation's
+`started` line, ACT to that activation, and BACKUP from the rollback set's `BACKUP` file, which A3
+writes when `backup_store` returns. A re-pin's lines then read `op activate`, a rollback's `op
+rollback`, each with the from, to and backup a dragon-lin run would log. `from_log previous` and
+`from_log backup` read .53's log as they read dragon-lin's. `confirm` reads only the line A3 wrote for
+that activation, which `interrupted` already names.
+
+A failing `mosaic` step after `started` writes no log line. It writes its code to `FAILED` beside
+`AWAITING-UNITS` and exits 1. R4 reads that code for the result line. Root passes R4 `--cause
+A3|A4|A5`, the step it saw fail, from its own exit codes. A4 is root's own step and has no `FAILED`
+file, so R4 writes `failed code units-start` for it. A cause with no `FAILED` file where one should be
+writes code `unrecorded`.
+
+The open activation. A3 writes `$STATE/stack-rollback/<ACT>/AWAITING-UNITS` holding the target copy
+(renamed from r3's `PENDING`, which read like the pointer's `pmPending`, `P_PENDING` at :128; N3).
+`confirm` and `revert` take the copy root passed, not an activation id. Each lists the
+`AWAITING-UNITS` files and the `interrupted` set (:146), and goes on only when there is exactly one
+file, its activation is the one `interrupted` names, and the copy in it is the copy root passed.
+Anything else refuses `open-activation` with exit 3 and the list it found, and changes nothing.
+`confirm` without `--rollback` also refuses `activation-failed` when `FAILED` exists, so a second
+confirm can't pass an activation that already failed. Whichever `confirm` writes the result line
+removes `AWAITING-UNITS` and `FAILED` after it.
+
+Refusals of the three external verbs. `confirm`, `revert` and `gate` act on an open activation by
+design, so they skip the `interrupted-run` refusal (:605). Their refusals log `result refused` with no
+activation id: they set ACT only after every check has passed. So a refused `confirm`, a wrong copy
+say, leaves the open activation open. Today's `refuse` (:62-67) adds the activation id whenever ACT is
+set, and the external verbs keep that order. A test and a mutant hold it (section 7).
+
+Root's step log. Every step `case1-repin.sh` runs appends one line to `/var/log/mosaic-stack/case1-repin.log`,
+`root:root` 0640: the time from `date -u`, the step, its argv, its exit code. `mosaic` can't write it,
+so it stays readable after a run that dies before `mosaic` logs anything.
+
+### Activate: `case1-repin.sh activate ID [--migrate] [--timeout S]`
+
+| # | Step | Runner | On failure |
+|---|---|---|---|
+| A1 | `/root/mosaic-stack` HEAD is the commit the go names. ID is 40 lowercase hex and names a copy under `/srv/mosaic/.local/share/mosaic-stack/copies` that holds `scripts/mosaic` (row 230's copy-id rule). `case1-hostcheck.sh --check` exits 0, else `profile-drift` (B2). Root reads OLD from the unit files. `stack-release.sh activate ID mosaic-stack --units external --plan --expect-from OLD` exits 0. The plan refuses `pointer-differs` when the pointer's copy isn't OLD (N5), so a pointer and units that disagree stop before any stop | root; the plan as `mosaic` | refuse, exit 3. Nothing has changed |
+| A2 | `systemctl stop` UNITS in reverse order, then wait until each is inactive, within `--timeout` | root | A2f below |
+| A3 | `stack-release.sh activate ID mosaic-stack --units external [--migrate]`. Before it logs `started` (N3), it refuses `units-running` unless each of UNITS is inactive (system-manager reads, which need no privilege) and the store is stopped (`stopped`, :359), and `interrupted-run` while any activation is open. Then, in this order: logs `result started`; makes `$RS` with capture's `mkdir -p` of `stack-rollback` and exclusive `mkdir -m 0700` (:415-416), and writes `AWAITING-UNITS` in it at once (N1); captures the rollback set into that directory, making none (pointer, wrapper, and the sha256 and `ExecStart=` of each installed unit, read only); takes `backup_store` (:372) into `$DATA/backups/stack/<ACT>` and writes its name to `BACKUP` in the rollback set; under `--migrate`, writes `MIGRATING` in the rollback set and sets TAKEN, both before `migrate-schema.mjs` runs, where today's run sets TAKEN (:1004-1005, r5's B2), then migrates; installs the wrapper for ID. It writes no pointer | `mosaic` | a refusal before `started` exits 3 with nothing changed. A marker or capture failure, an existing `$RS` included, removes the marker if it wrote one, logs its `refused` line and exits 3. Root runs A2f for both. Any later failure writes `FAILED` with its code, logs nothing, cleans up nothing and exits 1. Root runs R1-R4 with `--cause A3` |
+| A4 | `case2-unit.sh` with `case1-unit.args` and `--copy ID`, `systemctl daemon-reload`, `systemctl start` UNITS in order | root | R1-R4 with `--cause A4` |
+| A5 | `stack-release.sh confirm ID mosaic-stack --units external --timeout S`. This is `gate` (:522), which polls `gate_once` (:471) every second until `--timeout`, with the external checks below. On a pass it writes the pointer, logs `result ok`, removes `AWAITING-UNITS`, exit 0. When the timeout runs out it writes `FAILED` with the last gate code, logs nothing and exits 1 | `mosaic` | R1-R4 with `--cause A5` |
+
+Why A3 writes the marker first and does no cleanup of its own. With the marker written last, as in r4,
+an A3 failure after `started` left an open activation with no marker, and R2 and R4 refused it. With
+the marker first, every A3 failure after the marker leaves exactly what R2 needs: the open activation,
+its marker and whatever part of the rollback set exists. R2 is then the one cleanup path, for A3, A4
+and A5 alike. Two cleanup paths, A3's own and R2, would each need their own tests for each failure point.
+
+A2f, a stop that fails or times out, or an A3 that exits 3. This run has no open activation: A2 logs nothing, and
+A3's exit 3 comes either before `started` or after its own `refused` line. Nothing of `mosaic`'s has
+changed. Root reads `date -u +%s` as T, runs `systemctl start` UNITS in order, then `stack-release.sh gate
+OLD mosaic-stack --units external --since T --timeout S`, a new verb that runs `gate` on OLD and writes no
+log line, no pointer and no file. A2f has no `started` line to take a start floor from (the first
+re-pin after adopt has none at all), so `--since` is the floor, and `gate` refuses `usage` without it
+(r5's N2). T is root's own clock, so root still parses nothing `mosaic` wrote. A unit that never
+stopped keeps its old `ActiveEnterTimestamp`, fails `stale-start` and takes the exit 2 path below.
+If that passes, root logs `A2 failed, OLD running` (or `A3 refused`) in its step log and exits
+1. If it fails, root stops UNITS, logs `OLD gate failed <code>` and exits 2. The next run's
+`interrupted` check finds nothing open either way.
+
+The external gate. `gate_once` keeps its order and codes, with these changes under `--units external`:
+
+- `systemctl` without `--user` for `is-active` and `show`. Both work unprivileged against the system
+  manager.
+- This start's time is the bus unit's `ActiveEnterTimestamp`, read with `systemctl show --timestamp=unix
+  -p ActiveEnterTimestamp`, in place of the `START_MS` that `start_both` (:451) sets on dragon-lin.
+  It is whole seconds (`@1792540800`), and the `started` line has milliseconds (N4). So the rule
+  compares seconds: the start passes when its second is at or after the floor of `started`'s second.
+  A unit that was active across A3 can't reach this check, because A3 refuses `units-running`, so the
+  equal second can only be a start after A3. An earlier second fails `gate_once` with the gate code
+  `stale-start`. It's a gate failure like any other, not a refusal (r4 had it as a refusal, which
+  would have logged against the open activation): `gate` keeps polling, since `Restart=on-failure`
+  can bring a fresh start, and at the timeout `FAILED` holds `stale-start`. The PM check's
+  `startedAt` bound uses the same second.
+- `copy-check` runs `stack-copy.sh check --units external`, which reads the system units.
+- The PM check is below.
+
+The PM (r4's B2). .53 runs the PM: the factory's PM dispatches its work, as it does on dragon-lin, and the
+serve flags carry `--pm`. The pointer's `pm` comes from the installed bus unit's `ExecStart=`, as the
+unit parse at :195 already reads it. Today's `pm_launched` (:505) takes the run id from the
+`launched ...` line in `journalctl --user -u BUS_UNIT`. On .53 that read fails twice over: the unit is
+a system unit, and under `SplitMode=uid` the logs of a system-range uid land in the system journal,
+which `mosaic` (no `adm` or `systemd-journal` group) can't read. Under `--units external` the check
+reads `launches list --json` alone. It passes when exactly one entry has business `mosaic-stack`,
+instance equal to the business file's `launch.by` (the PM's instance, the one `bus start --pm` launches
+at `packages/cli/src/launcher.mjs:675`), `live` true, and `startedAt` at or after this start's time.
+Zero entries, two, a stale one or one for another business fail with `pm-launch-unconfirmed` and what
+it saw, as today. A run the PM starts for another role has another instance, so it doesn't count.
+
+Why not the other reads. A regular uid for `mosaic` would put its logs in a per-user journal it can
+read, but it changes the account Case 2's install creates. Root reading the journal and passing the run id in
+would make root parse output from `mosaic`'s process, which section 4's rule forbids.
+
+Under `--units external`, `pm-on` (:1137) and `activate --pm-after-harness` refuse `external-pm`. Both
+flip the PM on dragon-lin by restarting the user bus with new arguments. On .53 the PM's state is a
+serve flag in a root-owned unit, so changing it is a re-install with its own go.
+
+### Rollback inside the run (R1-R4)
+
+| # | Step | Runner | On failure |
+|---|---|---|---|
+| R1 | `systemctl stop` UNITS, then wait as in A2 | root | rollback-failed |
+| R2 | `stack-release.sh revert ID mosaic-stack --units external`. It finds the open activation as above, puts the wrapper back from the rollback set and checks its sha256, and restores TAKEN (`restore_store`, :396) only if the rollback set holds `MIGRATING`. Each part is idempotent, so it works for an A3 that stopped partway: no `MIGRATING` means no restore, a migrate that failed partway is restored from the backup taken before it, and copying the saved wrapper over an unchanged one changes nothing. It writes no log line | `mosaic` | rollback-failed, activation left open |
+| R3 | `case2-unit.sh` with `case1-unit.args` and `--copy OLD`, `systemctl daemon-reload`, `systemctl start` UNITS | root | rollback-failed, activation left open |
+| R4 | `stack-release.sh confirm ID mosaic-stack --units external --rollback OLD --cause A3\|A4\|A5 --timeout S`. It finds the open activation, checks OLD is its `from`, gates OLD with `gate`, and writes the activation's one result line from the cause and the `FAILED` code: `failed code <c> rollback ok` (A3, A4), `gate-failed code <c> rollback ok` (A5), or `rollback-failed code <c> rollbackCode <gate>` when OLD's gate fails | `mosaic` | rollback-failed, logged |
+
+rollback-failed: root stops UNITS and exits 2, as `rollback_failed` (:587) does. When R4's gate fails,
+the log has the `rollback-failed` line and the activation is closed. When R1, R2 or R3 fails, no
+`mosaic` step writes a result, so the activation stays open with its marker. Root's step log has the
+codes, the next activate refuses `interrupted-run` until Jason or Mos settles it (:605), and status
+shows it. I chose that over a log-only verb for root to call after an R2 failure: nothing could gate
+the old stack at that point, and a closed activation would let the next activate start against a
+wrapper and store in an unknown state. Exit codes match `stack-release.sh`: 0 ok, 1 failed with the old
+stack running (rolled back, or A2f), 2 rollback-failed with UNITS stopped, 3 refused with nothing
+changed.
+
+### Rollback to the previous copy: `case1-repin.sh rollback --to ID [--restore ACT --events N]`
+
+The same list with TO in place of ID. The go names TO, from Mos's or Sage's read of `stack-release.sh
+status` as `mosaic`. Root passes it. A1's plan, `stack-release.sh rollback mosaic-stack --units external
+--to ID --plan --expect-from OLD`, refuses `pointer-differs` as in activate. It also exits 3 unless ID
+is `from_log previous` (:162), the previous distinct copy, so a
+stale or mistyped go refuses before anything stops. With `--restore`, the plan also refuses unless
+`$DATA/backups/stack/ACT` exists. `--to` is a new flag, accepted only with `--units external`;
+dragon-lin's rollback keeps reading TO from the log.
+
+The post-backup event count runs in A1's plan as `mosaic` while the bus still holds the store (the
+`heldcount` read, :1074), and again in A3 on the stopped store. A difference refuses
+`post-backup-events`, as `run_steps` does (:1013).
+
+### Migrations (N4)
+
+`--migrate` under `--units external` runs only inside A3, and A3 refuses `units-running` before it logs
+or migrates anything while any of UNITS is active. So a migration never runs against a store a live bus
+holds. The test is in section 7.
+
+### Backup
+
+A3's `backup_store` is today's. It copies the stopped store into `$DATA/backups/stack/<ACT>`, so
+`rollback --restore <ACT>` and row 181's guard find it. As on dragon-lin, the config dir isn't in the
+backup, and the credential isn't either. PBS backups of VM 1008 cover the disk (P4). A restore swaps
+only `bus/` and leaves `secrets/claude-session.env` in place (N6, in the run sheet).
+
+The install's adopt (2c') takes no backup. The store holds only what the acceptance wrote, and the first
+re-pin's A3 takes the first backup.
+
+### The log
+
+Every `mosaic` line goes to `$DATA/state/stack-activation-log.jsonl`, as today, with `units external`
+added. So `from_log previous` reads .53's history the same way it reads dragon-lin's. A3 writes
+`started`. A5 or R4 writes the one result line, with the op, from, to and backup of that activation,
+or A3 its `refused` line before any change. Refusals of
+`confirm`, `revert` and `gate` log no activation id. If a run dies between `started` and the result,
+the log keeps `started` with no result, the next run's `interrupted` check reports it, and root's step
+log shows the last step that ran.
+
+### Who
+
+Mos or Sage plans each re-pin. ops-01 runs `case1-repin.sh` on Jason's or Mos's go, and a STATE report
+follows. The gate and the in-run rollback have one owner, the root command, as they do on dragon-lin.
+
+### dragon-lin's path
+
+`--units external` is a new value. Without it, `stack-release.sh` and `stack-copy.sh check` run as they
+do today, `pm_launched` still reads the user journal, and rollback still takes TO from the log.
+`confirm`, `revert`, `gate` and `--to` refuse without it. Section 7 names the tests that show this.
+
+### Not taken
+
+- Row 190's user units under `mosaic`, with root running `loginctl enable-linger mosaic` once. Every
+  existing re-pin tool would work unchanged and root would be needed only once. But the unit form
+  would differ from Case 2, and a user manager would run as `mosaic`.
+- A sudoers rule that lets `mosaic` start and stop the units. P1 and row 230's precheck require that
+  `mosaic` has no sudo.
+- `confirm` and `revert` taking ACT from root. Root would have to read it from `mosaic`'s output or
+  log, which the rule above forbids (r4's B1).
+
+## 5. Acceptance checks
+
+A new script, `scripts/case1-accept.sh`, in this row's manifest. It runs on .53 as `localadmin` and prints
+one line per check: `<id> <path> <mark> <evidence>`. The marks are `closed`, `accepted Q182`,
+`accepted Q183`, `accepted mos-1096`, and `unnamed`, which means "not named in Q182, Q183 or a Mos
+ruling". The script ends with a count of each mark. It exits non-zero only when a functional check (F)
+fails. A P check never changes the exit status. Each `unnamed` line goes to Mos, who takes it to Jason
+(R8 N1).
+
+Functional checks. Any failure fails the row:
+
+| Id | Check | How |
+|---|---|---|
+| F1 | the units run as `mosaic` | `systemctl show <unit> -p User -p MainPID` for each of UNITS; each MainPID's uid in `/proc/<pid>/status` is `mosaic`'s, and each unit is active |
+| F2 | the Console listens on 127.0.0.1:732 on .53 and answers there | `curl -fsS http://127.0.0.1:732/healthz` on .53 succeeds, and the listener table shows 732 bound to 127.0.0.1 only, by the Console unit's MainPID. Jason reaches it with `ssh -L 7332:127.0.0.1:732 localadmin@10.1.1.53` and his browser at 127.0.0.1:7332 as today. A LAN listener waits for Q175 SSO (sage-1451 Q3) |
+| F3 | one tester message gets a reply | as `mosaic`: `mosaic talk chief <marker> --tester`, then `mosaic follow --tester`, with a 300 s limit. A stored reply to the marked message passes. The inbox alone shows decisions only, so it isn't used (N3) |
+| F4 | the precheck passes | `case2-precheck.sh --profile factory` exits 0 as `mosaic` |
+| F5 | a role session runs under bwrap with the profile | while F3's reply is pending: a `/usr/bin/bwrap` process owned by `mosaic` has a claude process under it. `/proc/<bwrap pid>/attr/current` equals `bwrap (enforce)` and the claude process's equals `bwrap//&unpriv_bwrap (enforce)`, each compared as an exact string after the trailing newline is cut (N1). If `launches list --json` records the sandbox, the build reads that for the first part, since a short session can end before `ps` sees it |
+| F6 | claude is the pinned version | `/srv/mosaic/.local/bin/claude --version` as `mosaic`, after F3, equals the run sheet's pin |
+| F7 | the PM run is live | `launches list --json` as `mosaic` has exactly one live entry for the PM's instance, the check `confirm` runs (section 4) |
+
+Privilege and host paths. These report and never fail the row:
+
+| Id | Path | Mark | Evidence the script prints |
+|---|---|---|---|
+| P1 | `mosaic` has sudo | closed only when `sudo -l -U mosaic` prints "is not allowed to run sudo" (N2); any other output is unnamed | the `sudo -l` result |
+| P2 | `mosaic` has supplementary groups or a key | closed when `id -G mosaic` is one entry and `~mosaic/.ssh/authorized_keys` is absent or empty | `id`, file state |
+| P3 | `localadmin` NOPASSWD sudo, reached with the dragon-lin key | accepted Q183 (agents keep ssh to .53; localadmin from #423 step 1) | `sudo -l -U localadmin` |
+| P4 | root on pve over VM 1008, and PBS backups of VM 1008, which hold `/srv/mosaic` including the credential | accepted Q182 and Q183 (agents keep root on pve and PBS) | a fixed line; the script can't see pve from inside |
+| P5 | `jarvis`, which runs Hermes, can reach `/srv/mosaic` through sudo, or through the docker or lxd groups, which are root-equivalent | closed when `jarvis` is in none of sudo, docker and lxd; unnamed otherwise. #423 step 4 lands before the install (mos-1091 4c), and its `step4.sh` removes `jarvis` from sudo, docker, lxd and adm, so after it this reads closed (Duckworth N2) | `id jarvis` |
+| P6 | other members of sudo, docker, lxd | closed when sudo holds only `localadmin` and docker and lxd are empty. Every other member is its own unnamed line, `jarvis` included (N1) | `getent group` lines |
+| P7 | a file under `/etc/sudoers.d` naming `mosaic` | closed when none | the file names |
+| P8 | the Console or tester reachable from the LAN | closed when 732 and 7333 are bound to 127.0.0.1 only, each by the Console's MainPID, and nothing listens on 7331 | listener table |
+| P9 | a user namespace through `/usr/bin/bwrap` | accepted mos-1096 only while all seven hold, unnamed otherwise: (1) `dpkg-statoverride --list /usr/bin/bwrap` reads `root mosaic 0750`; (2) `aa-status --json` lists `bwrap` and `unpriv_bwrap` in enforce mode; (3) `/etc/apparmor.d/bwrap-userns-restrict` has the pinned sha256 and no package owns it; (4) `sudo -u jarvis /usr/bin/bwrap --version` fails with "Permission denied"; (5) `getent group mosaic` lists no member and no other account in `/etc/passwd` has its gid; (6) `fs.protected_hardlinks` is 1; (7) no `mosaic-bwrap` profile is loaded, no other file under `/etc/apparmor.d` names `bwrap`, and the live label of a process bwrap runs is exactly `bwrap//&unpriv_bwrap (enforce)` (N1, mos-1098 point 2). Items 1-3, 6 and 7 are `case1-hostcheck.sh --check`'s, so P9 reuses its lines | each item's line, and Mos's reason: "Case 1's agents are the factory's agents. In Q182 and Q183 Jason accepted that the factory reaches root on pve and, through it, every VM. So a user-namespace path to root on .53 gives that class no new reach." With the profile, what's left is bwrap's own setup, run by `mosaic` |
+| P10 | a session binds the tester port, 7333, while the Console is down | accepted mos-1101 while `ip_unprivileged_port_start` is above 732 and 7333 is held by the Console's MainPID at the check. Serve refuses a tester port below 1024 (`cli.mjs:33`), so the Console-port fix can't cover it. A squatter would get the tester's writes and could answer them. The tester's users are the factory's agents, the class Mos's reading covers (mos-1101 item 5). Mos can object, and then this line reads unnamed | the floor, and the owner pid of 7333 |
+
+Tests, in `packages/cli/tests/case1-accept.test.mjs`. The script takes a fake root (`--root DIR`) for
+`/proc`, `/etc` and `getent` output, and fake `systemctl`, `curl`, `ss`, `sudo`, `bwrap`, `aa-status`,
+`dpkg-statoverride`, `sysctl` and `claude` on PATH. Cases:
+- each F check failing gives a non-zero exit with its line;
+- each P check in each of its marks, including P1 with output that grants nothing but lacks the refusal
+  text (unnamed), P9 unnamed once for each of its seven items missing, and P10 unnamed with a floor of
+  700 and with 7333 held by another pid;
+- F5 fails on a label of `unpriv_bwrap (enforce)`, `bwrap//&unpriv_bwrap (complain)` and
+  `bwrap (enforce)` with a trailing space;
+- a run with every P check `unnamed` still exits 0;
+- the summary counts match the lines.
+
+Mutants: one per F check (the check made to pass on failure), one that maps P5 to `closed`, one that
+closes P1 on any output without a rule line, one that drops P9's jarvis item, one that drops P9's item
+7, and one that makes F5 a substring match.
+
+Nothing in the tests reaches .53 or dragon-lin's live state.
+
+## 6. Rulings
+
+sage-1451:
+
+- Q1, unit form: the brief's system unit. C2-13's `ExecStart=` check accepts a varying copy id, and
+  C2-13 took that (gosalyn-0034 item 3).
+- Q3, the Console: it listens on 127.0.0.1 on .53 (`packages/webui/src/serve.mjs:466`; `cli.mjs` passes no
+  host), and Jason reaches it with `ssh -L`. F2 says so. A LAN listener waits for Q175 SSO.
+- Q4, the date: if C2-13's candidate is late, I build on C2-13's latest commit and rebase (Q177). Under
+  the #426(a) push rules (mos-1086) a rebase goes to a new branch name.
+
+mos-1091 (none goes to Jason):
+
+- Q2 4a: installing bubblewrap is an install step, run by ops-01 as root under R27. Rollback is
+  `apt-get remove`.
+- Q2 4b: a per-binary AppArmor profile for `/usr/bin/bwrap`, the sysctl left at 1. r4 takes Ubuntu's
+  `bwrap-userns-restrict` for it (mos-1096). Section 1 has the steps.
+- 4c: P5 ends at #423 step 4, which Mos sent to Duckworth so it lands in Jason's VM 1008 boot session,
+  before the install. The P5 check stays.
+
+mos-1096:
+
+- B1 and B2 are mine, and so is the PM answer: .53 runs the PM (section 4).
+- The `dpkg-statoverride` on `/usr/bin/bwrap`, the hardlink and group checks, the jarvis refusal and F5
+  under the profile (sections 1 and 5).
+- P9 is Mos's acceptance, with the reason quoted in section 5.
+- Jason's Q9 on install and upgrade is open. r4 goes ahead, since B1's re-pin and rollback are needed
+  whatever he answers. If his answer changes how upgrades reach .53, the change lands in section 4 and
+  the run sheet as a new round.
+
+mos-1098 and mos-1101 (on Duckworth's REVIEW-r3):
+
+- Duckworth's CHANGES stand. B1 and B2 are fixed in this round, with B1's real-sequence test, and all
+  three of B2's asks: an owner across upgrades, what fails closed, and the pins as reviewed values.
+- r4's PM, statoverride and P9 stand. mos-1098's two questions are answered in section 1: the profile's
+  owner across upgrades is ops-01 with `case1-hostcheck.sh`, and the stop is bwrap closed to `mosaic`.
+  Both profiles attach to `/usr/bin/bwrap`: `bwrap` to the binary and `unpriv_bwrap` stacked on what it
+  runs. P9 item 7 checks that no third one does.
+- P9 has seven items and F5 compares exact strings (N1).
+- The port squat applies (section 1). The Console takes Case 2's fix, a port below 1024 with
+  `CAP_NET_BIND_SERVICE` and the floor checked. Only the tester port can't take it, and P10 records it
+  under Mos's reading that Case 1's sessions are the factory class. I've told Mos, who can object.
+- Work on r5 goes ahead while Jason's Q9 (Vikunja #429) is open. If install and upgrade become
+  product commands, these steps become that installer's configuration and row 195 rebases on its row
+  (sage-1481, sage-1491).
+
+sage-1499: C2-13a is row 230 (#1732, Gosalyn), and row 195 chains on row 230's candidate.
+
+gosalyn-0049: the factory profile is the library set plus an optional `--tester-port`, and row 195 names
+any other difference. Section 2 names four, with the reason .53 can't meet the preview trio, `--send` or
+the proof pair. The managed-settings route needs no Case 2 change.
+
+## 7. Manifest (planned)
+
+- `scripts/case1-repin.sh` (new) and `packages/cli/tests/case1-repin.test.mjs` (new). Fake `systemctl`,
+  `sudo` and `case2-unit.sh` on PATH record their argv, with a scratch home standing in for `/srv/mosaic`,
+  a scratch dir for `/etc/mosaic-stack` and one for `/var/log/mosaic-stack`. Cases:
+  - a pass runs A1-A5 in order;
+  - a failure at A3, A4 or A5 runs R1-R4 with `--cause` set to that step, and exits 1;
+  - an A3 exit 3 runs A2f, not R1-R4;
+  - a failure at R2 or R4 exits 2 with UNITS stopped;
+  - A1 refuses `profile-drift` when a fake `case1-hostcheck.sh --check` exits 1, before any stop;
+  - every `mosaic` step's argv carries `env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin`, with the node
+    dir from `case1-unit.args`;
+  - a HEAD mismatch, an ID that fails the copy-id rule, or unit files that name two copies refuses with
+    exit 3 before any stop;
+  - A1's plan argv carries `--expect-from` with OLD from the unit files;
+  - A2f passes `gate OLD --since T`, with T from a fake `date` that root calls before its start;
+  - A2f: a fake `systemctl` that never reports inactive. The script starts UNITS, runs `gate OLD`, exits
+    1 with OLD's gate passing and 2 with it failing, and the stack log is byte-identical before and
+    after;
+  - `rollback --to` with an ID that isn't `from_log previous` exits 3 before any stop;
+  - every exec of a path under the home goes through `sudo -u mosaic -H` (from the recorded argv);
+  - no argv root passes holds an activation id, and OLD comes from the unit files, not from anything
+    the `mosaic` steps print;
+  - every `case2-unit.sh` call carries the arguments in `case1-unit.args` and differs only in `--copy`;
+  - the step log has one line per step with its exit code.
+- `scripts/stack-release.sh`: `--units external` for `adopt`, `activate`, `rollback` and `status`, the
+  `--to` flag for an external rollback, and the new `confirm`, `revert` and `gate` verbs, which refuse
+  without it. `scripts/stack-copy.sh`: `check --units external`, which reads the system units. Tests in
+  `packages/cli/tests/stack-release-external.test.mjs` (new), against a fake system-scope `systemctl`
+  and a fake `mosaic` for `bus status` and `launches list`:
+  - `units-running` refuses while any unit is active, and `activate --migrate` with a unit active
+    leaves the store, the log and TAKEN as they were (N4);
+  - activate leaves the pointer as it was, writes `AWAITING-UNITS`, and writes a backup of the stopped
+    store under `$DATA/backups/stack/<ACT>`;
+  - `confirm` and `revert` refuse `open-activation` with zero `AWAITING-UNITS` files, with two, with
+    one whose copy isn't the one passed, and with one whose activation isn't in the `interrupted` set;
+  - `confirm` polls: a fake bus whose status turns good after 3 s passes with `--timeout 10` and fails
+    with `--timeout 1`;
+  - `stale-start` (N4): with `started` at 1792540800.900, an `ActiveEnterTimestamp` of `@1792540800`
+    passes and `@1792540799` fails `gate_once` with `stale-start`. A fake that turns to `@1792540805`
+    after 2 s passes with `--timeout 10`, which shows it's a gate code that polling can clear, not a
+    refusal;
+  - `confirm` on a pass writes the pointer, logs `ok` and removes `AWAITING-UNITS`. On a timeout it
+    writes `FAILED` with the gate code, leaves the pointer, the log and the marker as they were, and
+    exits 1;
+  - `confirm` without `--rollback` refuses `activation-failed` when `FAILED` exists;
+  - every line `confirm` writes has op `activate` or `rollback`, never `confirm`, and the from, to and
+    activation of its `started` line, and backup equal to the rollback set's `BACKUP`;
+  - `gate` (N2): with `--since 1792540800`, `@1792540800` passes and `@1792540799` fails `stale-start`;
+    without `--since` it refuses `usage`;
+  - `--plan --expect-from` (N5) refuses `pointer-differs` when the pointer names another copy, for
+    activate and for `rollback --to`;
+  - A3's order: a fake that fails the capture leaves the log with `started` and `refused code
+    capture-failed` for that activation, no marker and no `FAILED`, and exit 3. An existing `$RS`
+    gives `refused code marker-failed` and exit 3, and a capture under `--units external` makes no
+    directory of its own. A fake that fails the
+    wrapper install after a migration leaves `started` only, the marker, `FAILED`, TAKEN as migrated,
+    and exit 1;
+  - refusals by `confirm`, `revert` and `gate` log with no activation id, and the `interrupted` set
+    is the same before and after each one;
+  - the PM check passes with one live entry for the PM's instance since the start, and fails
+    `pm-launch-unconfirmed` with none, with two, with one whose `startedAt` is before the start, with one
+    not live, and with one for another business. A second live entry for another instance doesn't
+    count. A fake `journalctl` on PATH records any call, and no external run makes one;
+  - `pm-on` and `activate --pm-after-harness` refuse `external-pm`;
+  - `revert` puts the wrapper back, and restores TAKEN only after a migration;
+  - `confirm --rollback OLD` writes the line for each `--cause` (A3 and A4 `failed`, A5 `gate-failed`,
+    with the `FAILED` code, `units-start` for A4, `unrecorded` when the file is missing), or
+    `rollback-failed` when OLD's gate fails. It removes the marker and `FAILED` after the line, and
+    refuses when OLD isn't the open activation's `from`;
+  - real sequences on one log (B1). The fake `sudo` execs the real `stack-release.sh` as the test's
+    user, so each step reads the log and state the last one wrote. Fakes stand in only for
+    `systemctl`, `mosaic` and `case2-unit.sh`. Each sequence ends with the log holding exactly one
+    `started` and one result line for its activation, an empty `interrupted` set, no marker or
+    `FAILED`, and a following `activate --plan` that doesn't refuse `interrupted-run`:
+    1. activate, confirm times out, revert, `confirm --rollback --cause A5` passes:
+       `gate-failed code <c> rollback ok`;
+    2. activate with `--migrate`, the wrapper install fails, revert restores TAKEN, `confirm --rollback
+       --cause A3`: `failed code <c> rollback ok`;
+    3. activate, root's A4 fails, revert, `confirm --rollback --cause A4`: `failed code units-start
+       rollback ok`;
+    4. activate whose capture fails: `refused code capture-failed` and nothing open, then A2f's
+       `gate OLD` writes nothing;
+    5. activate, then `confirm` with the wrong copy is refused, then revert and `confirm --rollback
+       --cause A5` still close the activation, because the refusal didn't;
+    6. activate, revert fails (a wrapper whose saved copy is missing): the activation stays open, and
+       the next `activate --plan` refuses `interrupted-run`;
+    7. adopt C0, activate C1 and confirm, activate C2 and confirm (r5's B1): both `ok` lines read
+       `op activate` with their `started` line's from and to and the backup each took. `rollback --to C1
+       --plan` exits 0 and `--to C0 --plan` refuses. A rollback to C1, confirmed, logs `op rollback`, and
+       `from_log previous` then names C2;
+    8. activate with `--migrate`, where the copy's `migrate-schema.mjs` is a fake that writes to the
+       store and exits 1 (r5's B2): `FAILED` holds `migrate-failed` and `MIGRATING` exists. revert
+       restores the store byte-identical to the backup, and `confirm --rollback --cause A3` gates OLD on
+       it: `failed code migrate-failed rollback ok`;
+  - `rollback --to` refuses when ID isn't `from_log previous`, and `rollback --restore` finds a backup
+    that an external activate took;
+  - `gate` writes nothing: the log, the pointer and the state dir are byte-identical before and after;
+  - `confirm`, `revert`, `gate` and `--to` refuse without `--units external`.
+- dragon-lin unchanged. `stack-release.test.mjs` and `stack-copy.test.mjs` run unchanged and green. A
+  new case in `stack-release-external.test.mjs` runs a default activate, rollback and check against a
+  fake `systemctl` that records argv, and every call carries `--user`. A default `activate --plan`
+  prints the same bytes on the candidate as on its base, with the base output as a fixture.
+- Mutants for the re-pin:
+  - `confirm` writes the pointer on a gate failure;
+  - `confirm` calls `gate_once` once in place of `gate`;
+  - the external PM check counts entries of any instance;
+  - the external PM check drops the `startedAt` bound;
+  - `confirm` takes the newest `AWAITING-UNITS` instead of refusing two;
+  - `rollback --to` skips the `from_log previous` comparison;
+  - `case1-repin.sh` skips R1-R4;
+  - `case1-repin.sh` exits 0 after A2f;
+  - `case1-repin.sh` runs `mosaic`'s `stack-release.sh` without `sudo -u mosaic`;
+  - the default path drops `--user` from one `systemctl` call;
+  - `confirm`'s timeout writes r4's interim `gate-failed ... rollback pending` line (B1; killed by
+    sequences 1 and 5);
+  - A3 writes `AWAITING-UNITS` last, after the wrapper (killed by sequence 2);
+  - an external verb's refusal logs with the open activation id (ACT set before the checks; killed by
+    sequence 5 and the refusal test);
+  - `stale-start` is a refusal again (killed by the polling case);
+  - `revert` restores TAKEN without `MIGRATING` (killed by the revert case);
+  - `confirm` logs with its own op, `confirm` (killed by sequence 7 and the op case);
+  - A3 writes `MIGRATING` after `migrate-schema.mjs` (killed by sequence 8);
+  - `gate` takes its floor from the newest `started` line when `--since` is missing (killed by the
+    `gate` case).
+- `scripts/case1-pins.sh` and `scripts/case1-hostcheck.sh` (new),
+  `packages/cli/systemd/mosaic-hostcheck.service` (new) and `packages/cli/tests/case1-hostcheck.test.mjs`
+  (new). The script takes `--root DIR` for `/etc`, `/proc/sys` and `/usr/bin/bwrap`'s stat, and fake
+  `aa-status`, `dpkg`, `dpkg-statoverride`, `apparmor_parser`, `systemd-run`, `chown` and `chmod`
+  on PATH record their argv. Cases:
+  - `--check` exits 0 with all seven items and 1 with each one failing alone, its line naming it;
+    item 3 fails on a second file naming `bwrap` as a word, one that writes `/{usr/,}bin/bwrap` included,
+    and passes with `bwrap-userns-restrict` alone. Item 4 fails on a label of `unpriv_bwrap (enforce)`
+    or one with a trailing space, and its `systemd-run` argv carries `-p NoNewPrivileges=yes` and the
+    other 2a' properties. Item 7 fails with the floor at 732;
+  - `--enforce` exits 0 on a pass and on every failure. On a failure it unloads the profile, closes
+    bwrap to `root:root` 0700, writes `DRIFT` and one log line. With `DRIFT` present and every item
+    passing, it still closes bwrap;
+  - `--enforce` never calls `dpkg-statoverride` with `--update`, `--add` or `--remove`;
+  - a bubblewrap version other than the install pin is a printed line, not a failure;
+  - `--upstream` against a fake deb whose file differs prints the difference and exits 0;
+  - the service unit has `Type=oneshot`, `After=apparmor.service`,
+    `Before=mosaic-bus@mosaic-stack.service` and runs `--enforce`.
+
+  Mutants: `--enforce` exits 1 on a drift; `--enforce` ignores `DRIFT` when the items pass; item 1
+  drops the `dpkg -S` owner check; item 3 matches only the `/usr/bin/bwrap` path; item 4 matches a
+  substring; item 4 drops `-p NoNewPrivileges=yes`; item 7 compares with `>=`.
+- `scripts/case1-accept.sh` (new) and `packages/cli/tests/case1-accept.test.mjs` (new), section 5.
+- Row 230 (C2-13a). `--profile`, the node, bwrap and port-floor precheck lines, the copy-id rule, the
+  two units and the Console's capability lines are in its brief at 5b8def2f1. Section 2's four items
+  are not. Any of them that row 230's candidate lacks becomes a named change here, reviewed by
+  Duckworth with Webby told. I told Gosalyn earlier that the settings-file route for
+  `DISABLE_AUTOUPDATER` doesn't reach a role session, and that Case 1 uses the managed settings file.
+- Docs: the Case 1 run sheet `docs/guides/case1-install.md` (new). It lists the window's steps in order,
+  each with who runs it and its go, the pinned node sha256 and claude version, a pointer to
+  `case1-pins.sh` for the bubblewrap and profile pins, the statoverride, the drift stop and the managed
+  settings file, each with its rollback, how ops-01 clears a `DRIFT`, the `ssh -L` line for port 732,
+  and a note that a restore leaves the credential in place.
+- No change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, dragon-lin's units or `~/.mosaic`.

agents/gizmoduck/work/machine-grant/DESIGN.md

@@ -1,926 +0,0 @@
-# Machine grant path, design draft r6 (Vikunja #436, row 210 follow-up)
-
-Owner: Gizmoduck. Reviewer: Duckworth. Sizing and row assignment: Sage. Design only. Code starts when
-Duckworth approves the design and row 210 lands (sage-1527).
-
-Sources: Q188 (DECISIONS.md:1642, jason-master-restart 8ecf252), mos-1115, mos-1120, mos-1125, mos-1127, mos-1131, mos-1133, mos-1139,
-sage-1527, Duckworth's r1 review (REVIEW-r1.md, duckworth/reviews d025ef492, corrected at 749080115), Duckworth's
-r3 and r4 review (REVIEW-r3.md, duckworth/reviews 9dceb2148, duckworth-0060), Duckworth's r5 diff check
-(REVIEW-r5.md, duckworth/reviews c3dc58f30, duckworth-0063),
-Honker's PRD 1.8 draft (honker/row194-b2 3c30f1036, REQ-TRUST-2 and REQ-GRANT-1 to -4), row 210 DESIGN r3
-(e021dfa26) and its approved candidate 455964f23. Code cites are `path:line` at origin/refactor f41729178
-unless they say "210:", which means the row 210 candidate 455964f23 (the same code as the branch head
-a2fd30390). Host facts come from ops-01's read-only check of .53 and .54 at 22:21Z (mos-1127).
-
-## r6 changes (from r5 7686fd783)
-
-Duckworth approved r5 with C1 and one note (duckworth-0063). The design is approved for code once row 210
-lands. r6 carries C1 and the note, for a diff check on those lines.
-
-- C1: a revoke can't be undone by a commands-change undo. After step 5 commits, the executor ignores an
-  abort (X5). Both undo paths that set a record back to `previous` only update a record that exists, never
-  insert one, and do nothing when a `grant.revoked` is newer than the decision (X3). G28 and an upsert
-  mutant cover it.
-- N1: a failed unlink at revoke step 2 no longer depends on the marker. At start, after the grant
-  reconcile, the bus unlinks every `host.<id>` key file that has no `host_grants` record (section 6, G27).
-
-## r5 changes (from r4 1c5705d6d)
-
-Duckworth's review of r3 and r4 (duckworth-0060) asked for changes, B1 and B2, with notes N1 to N11. mos-1139
-says to fix both and rules on N8.
-
-- B1: E2 step 1 is now one transaction: `#consumeGrant`, a check that the host isn't enrolled yet, then the
-  insert. A second approved enrollment for the same `hostId` ends `grant.failed host-enrolled`. `hosts` gets
-  the primary key (business, host id) in `3i-3j.sql`. G17 and two mutants cover it.
-- B2: X2 consumes first and claims second, in one turn of the event loop. A busy claim ends `grant.failed
-  host-busy` with a message. At start, a grant decision resolved yes with no `action.allowed` ends
-  `grant.failed interrupted` and never runs late (X3). `hosts.revoke` records `grant.revoked` even with no
-  reference and no claim, so X5's first bullet now matches the code. G11 and G23 cover it.
-- N1: the `ID_PATTERN` cite is marked `210:`.
-- N2: X5 states the build rule that `issue` and its `commit` stay synchronous, with a mutant.
-- N3, N4: `hosts.revoke` is its own verb in `bus/src/host-grants.mjs`, not 210's `credential-verbs.mjs`. It
-  writes a `pending` marker first, and the start reconcile finishes a revoke a restart cut short (section 6,
-  G27).
-- N5: the writer also refuses `disk`, `libvirt` and `incus-admin` (E3).
-- N6: a first `add` creates the file, and a leftover regular tmp is unlinked under the `flock` (E3, G25).
-- N7: the installer's line is written out exactly (E3).
-- N8: a dev instance is a business whose `bus.tester` var is exactly true (mos-1139, section 6).
-- N9: the row a run sheet strips row 210's `hosts` keys before the `--migrate` re-pin (S1).
-- N10: the writer list in the r3 changes now includes `hosts.check`. ops-01 reads only the three key types the
-  keyscan asks for (E1).
-- N11: Duckworth withdrew a PRD note. Section 6 step 1's record delete stays.
-- Row b grows by the revoke verb and its marker. My estimate goes from 1.5 days to 1.75 (section 12).
-
-## r4 changes (from r3 d8bcf8066)
-
-mos-1133 corrects S1's migration lines. r3 said the 3i-3j re-pin needs `--migrate` with Jason present (P19
-371). That was wrong. P19 371 predates Q173, and Q173 lets Mos, Sage or Darkwing re-pin, migrate, roll back
-and restore the mosaic-stack business on dragon-lin. S1 now says so and adds the .53 and .54 plan. Nothing
-else changed.
-
-## r3 changes (from r2 eb4c756a1)
-
-mos-1131 (from duckworth-0057 and mos-1129): under PRD 1.8 only an Approve creates a grant, and a hand edit
-of the business file makes nothing. So W1 is gone.
-
-- Enrolled hosts and grants are records in the bus store, written only by the executor, revoke,
-  `hosts.check` and `hosts.remove`, each in the same transaction as its event (section 5, S1). Nothing writes them into the
-  business file.
-- Row 210's hand-edited `hosts` keys stay a test path until row a (#436a) moves `host.run` to the store
-  records. After that the loader refuses those keys (S1).
-- B1 gets simpler. `host.run` reads the store at each call, so the broker needs no runtime apply. Only
-  `Credentials.register` stays (X4).
-- `registrySha256` stays, now over the store's host record. It is what 1.8 calls "the target or its
-  enrolled identity" (mos-1131 point 3).
-- Enrollment carries expected fingerprints, and the raise runs its own keyscan (E1, mos-1132 Q-M2).
-- Revokers follow mos-1124 d and mos-1132: the human, the assistant in its own organization (Q188's "Mos",
-  Mos's reading for prd.approve), and the tester on a dev instance only (section 6).
-- ops-01's Q-O2 rules and writer points a to d are in E3 and section 9.
-- X5 (B2) is 1.8's N2: a revoke during creation stops it, and nothing it made stays usable (mos-1131 point
-  4).
-- The store records need a new migration, `3i-3j.sql` (S1). That makes row a a schema change.
-
-## r2 changes (from r1 f6b6a04b6)
-
-- Enrollment is a request the chief raises and Jason approves, not a CLI Jason types (mos-1120 point 3).
-  Section 3 is rewritten. `hosts.enroll` stays, as the verb the executor runs.
-- The action is `credential.mint` with a `grant` binding, not a new `host.grant` (sage-1527 Q-S3, Honker's
-  REQ-GRANT-1). The hard-waits list doesn't change. R2 says why the binding still carries G1 to G10.
-- The binding adds a hash of the agent's role definition, because REQ-GRANT-2 voids an approval when the
-  definition changes. It also carries the full commands list (N2).
-- The host side follows ops-01's answer to Q-O1 (mos-1125): lines in a root-owned
-  `/etc/ssh/mosaic-keys/%u`, a dedicated install user, a forced command that only parses, and a root
-  writer in this repo that checks everything again (E3). This answers B5.
-- A target user with sudo is enrolled by name, and Jason's Approve of the enrollment covers it (E1, E3,
-  mos-1125's recommendation). Without this no `host.sudo` grant could be installed.
-- B1: a grant, a commands change, an enrollment and a revoke take effect in the running bus (X4).
-- B2: the executor holds an `#inflight` entry that revoke aborts, and a revoke works before any grant
-  exists (X5).
-- B3: progress events before each step, and a start-time reconcile that undoes to the state before the
-  decision (X3).
-- B4: the tag is a hash, recorded in events, and `list` and `sweep` only touch this business's recorded
-  tags (X2, step 2).
-- N1 to N3 answered in X1, R4 and E4.
-- Section 9 adds ops-01's point that a host line has no `command=` (mos-1125).
-- Answers recorded: Q-S1 to Q-S4, Q-M1, Q-O1. New questions Q-M2, Q-S5 and Q-O2.
-
-## 0. What Q188 asks for, and what this draft builds
-
-Q188 says no agent creates a grant. A request goes up the chain, only the chief raises it to Jason's inbox,
-Jason clicks Approve or Deny, and on Approve protected stack code creates the grant. Revoke stays instant, by
-Jason, Mos or the tester. mos-1115 puts machines first: issue the key, install it on the host with
-`from="<stack host>",restrict`, pin the host fingerprint, and on revoke drop the key and cut the connection.
-This replaces row 210 section 4, where Jason hand-edits three layers, runs `issue`, and ops-01 pastes the
-`authorized_keys` line.
-
-This draft covers:
-
-- host enrollment, once per host (section 3)
-- the grant request and its decision (section 4)
-- the executor that runs on Approve (section 5)
-- revoke (section 6)
-- how row 210's per-call decision becomes manual mode (section 7)
-
-Gitea and GitHub grants follow the same executor shape and are a later draft (section 11).
-
-One thing up front, because it changes what Jason sees on 10-27. A grant made this way still doesn't let an
-agent run a command without a click. Under PRD 1.7 `host.sudo` is a hard wait, and every `host.run` needs its
-own decision (210 D4). "Runs without a click" needs REQ-CRED-4 in PRD 1.8 (Vikunja #434, Honker through Sage)
-and the reviewed commit that routes `host.sudo`. This path and that routing are separate pieces, and the
-first is useless for Q188's goal without the second.
-
-## 1. Facts from the code
-
-- F1. **No chain of command exists in the data.** A role definition has only `roleVersion, name, title,
-  contract, tools, network, authority, credentials, messaging, skills` (`business/src/role.mjs:19-20`). There
-  is no `reportsTo` or manager field. The one fixed rank is the chief, the definition named
-  `chief-of-staff` (`bus/src/broker.mjs:157`), and the broker already checks an instance's definition against
-  it (`broker.mjs:593`, `:1990`). Who may message whom is the only structure, `#checkMessaging`
-  (`broker.mjs:617-627`).
-- F2. **Any agent may raise any action.** `decision.raise` stores `raised_by_role` and `raised_by_run`
-  (`broker.mjs:1703-1708`). No rule limits which role raises which action, and no raise names another agent
-  as its beneficiary.
-- F3. **A hard wait always routes to the human.** Any action outside `ROUTED` is in `GATED_ONLY`
-  (`business/src/vocabulary.mjs:88`), classifies `gated` (`broker.mjs:597-609`) and routes to `human`
-  (`broker.mjs:1677-1680`). A tester thread can't route to the human (`broker.mjs:1683`).
-- F4. **Resolving a decision runs nothing.** `decision.resolve` records a `decision_events` row and messages
-  the raiser (`broker.mjs:1752-1828`). An effect happens later, when a verb consumes the decision through
-  `#consumeAuthority`, which refuses `decision-consumed` if an `action.allowed` event other than the raise
-  already cites it (`broker.mjs:808-831`). `#consumeAuthority` needs the raiser's own agent session: it
-  checks `raised_by_role` and the raiser's thread against the caller (`broker.mjs:764`, `:786`). The
-  landing path is the only place where stack code reacts to a resolution, and even there the agent's own
-  `land_work` call does the work (`cli/src/launcher.mjs:555-600`).
-- F5. **The human proof.** `mosaic decide` resolves through `human-cli.mjs` (`cli/src/cli.mjs:142-175`,
-  `cli/src/transport.mjs:55-75`). `verifyHuman` is a same-UID cooperative check (`bus/src/human.mjs:50-52`),
-  and `#human` needs `via === 'cli'` and `outsideAgent` (`broker.mjs:375-378`).
-- F6. **The business file has one writer discipline.** `organizationWriter.write`
-  (`business/src/organization.mjs:177-219`): a lock dir, a revision that is the sha256 of the current bytes,
-  `previous.json`, tmp, fsync, rename, and receipts in `businesses/.history/<id>/changes.jsonl`. The bus child
-  does the write (`cli/src/host.mjs:215`, `bus/src/process.mjs:1-3`). Agent-reachable keys are
-  `ORGANIZATION_KEYS` and `INSTANCE_KEYS` (`broker.mjs:146-148`). Row 210's `hosts` keys sit outside both.
-- F7. **Row 210's pieces this path reuses:**
-  - the agent key store at `<configDir>/secrets/agents/<business>/<agent>/host.<id>` (210:
-    `bus/src/credentials.mjs:153-157`)
-  - `issue`, which writes tmp, fsync, rename, then calls `commit`, then sets memory and clears the revoked
-    mark (210: `credentials.mjs:243-280`, the clear at `:279`)
-  - `revoke`, which drops memory, aborts the call in flight and unlinks the file (210:
-    `credentials.mjs:284-298`, the abort at `:289`). It refuses `credential-unknown` for a service with no
-    loaded reference (210: `credentials.mjs:235-238`).
-  - the busy map `#inflight`, instance and service to an `AbortController` (210: `credentials.mjs:118`,
-    `busy` at `:332-334`, used by `host-run.mjs:249`)
-  - pinned `known_hosts` built from the registry's `hostKeys` with `StrictHostKeyChecking=yes` (210:
-    `bus/src/host-run.mjs:36`, `:170`)
-- F8. **Nothing on refactor generates keys or contacts a host.** No `ssh-keygen` or ssh spawn exists in
-  `packages/*/src`. Row 210 adds the ssh spawn, and row 210's tests already require `ssh-keygen` on the
-  machine (210 test list, first test).
-- F9. **The Console can't approve today.** It shows decisions and copies the `mosaic decide` command
-  (`webui/src/public/bus.js:3-5`). `decision.resolve` is not in `BUS_VERBS` (`webui/src/serve.mjs:62`).
-  Vikunja #435 adds Approve after Q175 sign-in (#412).
-- F10. **`credential.mint` is already a hard wait with no executor** (`vocabulary.mjs:38`).
-- F11. **The running bus never reloads the business file, except the limits.** The broker keeps a clone
-  made once (210: `broker.mjs:234`), and `host.run` reads `b.hosts` and `b.roles[role].hosts` from it (210:
-  `broker.mjs:1731-1735`). `Credentials` loads its references once, in the constructor (210:
-  `bus/src/runtime.mjs:85-98`, `credentials.mjs:125-147`). Only the limits read the file at each ask, and
-  `instances.set` answers `restart: true` (`business/src/instance-settings.mjs:73`, `:155`).
-- F12. **The business file has no room for state on a host or a grant.** A registry entry takes only
-  `address, port, user, hostKeys` (210: `business/src/hosts.mjs:75`), and a role's grant only `commands`
-  (210: `hosts.mjs:123`). Under 1.8 the file holds no grant at all (mos-1131), so hosts, grants, state, tags
-  and progress live in the bus store (S1).
-
-## 2. Shape
-
-```
-agent --message--> chief --decision.raise credential.mint + grant--> Jason's inbox
-                                                         |
-                                     mosaic decide (later: Console Approve, #435)
-                                                         |
-                          bus child grant executor (on resolve, approve only)
-               keygen -> install via host installer -> verify -> key file + store record + live refs
-```
-
-Revoke runs the other way: memory, then the in-flight call, then the key file, then the store record, then
-the host line.
-
-## 3. Host enrollment (once per host, a request like a grant)
-
-Installing a key on a host needs something on the host that already trusts the stack. Nothing on refactor
-holds that trust, so each host gets one enrollment. This is the step that remains for ops-01, once per
-host, and it goes on the ops-01 run sheet in the installer's I3 row (#432, mos-1120). Per-agent installs no
-longer need ops-01.
-
-A host here is a registry entry, so it has one user (F12). Two users on one machine are two host ids with the
-same address, each enrolled on its own.
-
-### E1. The request
-
-ops-01 reads the host's ed25519, ecdsa and rsa key fingerprints on the host, read-only
-(`/etc/ssh/ssh_host_{ed25519,ecdsa,rsa}_key.pub`). Those are the three types the keyscan asks for, so a
-fingerprint of any other type would make the raise refuse `host-key-mismatch` (N10). Host keys never travel
-by message (mos-1132). The request carries ordinary fields: address, port, the target user,
-whether that user has sudo, and the expected fingerprints. On the #433 VM, Mos or Sage passes them to the
-chief as the tester (Q173). On .53 and .54, Jason sends the request in the Console (Q118), with text Mos
-builds from ops-01's values. The chief raises a `credential.mint` decision with the binding (section 4, R4):
-
-```
-grant: { "method": "host-enroll", "host": "<hostId>", "address": "A", "port": 22, "user": "U",
-         "sudo": true, "fingerprints": ["SHA256:...", ...] }
-```
-
-The raise checks are 210 D3 layer 2's: the address rules, refusing loopback and this machine's names, the
-port range, the user pattern and the key types. It also refuses a `hostId` that is already enrolled, a user
-named `root`, `localadmin` or `mosaic-installer`, and a `sudo` that isn't a boolean.
-
-Before the raise transaction, the raise runs its own `ssh-keyscan -T 5 -p <port> -t ed25519,ecdsa,rsa
-<address>` from the stack host. The set of scanned fingerprints must equal the set in the request, or the
-raise refuses `host-key-mismatch` and nothing is stored. So two independent reads, ops-01's on the host and
-the stack's over the network, have to agree before Jason sees the binding (mos-1132). The scanned key lines
-go in the raise event body as `hostKeys`, and those are what E2 writes and E4 pins. The keyscan only reads
-the host's public keys. It logs in to nothing.
-
-The rendered block shows each fingerprint and the key line, so Jason can compare them with ops-01's. With `"sudo": true` it adds one line in plain words: "U has sudo on this host.
-Approving lets later grants for U be installed, and section 9's first limit applies to U."
-
-Jason approves with `mosaic decide` until #412 brings the Console inbox. No one pastes a host key. The keys
-come from the keyscan, checked against ops-01's fingerprints.
-
-The pin is never taken on trust from one connection (210 section 4). It is the keyscan result, and only
-when it matches the fingerprints ops-01 read on the host. E4's check fails closed on a wrong pin too.
-
-Not every host can be enrolled yet. jarvis on .53 and melanie on .54 wait for #423 steps 4 and 5
-(mos-1125 point 5).
-
-### E2. What the executor does
-
-On Approve the bus child runs `hosts.enroll`, with the same start rules as a grant (section 5, X1):
-
-1. **Recheck and consume** in one store transaction (B1): `#consumeGrant(business, decision, 'host-enroll')`
-   (X1), a check that no `hosts` record has this (business, `hostId`), then `host.enroll.step {decision,
-   host, step: 'registry'}` and the `hosts` record (S1) with the bound `address, port, user, sudo,
-   hostKeys`. If the host is already enrolled, the transaction writes only the spend and `grant.failed
-   {code: 'host-enrolled'}`, and the human and the chief get a message. The primary key (S1) refuses a
-   second insert as well. So of two approved enrollments for one `hostId`, the second never replaces the
-   pin, the user or the sudo mark under live grants, and enrolling again still means `hosts.remove` first
-   (E4). Enrollment needs no `#inflight` claim, because a second enrollment stops here, before anything
-   else is written.
-2. generates an installer key pair with `ssh-keygen -t ed25519 -N '' -C mosaic-installer-<tag>`, where `<tag>`
-   is the hash of section 5's X2 step 2 over (business, `@installer`, hostId), in a 0700 dir under
-   `<configDir>/secrets/run`, the dir row 210 already sweeps at start
-3. moves the private half to `<configDir>/secrets/hosts/<business>/<hostId>/installer`, mode 0600 in 0700
-   dirs, by the same tmp, fsync, rename steps as 210 `issue`. The path follows row 199 D1's
-   `secrets/agents/<business>/...` (Q-S2, mos-1120, sage-1527)
-4. records `host.enrolled {decision, host, registrySha256, installerFingerprint, user, sudo}` and messages
-   the human and the chief with what ops-01 installs (E3)
-
-No private material goes out. A failure at step 2 or 3 deletes the host record again and ends
-`grant.failed`, as X3 does. A restart after step 1 does the same (X3).
-
-The host's state is in the store record (S1):
-
-- `pending-install`: set by step 1
-- `ready`: set by a passing `hosts.check` whose `registrySha256` and installer fingerprint match the record
-
-### E3. The host side
-
-ops-01 answered Q-O1 with six changes (mos-1125). The stack side doesn't change. The host side is four
-files in this repo under `tools/host/`, each reviewed like code, and Duckworth reviews the writer, the
-sudoers line and the sshd drop-in before .53 (mos-1125 point 6):
-
-| File | Installed as | Does |
-|---|---|---|
-| `mosaic-keys` | `/usr/local/sbin/mosaic-keys`, root, 0755 | the installer key's forced command. Parses `SSH_ORIGINAL_COMMAND` against fixed patterns and runs `sudo -n /usr/local/sbin/mosaic-keys-write <request>`. Nothing else. |
-| `mosaic-keys-write` | `/usr/local/sbin/mosaic-keys-write`, root, 0755 | checks everything again and writes the line |
-| `mosaic-keys.sudoers` | `/etc/sudoers.d/mosaic-keys`, root, 0440 | `mosaic-installer ALL=(root) NOPASSWD: /usr/local/sbin/mosaic-keys-write` |
-| `mosaic-keys.sshd.conf` | `/etc/ssh/sshd_config.d/<nn>-mosaic-keys.conf` | `AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2 /etc/ssh/mosaic-keys/%u` |
-
-The drop-in keeps both paths the hosts use today. On .53 and .54, `sshd_config` includes
-`sshd_config.d/*.conf` at line 12 and no file sets `AuthorizedKeysFile` (mos-1127 point 2). Root never
-writes into a user's home (mos-1125 point 1).
-
-Host config, all root-owned and written by ops-01 from the approved enrollment message:
-
-- `/etc/mosaic-keys/users`: the users the writer may touch
-- `/etc/mosaic-keys/privileged`: the users with sudo that Jason approved by name (E1 `"sudo": true`)
-- `/etc/mosaic-keys/from`: the `from=` value. The stack can't choose it.
-- `/etc/ssh/mosaic-keys/`: root, 0755. `mosaic-installer`'s own line lives here, in a root-owned
-  `mosaic-installer` file that ops-01 writes by hand.
-
-The installer's line is exactly this, with `<from>` the same value as `/etc/mosaic-keys/from` (N7):
-
-```
-restrict,command="/usr/local/sbin/mosaic-keys",from="<from>" ssh-ed25519 <base64> mosaic-installer-<tag>
-```
-
-E2 step 4's message carries the line with the public key filled in, and the I3 run sheet's host step quotes
-it. So a hand-written line can't drop `restrict` or `command=`.
-
-`mosaic-installer` is a dedicated user, never `localadmin` and never an agent user (mos-1125 point 2). It
-needs no entry in any sshd list, because .53 and .54 have no `AllowUsers`, `AllowGroups`, `DenyUsers`,
-`DenyGroups`, `ForceCommand` or `Match` block and `pam_access` is off (mos-1127 point 1).
-
-Requests:
-
-| Request | Effect |
-|---|---|
-| `list <user>` | prints each line of `/etc/ssh/mosaic-keys/<user>` whose tag matches the tag pattern |
-| `add <user> <type> <base64> <tag>` | appends `from="<from>",restrict <type> <base64> <tag>` unless the tag exists |
-| `remove <user> <tag>` | drops the line with that exact tag |
-
-`remove` of a tag that isn't there changes nothing and exits 0, so a revoke and an executor undo can both run
-it.
-
-What `mosaic-keys-write` checks, at every request (mos-1125 points 3 and 4):
-
-- the request matches the patterns again. Each tag matches `^mosaic-[0-9a-f]{32}$`, and each type and
-  base64 match E1's patterns.
-- `<user>` matches `^[a-z_][a-z0-9_-]{0,31}$` before it is used in any path. `O_NOFOLLOW` covers only the
-  last component, so the pattern is what stops a `../x` relative to the dir fd (ops-01 point a).
-- `<user>` exists, is in `users`, and isn't uid 0, uid under 1000, `mosaic-installer` or `localadmin`. These
-  names and the uid rule are in the code, not in a file. `users` is always required.
-- `<user>` is in none of the groups `sudo`, `admin`, `wheel`, `docker`, `lxd`, `disk`, `libvirt` and
-  `incus-admin`, and has no sudo rights, unless it is in `privileged`. A group the host doesn't have counts
-  as no membership. `disk` reads and writes raw block devices, and `libvirt` and `incus-admin` start guests
-  with host mounts, so each is root by another route (N5). `privileged` only lifts this check. Being in it alone allows nothing (ops-01 Q-O2
-  point 1).
-- the sudo test is `LC_ALL=C sudo -l -U <user>`. Any output other than the exact line
-  `User <user> is not allowed to run sudo on <host>.` counts as having sudo (ops-01 Q-O2 point 4).
-- it never touches a line whose tag doesn't match the pattern.
-
-How it writes, so no path trick moves the write:
-
-- opens `/etc/ssh/mosaic-keys` with `O_DIRECTORY | O_NOFOLLOW` and refuses unless it is root-owned and not
-  group or world writable
-- takes `flock` on `.lock` in that dir, a name the user pattern can't match, so sshd never reads it and
-  `list` never shows it (ops-01 point b)
-- opens the user's file relative to the dir fd with `O_NOFOLLOW`, and refuses one that isn't a regular
-  root-owned file. A first `add` for a user finds no file. `ENOENT` there means an empty list, and the
-  rename creates the file. `list` and `remove` on a missing file print nothing and change nothing (N6).
-- the tmp is `.<user>.tmp`, a name the user pattern can't match. Under the `flock`, a leftover tmp can only
-  come from a writer that crashed, so a regular root-owned one is unlinked first. A tmp that is a symlink
-  or not a regular file refuses, and nothing is written (N6).
-- writes the tmp with `O_CREAT | O_EXCL | O_NOFOLLOW`, sets mode 0644, `fsync`, `renameat` over the file,
-  then `fsync` on the dir
-- logs to syslog the result, user, tag and key fingerprint. The fingerprint is sha256 over the decoded
-  blob, so no `ssh-keygen` runs
-
-sudo's `env_reset` drops `SSH_CONNECTION` on both hosts. So `mosaic-keys` logs `SSH_CONNECTION` and the request
-with `logger -t mosaic-keys` before it calls sudo, and the sudoers file stays one line with no `env_keep`
-(ops-01 point c). The hosts set `use_pty`. With `restrict` there is no pty, and sudo shouldn't allocate one
-when stdin isn't a tty. The #433 proof checks that `list` output and the exit code pass through unchanged
-(ops-01 point d).
-
-The writer is python3, standard library only, with `#!/usr/bin/python3 -I`, because `os.open` takes `dir_fd`
-and `O_NOFOLLOW` and a shell script can't do that safely. Both hosts have Python 3.12.3 at `/usr/bin/python3`,
-root-owned, and `python3 -I` imports every module the writer needs (ops-01, 22:26Z).
-
-When ops-01 writes `users` and `privileged` from an approved enrollment, ops-01 first checks the E1 `sudo`
-mark on the host. If the host disagrees, for example `sudo: false` for a user in `docker`, ops-01 writes
-neither file and reports back, and the enrollment needs a new request (ops-01 Q-O2 point 2).
-
-sshd's `StrictModes yes` (on both hosts, mos-1127 point 3) also refuses a key file whose path is writable by
-anyone but root or the user.
-
-The install proof runs on the #433 VM first (mos-1125 point 6), as ops-01 does it (mos-1127): `sshd -t`,
-`systemctl reload ssh`, then a new connection. An existing session survives the reload. Rollback removes
-the drop-in and reloads, which restores the old value. The run sheet's host step (#432, I3) cites these.
-
-This still doesn't make the installer key safe to lose. A key that can add a line for a privileged user is
-root on that host. Section 9 says so.
-
-### E4. Check
-
-After ops-01 installs the files and the installer line, `hosts.check <hostId>` connects as `mosaic-installer`
-with the installer key, the pinned `known_hosts` and 210's ssh options, and runs `list <user>`. A wrong pin
-exits 255 and refuses `host-key-mismatch`, as 210 does, and the host stays `pending-install`. A pass records
-`host.checked {host, registrySha256, installerFingerprint}` and sets the record `ready` in the same
-transaction. Only a `ready` host can be named in a grant (R4).
-
-The chief, the tester or the human may run `hosts.check`. It reads the host's lines and widens nothing past
-what Jason approved, so it needs no decision. `status` shows each host's state, pin fingerprints, installer
-fingerprint and last check time.
-
-`hosts.remove <hostId>` is for the human or the tester, as a revoke is (REQ-GRANT-4), because it only takes
-access away. It refuses `host-in-use` while any grant names the host and `host-line-left` while any event's
-`hostLineLeft` names the host and no later `sweep` cleared it (N3). Then it deletes the installer key and the
-host record, and records `host.removed` in the same transaction. ops-01 removes the
-installer line on the host. Enrolling the host again takes a new request.
-
-## 4. The request and the decision
-
-### R1. Up the chain
-
-An agent that needs host access sends the chief a message, as any request to the chief goes today
-(`#checkMessaging`, `broker.mjs:617-627`). There is no structured request verb (Q-S1). F1 gives the reason:
-nothing records who reports to whom, so the bus can't check a chain beyond "the chief raises it".
-
-"Not every agent may request" (Q188) is enforced at the raise. The target agent's definition must declare
-`{"service": "host"}` in `credentials` (210 D3 layer 1, a reviewed commit). An agent whose definition lacks
-it can ask, but the chief's raise for it refuses `host-not-declared`. Which definitions declare `host` is
-the reviewed list of agents that may hold a host grant.
-
-### R2. The action
-
-The request is a `credential.mint` decision, as Honker's REQ-GRANT-1 says. `credential.mint` is already a
-hard wait (`vocabulary.mjs:38`, F10), so it classifies `gated` for every role and routes to the human (F3).
-No role file may list it (REQ-WAIT-2), so it can never be routed, and the hard-waits list doesn't change.
-
-r1 used a new `host.grant` action because `credential.mint` names no host or argv. That reason doesn't
-hold. The binding lives in the raise's `grant` argument and the raise event body, not in the action name,
-so G1 to G10 test the same things either way. The executor starts only for a decision whose raise carries
-a `grant` binding.
-
-A `credential.mint` raise without `grant` keeps today's behaviour. Any agent may raise one, Jason may
-answer it, and nothing runs. It is a question for a hand-made credential, as it is now.
-
-### R3. Who may raise it
-
-The broker refuses a raise that carries `grant` unless the raiser's definition is `chief-of-staff`
-(`b.roles[s.role].definition === STAFF_TO`, the check at `broker.mjs:593`). Refusal: `grant-chief-only`. A
-tester thread can't raise it, because it routes to the human (`broker.mjs:1683`). Any other action with a
-`grant` argument refuses `invalid-request`.
-
-### R4. What the raise binds
-
-New raise argument `grant`, allowed only with `action === 'credential.mint'`. For a host grant:
-
-```
-grant: { "method": "host", "agent": "<instance>", "host": "<hostId>",
-         "commands": [["systemctl", "status"], ...], "rotateBy": "YYYY-MM-DD" }
-```
-
-`host-enroll` is E1's. A later draft adds `gitea` and `github`. Any other `method` refuses
-`invalid-request`.
-
-Checks at raise, all inside the raise transaction:
-
-- `agent` is a role instance of this business, and its definition declares `host` (R1)
-- `host` is `ready` (E2, E4), or the raise refuses `host-not-ready`
-- `commands` passes 210 D6's argv rules: no wildcard, no shell, no empty prefix, and the existing
-  refusals for `bash` and the like
-- `rotateBy` is a date inside 210's rotation window
-
-The broker appends a rendered block to the question, as 210 D4 does for `host.sudo`: agent, host id,
-address, user, whether the user has sudo (from `host.enrolled`), each argv prefix JSON-quoted, the rotate
-date, and whether this is a new key or a change to an existing grant's commands. The chief can't shape that
-block. If the question with the block exceeds the 4096-character cap (`broker.mjs:126`), the raise refuses
-`invalid-request`, as 210 D4 does (N2). The chief then splits the commands over two requests.
-
-The raise event body gets `grant = {method, agent, host, commands, commandsSha256, rotateBy, registrySha256,
-definitionSha256}`. The full `commands` list is stored there, and the executor reads it from that event at
-X2 step 1 and checks it against `commandsSha256` (N2). `registrySha256` hashes the host record's identity (`address, port, user, sudo,
-hostKeys`) at raise time, which is 1.8's "the target or its enrolled identity" (mos-1131), and `definitionSha256` hashes the agent's role definition file. REQ-GRANT-2 voids an approval
-when the agent, its definition, the target or the rights change after the raise. If either hash differs at
-X2 step 1, the executor refuses `decision-mismatch` and the chief raises again.
-
-### R5. Jason decides
-
-`mosaic decide <id> yes|no` as today (F5). After #435, the Console's Approve calls the same
-`decision.resolve` through `human-cli.mjs` behind Q175 sign-in. The executor keys on the resolution, not on
-the client, so #435 needs no executor change.
-
-## 5. The executor
-
-### X1. When it runs
-
-At resolve. Today a resolution runs nothing (F4), and the raiser comes back later to consume the decision.
-Here the raiser is the chief, and Q188 says no agent creates the grant, so the chief must not be the one
-whose call does it. The bus child starts the executor itself after the human's `decision.resolve` commits,
-when all of these hold: the decision's action is `credential.mint` and its raise carries `grant`, the route
-is `human`, the choice equals `approvalChoice`, and `via === 'cli'`. A resolve by an arbiter, the tester or
-an agent starts nothing (REQ-GRANT-2).
-
-The resolve call returns at once with `{grant: "started"}`. It does not wait on ssh. Jason sees the outcome
-in `mosaic hosts status` and as a message in his inbox from `system` when the executor ends.
-
-The executor can't use `#consumeAuthority`, because that needs the raiser's agent session (F4, N1). It gets
-its own path, `#consumeGrant(business, decisionId, method)`. In one transaction it checks the decision is
-resolved yes by the human via cli, checks `#spent` the same way (`broker.mjs:808-831`), and writes the
-`action.allowed` event with `operation: 'grant.<method>'` and actor `system/grant`. A second start finds it
-spent and refuses `decision-consumed`. It is a private method, and only the executor calls it.
-
-### X2. Steps
-
-1. **Recheck, consume, claim.** One store transaction: `#consumeGrant` (X1), the agent and its definition
-   still declare `host`, the definition hashes to `definitionSha256`, the host record hashes to
-   `registrySha256`, the host is `ready`, the `commands` in the raise event hash to `commandsSha256`, and no
-   revoke of this (agent, host) is newer than the raise. Any failure is `grant.failed` with its code, and
-   nothing remote has happened. Right after the commit, with no `await` between, the executor claims the
-   (agent, `host.<hostId>`) entry in `#inflight` (X5). The store is `DatabaseSync` (`store.mjs:1`), so the
-   transaction and the claim run in one turn of the event loop, and no revoke or `host.run` can run between
-   them. A claim that finds an entry, usually a running `host.run` from the same agent (210:
-   `credentials.mjs:355`), ends `grant.failed {code: 'host-busy'}` with a message to the human and the
-   chief, and the chief raises again (B2). The decision is spent before the claim, so every Approve ends in
-   `grant.applied` or `grant.failed`, never in silence.
-   I chose failing over waiting for the running call. A wait could last as long as 210's timeout while
-   Jason's inbox says "started", and a failure with a message is easier to see than a slow grant.
-2. **Key.** The tag is `mosaic-` and the first 32 hex digits of sha256 over business, agent and hostId
-   joined with a NUL byte. Names match `ID_PATTERN` (210: `vocabulary.mjs:143`, `:127` at f41729178), which has no NUL, so the join is
-   one to one, and the tag has a fixed length the host pattern accepts (B4). For a new grant,
-   `ssh-keygen -t ed25519 -N '' -C <tag>` in a fresh 0700 dir under `<configDir>/secrets/run`. For a
-   commands change with a live key, skip to step 5.
-3. **Install.** Write `grant.step {decision, agent, host, user, tag, step: 'install'}`. Connect as
-   `mosaic-installer` with the installer key, pinned (210's options), and run `list <user>`. If the tag is
-   there, `remove` it first: the tag is this agent's on this host, and step 2 only runs when the stack holds
-   no live key for it. Then `add <user> <type> <base64> <tag>`.
-4. **Verify.** Connect as `<user>` with the new key through a short-lived ssh-agent (210 D7) and run `true`.
-   The connection proves the line, the `from=` and the pin together. A failure here runs `remove <user> <tag>`
-   and ends `grant.failed`.
-5. **Go live.** Write `grant.step {..., step: 'commit', previous}`, where `previous` is the grant's
-   `commands` before this decision, or `null` for a new key. Then check the abort signal (X5), and with no
-   `await` between, run 210 `issue(agent, "host.<hostId>", privateKey, rotateBy, commit)`. For a new key the
-   reference is registered first (X4). `issue` writes the key file, then calls `commit`, which writes the
-   `host_grants` record (S1) with the decided `commands`, `rotateBy`, tag and decision id. Then `issue`
-   fills memory. For a commands change, step 5 is the abort check and one store transaction that updates
-   `commands` and the decision id, with no `issue`. The tmp dir from step 2 is removed in a `finally`.
-6. **Event and message.** `grant.applied {decision, agent, host, user, tag, fingerprint, commandsSha256}`
-   and a message to the human and the chief. The private key appears in no event, message or log (210 D8's
-   `assertCleanKey` runs on every event body).
-
-After step 6, or after any failure, the executor releases its `#inflight` entry in a `finally`.
-
-The tag is recorded in `grant.step` and `grant.applied`, so `list` output and `sweep` can be matched to this
-business's grants without trusting a comment on the host (B4).
-
-### X3. Failure and restart
-
-The steps are ordered so a failure leaves nothing an agent can use:
-
-| Fails at | State left | Cleanup |
-|---|---|---|
-| 1 | nothing | none |
-| 2 | tmp dir | `finally`, and the start sweep |
-| 3 | maybe a line with a key nobody holds | `remove <user> <tag>`, best effort |
-| 4 | a line, no grant | `remove`, best effort |
-| 5 before `commit` | a line, a key file, no grant record | unlink the key file, unregister (X4), `remove` |
-| 5 after `commit` | a line, a grant record, a key file | the record back to `previous` (deleted for a new key), 210 `revoke`, `remove` |
-
-Setting a record back to `previous`, here and in the restart table below, only updates a record that
-exists. It never inserts one, and it does nothing when a `grant.revoked` for the (agent, host) is newer than
-the decision. So a revoke that deleted the record stays done, and the next start loads no reference for it
-(C1).
-
-A best-effort `remove` that fails adds `hostLineLeft: <tag>` to `grant.failed`, and `status` shows it until
-`mosaic hosts sweep <hostId>` (human or tester) succeeds. `sweep` runs `list <user>` and removes each line
-whose tag is in this business's recorded `grant.step` tags and has no live grant. A line with any other tag
-is left alone, so a sweep can't touch another business's line on the same user (B4).
-
-**Restart.** A bus child that dies mid-executor leaves a spent decision with no `grant.applied` or
-`grant.failed`. At start, before `Credentials` loads, the bus reconciles each one from its last
-`grant.step` (or `host.enroll.step`), back to the state before the decision (B3):
-
-| Last step | Local undo, before load | Remote undo, after the bus is up |
-|---|---|---|
-| none | none (the tmp dir goes in 210's run-dir sweep) | none |
-| `install` | none | `remove <user> <tag>` |
-| `commit`, new key | unlink the key file if present, delete the grant record if present | `remove <user> <tag>` |
-| `commit`, commands change | set the record's `commands` back to `previous`, by the update-only rule above | none, the key and line didn't change |
-| enrollment `registry` | delete the installer key if present, delete the host record | none |
-
-Then it records `grant.failed {code: 'interrupted', tag}` with the tag listed every time, and `hostLineLeft:
-<tag>` if the remote undo failed. Jason gets a message. The chief raises again, and Jason approves again. I
-chose a new decision over an automatic retry because Jason approved one attempt at one moment, and a retry
-after a restart might be hours later. The remote undo only takes access away, so it needs no decision.
-
-A bus child can also die after the human's resolve commits and before step 1 runs. That leaves a grant
-decision resolved yes by the human via cli with no `action.allowed`. At start the reconcile spends each one
-through `#consumeGrant`, in the same transaction as `grant.failed {code: 'interrupted'}`, and Jason gets a
-message (B2). It never runs late, for the reason above, and a later start finds it spent. Enrollments get the
-same treatment.
-
-### X4. Taking effect in the running bus (B1)
-
-The running bus never reloads the business file (F11). The store records (S1) sidestep that:
-
-- After row a, `host.run` reads the host record and the agent's grant record from the store inside its
-  transaction at each call, and refuses `host-not-granted` unless the record's decision is a `credential.mint`
-  resolved yes by the human via cli and spent by `#consumeGrant` with `operation: 'grant.host'`. That is the
-  Approve record check. The record is read in place of `b.hosts` and `b.roles[role].hosts` (210: `broker.mjs:1731-1735`,
-  `:1962-1968`). A grant, a commands change, a revoke and a `hosts.remove` are seen by the next call with no
-  broker change.
-- `Credentials` still loads its references once (F11). It gets `register(instance, service, ref)`, which runs
-  the constructor's reference checks for one entry (210: `credentials.mjs:128-143`, moved into a shared
-  method) and sets `#refs`, and `unregister`, which drops an entry with no token. The executor registers
-  before `issue`, because `issue` refuses an unknown service (210: `credentials.mjs:235-238`).
-- At start, the runtime adds a store reference for each `host_grants` record to the references it hands
-  `Credentials` (210: `runtime.mjs:85-98`), so a restart finds the same keys.
-- Revoke deletes the grant record, and the reference left in memory reads as revoked with no file (199) until
-  the next start drops it.
-
-### X5. Revoke while the executor runs (B2)
-
-The executor's `#inflight` entry is an `AbortController` (210: `credentials.mjs:118`), the same entry that
-`revoke`'s `abort()` reaches (210: `credentials.mjs:289`). A new `Credentials.claim(instance, service)` sets
-it and returns the signal, and `release` deletes it.
-
-- A revoke before step 1 goes through `hosts.revoke` (section 6), which records `grant.revoked` for the
-  (agent, host) even when `Credentials` holds no reference and no claim. Step 1's "no revoke newer than the
-  raise" check finds it and ends `grant.failed {code: 'revoked'}` (B2). No revoke can fall between step 1's
-  transaction and its claim (X2).
-- A revoke during steps 2 to 5 aborts the claim. `hosts.revoke` doesn't call 210's `revoke` when
-  `Credentials` has no reference, because that refuses `credential-unknown` (210: `credentials.mjs:235-238`).
-  It calls a new `Credentials.abortClaim(instance, service)`, which aborts a live claim and answers
-  `{pending: true}`, and the broker records `grant.revoked {pending: true}`.
-- The executor checks `signal.aborted` after each `await`. At step 5 it checks right before `issue`, and
-  nothing between the check and `issue` awaits, so no revoke can run in between. That matters, because
-  `issue` clears the revoked mark (210: `credentials.mjs:279`).
-- Build rule (N2): `issue` and the `commit` it calls stay synchronous. `commit` is a store write and the
-  store is `DatabaseSync` (`store.mjs:1`), so nothing in `issue` yields today. An async `commit` would let a
-  revoke run between the key file write and the memory fill, and `issue` would then clear the revoked mark.
-  A mutant covers it.
-- On abort the executor undoes as X3's failure table does at that step, then ends
-  `grant.failed {code: 'revoked'}`.
-- A revoke after step 5 is an ordinary revoke (section 6). Once step 5 commits, the executor ignores an
-  abort and goes on to step 6, so its undo never runs against a revoke that came after the commit (C1).
-
-While the executor holds the claim, a `host.run` for the same agent and host refuses `host-busy`. That only
-matters for a commands change on a live key, and it lasts until the executor ends.
-
-### S1. Grant records in the store
-
-Two tables in the bus store, added by a new migration `3i-3j.sql` next to `3h-3i.sql`
-(`bus/src/migrations/`):
-
-- `hosts`: business, host id, address, port, user, sudo, host keys, installer fingerprint, state
-  (`pending-install` or `ready`), the enrolling decision id. Primary key (business, host id), so the store
-  refuses a second enrollment of one host (B1).
-- `host_grants`: business, agent, host id, commands, rotate-by date, tag, the decision id that made or last
-  changed it. Primary key (business, agent, host id).
-
-The executor, revoke, `hosts.check` and `hosts.remove` are the only writers, each in the same transaction as
-its event. No broker verb takes these records from a request body. Every write cites a decision id or the
-revoker, as W1's receipts did.
-
-The business file holds none of it (mos-1131 point 2). A hand edit makes nothing:
-
-- Until row a lands, row 210's `hosts` keys and role grants in the business file stay as they are, a test
-  path (mos-1131).
-- Row a moves `host.run` to the store records. From then the loader refuses `hosts` at the top level and
-  `hosts` in a role (210: `hosts.mjs:75`, `:123`), so a hand-edited grant fails closed at load instead of
-  doing nothing quietly. Row 210's tests move to store fixtures in the same row.
-- The credential reference for `host.<id>` comes from the grant record (X4), not from
-  `roles.<agent>.credentials`.
-
-The store file is writable by the stack's OS user, like the key files (199 D6). Section 9's same-user limit
-covers it.
-
-A new store schema is a migration (mos-1133):
-
-- On dragon-lin the 3i-3j re-pin is an agent-run `--migrate` window under Q173. Mos, Sage or Darkwing runs
-  it as the tester, takes a backup first and sends a STATE report after. Jason doesn't need to be present.
-  P19 371 predates Q173 and doesn't apply.
-- On .53 and .54 the plan is for row a to land before the installs (row a in review by 10-24, installs
-  10-26). Both hosts then start at 3j and need no migration.
-- The row a run sheet removes row 210's `hosts` keys and role grants from the business file before the
-  `--migrate` re-pin, because the loader refuses them from then on (G14). Any 210 grant in use stops there,
-  and the agent needs a chief raise and an Approve to get it back (N9).
-- If row a slips past an install, a later round or the row a packet says so. That host then goes 3i to 3j through I3's
-  upgrade driver (#432), and Mos rules on it at that point.
-
-## 6. Revoke
-
-Q188: instant, by Jason, Mos or the tester. `mosaic hosts revoke <agent> <hostId> --reason R`. Every revoke
-is logged with who made it (REQ-GRANT-4).
-
-Who may revoke follows mos-1124 d and PRD 1.8 r3's REQ-GRANT-4 (d16ccdb91):
-
-- the human, always
-- the assistant (`THREAD_DEFINITION`, `vocabulary.mjs:131`), for grants in its own organization only. The
-  broker checks the grant's business against the session's.
-- the tester, with `--tester` (210 D9 already gives the tester `revoke`), on a dev instance only. On any
-  other instance a tester revoke refuses `tester-dev-only`.
-
-A dev instance is a business whose var `bus.tester` is exactly `true` (mos-1139, N8). `vars.mjs:125` defines
-the var for the business layer only, with a default of `false`, and `broker.mjs:544` already refuses to bind a
-tester unless it is exactly `true` (`tester-off`). `hosts.revoke` checks the same var again for the grant's
-business. A missing value or any other value means not dev, so `tester-dev-only` fails closed. I2's install
-never sets the var, so .53 and .54 are never dev (mos-1139).
-
-Q188's "Mos" is read as the assistant role, Jason's main interaction agent (mos-1132). That is Mos's reading,
-labelled as such in the PRD 1.8 approval notes, and Jason settles it at prd.approve. This replaces mos-1120's
-"Mos revokes with `--tester`".
-
-`hosts.revoke` is its own broker verb in a new module, `bus/src/host-grants.mjs`, next to the executor. It
-doesn't go through 210's `credential-verbs.mjs:21-24`, which refuses `credential-unknown` when the business
-file has no reference. After row a no `host.<id>` reference is in the business file at all (N3).
-
-Order, local first so the part that matters can't wait on the network:
-
-1. One store transaction deletes the `host_grants` record, if there is one, and records `grant.revoked
-   {tag, hostLine: 'pending'}`. The tag is computed (X2 step 2), so it exists even with no record (N4). The
-   next `host.run` refuses `host-not-granted` (X4). A new grant needs a new decision.
-2. Right after the commit, with no `await` between: 210 `revoke` if `Credentials` holds a reference
-   (memory, abort the `host.run` or the executor in flight, unlink the key file), or `abortClaim` if it
-   holds only a claim (X5). Steps 1 and 2 are the "instant" part, and neither touches the network. If the
-   unlink fails, the verb reports it. The key is already out of memory, and the next start removes the
-   file (below).
-3. `remove <user> <tag>` on the host through the installer. Success records `grant.revoke.closed {tag,
-   hostLine: 'removed'}`. If the host can't be reached, it records `grant.revoke.closed {tag, hostLineLeft:
-   <tag>}`, and `sweep` clears it later.
-
-A restart between the steps (N4) leaves a `grant.revoked` with `hostLine: 'pending'` and no
-`grant.revoke.closed`. At start, before `Credentials` loads, the reconcile unlinks that key file if it is
-there. No reference loads for it, because the record is gone (X4). After the bus is up, the reconcile runs
-step 3 and closes the marker. `status` shows an open marker as a revoke in progress.
-
-Step 3 closes the marker even when step 2's unlink failed. So the file doesn't wait on the marker: at every
-start, after the grant reconcile (X3) and before `Credentials` loads, the bus unlinks each `host.<id>` key
-file in the agent store that has no `host_grants` record (N1 of duckworth-0063). The grant reconcile runs
-first, so a key an interrupted executor wrote is already handled there.
-
-Step 3 is defense in depth. After step 1 the stack holds no copy of the key. The line only matters if
-something copied the key file before the revoke, which section 9's same-user limit allows.
-
-Remote processes that the killed ssh started may keep running (210 section 6). Revoke cuts the stack's
-connection, not what already runs on the host.
-
-`hosts remove` (E4) refuses while grants exist or a line is left. Revoking the installer itself is
-`hosts remove` and ops-01 deleting the line.
-
-## 7. Row 210's per-call decision becomes manual mode
-
-Row 210 lands as reviewed (mos-1115). Its D4 stays the code path: a `host.run` whose class is `gated` needs a
-decision bound to host, argv hash and stdin hash, spent once.
-
-What changes is when the class is `gated`:
-
-- Under PRD 1.7, `host.sudo` is a hard wait, so every call is gated. That is today.
-- Under PRD 1.8 with REQ-CRED-4, `host.sudo` is routed, and a definition that lists it within-role runs
-  granted commands with no decision (210 section 5).
-- Manual mode (Q188) puts the per-call decision back. Honker's REQ-TRUST-2 takes the list form: the
-  organization file holds a list of actions in manual mode, empty by default, set only by the user. While
-  an action is listed, it classifies `gated` for every role. `#classification` checks the list first
-  (`broker.mjs:597-609`).
-
-Manual mode is built from REQ-TRUST-2, not in the grant rows (sage-1527 Q-S3).
-
-## 8. PRD lines
-
-Honker's PRD 1.8 draft (honker/row194-b2 3c30f1036) carries this design as REQ-GRANT-1 to -4, generalized to
-all three methods. There is no REQ-CRED-5. Duckworth's PRD review (duckworth-0057) notes that this design
-uses `credential.mint` with the method in the `grant` body, not a new `host.grant` action. Points r2 sends
-Honker to match:
-
-- REQ-GRANT-2 says a host's identity comes from the host side "when the user enrolls it". Under mos-1120
-  the user approves the enrollment and the stack runs it, so "when the user approves its enrollment" fits
-  better.
-- REQ-GRANT-4 names the assistant as a revoker. Honker kept it under mos-1124 d, and this design now follows
-  it (section 6). Done in PRD r3 d16ccdb91.
-- An enrollment names a target user with sudo, and the Approve covers that user by name (E1, mos-1125).
-
-I don't edit the PRD.
-
-## 9. Limits, said plainly
-
-- **The installer key is root on a host with a privileged user.** It can add a line for a user in
-  `privileged`, and that user has sudo. It sits in `<configDir>/secrets`, readable by the stack's OS user
-  like every other key (199 D6). The writer limits which users it can touch, and a user with sudo is
-  touchable only after Jason approved that user by name in the enrollment (E1, E3). It doesn't limit what
-  those users can do.
-- **Rights gained later are caught at the next add, not before.** A user who gains sudo or `docker` after
-  enrollment, and isn't in `privileged`, is refused on the next `add`. Lines already in place stay until a
-  revoke, `remove` or `sweep` (ops-01 Q-O2 point 3).
-- **A host line has no `command=`** (ops-01, mos-1125). `add` writes `from=` and `restrict` only, so the host
-  doesn't enforce the granted argv prefixes. The bus enforces them (210 D6). A copied agent key is a full
-  shell as that user from the stack's address. A forced command per key that checks
-  `SSH_ORIGINAL_COMMAND` against the granted list would close that, but it means the writer also carries
-  every commands change to the host, and 210's argv encoding has to round-trip through it. I'd make it a
-  follow-up row and not part of rows a and b.
-- **The seat network isn't confined** (`seat/src/sandbox.mjs:29-31`, 210 section 6). An agent granted a
-  command that writes a file as root can plant its own key and ssh around the bus. `from=` doesn't help,
-  because the sandbox shares the stack's address. A network-confined sandbox closes it (Sage's follow-up).
-- **The human proof is cooperative same-UID** (`bus/src/human.mjs:50-52`). Approve is as strong as
-  `verifyHuman`, no stronger. This path adds nothing weaker, but grants raise the stakes of that check.
-- **Approve is not "runs without a click"** until PRD 1.8 routes `host.sudo` (section 0).
-- **Enrollment still needs ops-01 once per host.** I don't see a way around it without a trust anchor on the
-  host, and I'd rather say so than claim the flow is hands-free.
-- **The pin needs two reads to agree.** A wrong pin needs both the fingerprints in the request and the
-  stack's network path to the host changed in the same way. Either one alone makes the raise refuse.
-- **Tags assume one stack per business id.** Two stacks that both run a business with the same id and grant
-  the same agent name on the same host user would compute the same tag. Nothing runs two stacks today.
-
-## 10. Tests and mutants (for the rows, not built here)
-
-Tests use a scratch sshd on 127.0.0.1 with throwaway keys, as row 210 does, with `mosaic-keys` running as the
-scratch sshd's forced command. The writer's checks are tested by calling its functions with a temp dir as
-the root and a fake group and sudo lookup. The installed entry point fixes the `/etc` paths and passes no
-such argument. No real host is contacted.
-
-| Test | Claim |
-|---|---|
-| G1 | a `credential.mint` raise with `grant` from a role that isn't the chief refuses `grant-chief-only`, and nothing is stored. A `grant` on any other action refuses `invalid-request` |
-| G2 | a raise for an agent whose definition lacks `host` refuses `host-not-declared` |
-| G3 | a raise with a wildcard, shell or empty argv prefix refuses, the same cases as 210 D6 |
-| G4 | the rendered block is appended by the broker, the chief's question text can't forge it, and a question over 4096 characters with the block refuses `invalid-request` |
-| G5 | a `credential.mint` raise with `grant` routes to `human`, a tester thread can't raise it, and an approved `credential.mint` without `grant` runs nothing |
-| G6 | a yes from the human via cli starts the executor, while a no, a withdraw, or an arbiter resolve start nothing |
-| G7 | executor end to end on scratch sshd: line installed with the `from=` and tag, verify login works, the grant record written with its decision id, key file 0600, `grant.applied` with the tag |
-| G8 | each failure row of X3 leaves the stated state, and a failed `remove` leaves `hostLineLeft` |
-| G9 | a registry, role definition or commands change between raise and Approve refuses `decision-mismatch` before any remote step |
-| G10 | a second start for the same decision refuses `decision-consumed`, and `#consumeGrant` refuses an unresolved or agent-resolved decision |
-| G11 | a bus restart after `install`, after the key file is written and before `commit`, and after `commit` each reconcile to the state before the decision: no key file, no grant, no line, `grant.failed interrupted` with the tag. A restart after an enrollment's `registry` step drops the entry and the installer key. A restart after the resolve commits and before step 1 spends the decision, ends `grant.failed interrupted` with a message, and nothing runs later, for a grant and for an enrollment (B2) |
-| G12 | revoke: the grant record is gone and the `pending` marker written, then in the same turn the call in flight dies and the key file is gone, then the host line is gone and the marker closed, in that order |
-| G13 | revoke with the host down still does steps 1 and 2 and reports `hostLineLeft` |
-| G14 | `organization.set`, `limits.set` and `instances.set` still refuse `hosts` and `manual`. After row a, a business file with `hosts` or a role grant refuses at load |
-| G15 | no event, message, log line or receipt holds private key material (210 D8 check on every body) |
-| G16 | `mosaic-keys` refuses bad requests without calling the writer. The writer refuses a user not matching the pattern (`../x` included), a `privileged` user not in `users`, users outside `users`, root, uid under 1000, `mosaic-installer`, `localadmin`, a member of each refused group (`disk`, `libvirt` and `incus-admin` included), a user with a `sudo -l` line who isn't in `privileged`, bad tags and bad key text, and takes `from=` from the host file |
-| G17 | a `host-enroll` raise refuses loopback and this machine's names, bad fingerprints, an enrolled id and the reserved users. A keyscan set that differs from the request's fingerprints by one key, extra or missing, refuses `host-key-mismatch` and stores nothing. On Approve the executor writes the entry and the installer key 0600, records `host.enrolled`, and its message holds no private material. Of two approved enrollments for one `hostId`, the second ends `grant.failed host-enrolled` with its decision spent, and the first record, pin and installer key are unchanged. A direct second insert fails on the primary key (B1) |
-| G18 | `hosts.check` with a wrong pin exits 255, refuses `host-key-mismatch`, runs nothing and leaves the host `pending-install` |
-| G19 | a grant naming a host that isn't `ready` refuses `host-not-ready` |
-| G20 | `hosts.check` from the chief, the tester and the human marks the host `ready`, and any other role refuses |
-| G26 | revoke by the human works. The assistant's works in its own organization and refuses another's. The tester's works where `bus.tester` is exactly `true`, and refuses `tester-dev-only` where the grant's business has it missing or set to anything else (N8). Any other role refuses |
-| G21 | `hosts.remove` refuses `host-in-use` while a grant names the host, `host-line-left` while a line is left, and any agent other than the tester |
-| G22 | one bus, no restart: enroll, check, grant, a `host.run` that works, a commands change that the next `host.run` uses, and a revoke that the next `host.run` refuses `credential-unavailable` (B1) |
-| G23 | a revoke during install (a scratch `mosaic-keys` that waits on a fifo) ends `grant.failed revoked` with no key file, no grant and no line. A revoke before the executor starts, with no reference and no claim, records `grant.revoked`, and step 1 then ends `grant.failed revoked`. A grant whose claim finds a running `host.run` ends `grant.failed host-busy` with its decision spent and a message (B2) |
-| G24 | agent and host names at 64 characters with `.` and `_` give distinct tags of the fixed length. `sweep` leaves another business's line and an unrecorded `mosaic-` line on the same user (B4) |
-| G25 | the writer refuses a symlinked `/etc/ssh/mosaic-keys`, a symlinked user file, a group-writable dir, and a tmp that is a symlink or not a regular file. A leftover regular tmp is unlinked and the write goes ahead. A first `add` creates the file. A written file is root-owned 0644 (B5, N6) |
-| G27 | `hosts.revoke` works for an agent whose business file has no credentials reference (N3). A restart after revoke step 1, and one after step 2, each end at start with no key file, no record, the line removed and the marker closed (N4). A key file left by a failed step 2 unlink is gone after the next start, though the marker closed |
-| G28 | a commands change commits at step 5, a revoke follows before `grant.applied`, and the bus restarts: the start ends with no grant record, no reference and no key file. The same with a failure after step 5 in place of the restart (C1) |
-
-Mutants, a first list. The row's BUILD.md numbers them and adds more:
-
-- drop the chief check
-- start the executor on a `credential.mint` with no `grant`
-- skip the `ready` check
-- skip the keyscan compare, or compare only one key
-- skip the definition hash compare
-- drop the definition check
-- skip the commands hash compare
-- skip the host record hash compare
-- swap the order of install and the grant record write
-- skip `remove` on a verify failure
-- skip the start sweep
-- skip the reconcile's remote `remove`
-- skip the `grant.step` before install
-- `host.run` reads the business file instead of the grant record
-- revoke leaves the grant record
-- skip `register` before `issue`
-- drop the abort check before `issue`
-- add an `await` between the abort check and `issue`
-- revoke ignores a claim with no reference
-- build the tag without the business
-- `sweep` removes any `mosaic-` line
-- drop `from=` in the writer
-- let the writer touch a line outside the tag pattern
-- drop `O_NOFOLLOW` on the user file
-- drop one group from the writer's refused list
-- drop the user pattern check before the path use
-- treat a `privileged` entry as enough without `users`
-- let the writer accept a sudo user not in `privileged`
-- run revoke's host step before the local steps
-- start the executor on an arbiter resolve
-- start it on `no`
-- write the private key into the event body
-- drop the "not yet enrolled" check in E2 step 1
-- drop the `hosts` primary key
-- claim before consume, or put an `await` between them
-- skip the start check for a resolved, unspent grant decision
-- make `commit` async
-- route `hosts.revoke` through `credential-verbs.mjs`
-- skip the revoke marker reconcile
-- let the undo to `previous` insert a record (an upsert)
-- let the undo to `previous` run past a newer `grant.revoked`
-- let the executor act on an abort after step 5 commits
-- skip the start sweep of key files with no record
-- treat a missing `bus.tester` as dev
-
-## 11. Not in this draft
-
-- Gitea and GitHub grants (`method` `gitea` and `github`). The same flow: chief raise, Jason approves, the
-  executor mints a token through an admin credential Jason enters, writes the reference, and revoke deletes
-  the token at the service. The admin scope is refused today (`vocabulary.mjs:105-106`), so that is a
-  design of its own.
-- The Console Approve (#435) and the Console token entry. Both wait on Q175 sign-in (#412).
-- The network-confined sandbox (Sage's follow-up from 210 section 6).
-- A per-key forced command on the host (section 9).
-- Changing an enrolled host's user or sudo mark. Today that is `hosts remove` and a new enrollment.
-
-## 12. Questions
-
-Answered since r1:
-
-- Q-S1 (sage-1527): no `grant.ask` in row a. Messaging the chief, with the definition gating the raise, is
-  enough. If review finds a forgery path, the verb comes then. Duckworth agrees (N4).
-- Q-S2 (mos-1120, sage-1527): `<configDir>/secrets/hosts/<business>/<hostId>/installer`.
-- Q-S3 (sage-1527): manual mode is Honker's REQ-TRUST-2, and REQ-CRED-5 is folded into REQ-GRANT-1 to -4.
-- Q-S4 (sage-1527): the split stands, both rows are mine, and Duckworth reviews both.
-  - Row a (#436a): enrollment as the approved request, the four `tools/host` files, the store records and
-    their migration, `host.run` reading them, and `hosts status`. More than r2's 1 day, because of the
-    migration and moving 210's tests. My estimate is 1.5 days.
-  - Row b: the raise binding, the executor, reconcile and revoke, after row a. r5 adds the `hosts.revoke`
-    verb and its marker, so my estimate goes from 1.5 days to 1.75.
-  - Both come after row 210 lands and need the 1.8 line before landing. Target: in review by 10-24, so
-    row a lands before the 10-26 installs (S1, mos-1133).
-- Q-M1 (mos-1120): Mos revokes as the tester. Replaced by mos-1132, see below and section 6.
-- Q-O1 (ops-01 through mos-1125): yes, with the six changes now in E3.
-- Q-O2 (ops-01, reply to gizmoduck-0063): the `privileged` file is accepted, with four rules and four writer
-  points, all in E3 and section 9.
-- Q-S5 (mos-1124 d, through honker-0035): the assistant may revoke grants in its own organization, and the
-  tester only on a dev instance. PRD 1.8 r3 (d16ccdb91) REQ-GRANT-4 keeps that. Section 6 follows it.
-- **Q-M2 (mos-1132).** ops-01 is a T3 seat and can't message a chief. Host keys never travel by message.
-  The request carries expected fingerprints, and the raise runs its own keyscan (E1). On the #433 VM, Mos or
-  Sage passes the fields to the chief as the tester (Q173). On .53 and .54, Jason sends the request in the
-  Console (Q118), with text Mos builds from ops-01's values.
-- **Mos as a revoker (mos-1132).** Q188's "Mos" is read as the stack's assistant role, Jason's main
-  interaction agent. This is Mos's reading, labelled as such, and goes in the PRD 1.8 approval notes. Jason
-  settles it at prd.approve. Section 6 is written to it.
-
-Open: none from this draft.

agents/gosalyn/README.md

@@ -1,11 +0,0 @@
-# Gosalyn
-
-Worker seat for Mosaic Stack, MVP track T2 (Case 2, the creative writing hub, Vikunja #416).
-
-- T3 thread: 7604438a-0ded-41c8-bd3f-26f57fdb5cd2
-- Model: Opus 5.5 (Claude Code, T3)
-- Launched by Mos (Jason's main agent, T3 38bc4c81-6270-4021-b00c-6a15c43b9b0e), who briefs the seat
-- Repository lead and queue: Sage (T3 1ef1e4f8-3ead-4208-beca-38f9f1add079)
-- Branch: gosalyn/case2-design, pushed only by this seat, landed on refactor by Sage
-
-Work lives in `work/`. The Case 2 design is `work/case2/DESIGN.md`.

agents/sage/work/window-plan/repin-4429a104f.md

@@ -1,124 +0,0 @@
-# Re-pin 490e2771d to 4429a104f (row 192, Q175 phase 1), with npm ci in the new copy
-
-Sage, 2026-10-20, draft 1, for mos-1099 item 3 under DECISIONS Q173. Mos checks this file at its commit before
-P0. Any change to this file or to NEW after the check means Mos checks again (mos-0849/0850).
-
-This is a smaller window than `repin-rows-177-185.md` (draft 2, which Mos checked in mos-0929). Where a step is
-the same, this file names that file's step and says what differs. The 7332 matrix, the snapshot, the W9 list and
-the rollback compare are reused unchanged.
-
-## Who, and what nobody does
-
-- Sage operates, as the tester. Darkwing holds the gate lane for row 190 round 3 tonight, so I take the
-  operator seat. Mos verifies each step's output before the next one and runs `rehearse` (P3), which reads the
-  live config and a live backup (`docs/TOOLS.md` `rehearse`: Jason or Mos runs it).
-- Jason has no step. Q173 covers a re-pin of this test system with a backup first and a STATE report after.
-  Nothing is pruned.
-- Nobody acts as Jason: no `--by jason`, no human shell or tmux pane, every bus read and write carries
-  `--tester`, and no request carries `jason.woltje`. `bus.tester` stays as it is; if it isn't `true`, stop at P1.
-- No pi (mos-0865 D2, P19 #383). No Save in the human Console, no `mosaic name`.
-- Outside reach doesn't change. The Console keeps its current flags. `--sso` stays off: row 192's sign-in code is
-  dormant without the flag, and `cli.mjs:57` refuses `--sso` with the preview flags the pointer carries anyway.
-  The proof pair stays unset. The tunnel still forwards 7332 only (P4 and W10 check it).
-
-## Names
-
-- OLD, live: `490e2771d3d057ab76991e2c7859cd251857e64c`, activation `20261020T192956Z-490e2771d3d0`, pointer
-  `pm: true`, schema 3i, Console `--port 7332 --public-host mosaic.woltje.com --auth-header X-authentik-username
-  --allow-user jason.woltje --tester-port 7333` (no `--send`, read from `stack-release.sh status` between 21:36Z and 21:39Z).
-- NEW: `4429a104f6d65ccf165f6c83b5d1dce3147dfde0`, row 192's landing, 106 commits past OLD counting records.
-  The commits after it (5b8def2f1 plans, 176a6bf4b sessions, 305857c8f queue) are records and don't move NEW. If
-  another code row lands before W0 (row 190 is the likely one), NEW stays here unless Mos rules otherwise.
-- REPO: the canonical checkout. `activate` runs REPO's `webui-service.sh`, so the four service scripts are held
-  at NEW for the window (P5).
-- `P=/mnt/storage/scratch/sage-pin-de352dfaf` (`business-check.mjs`, `console-check.sh`, checked against
-  `agents/sage/work/window-plan/repin-de352dfaf/SCRIPTS.sha256`).
-- `WIN=agents/sage/work/window-repin-4429a104f/`, where every transcript goes.
-- `SNAP=$WIN/snapshot.mjs`, a copy of `agents/darkwing/work/window-rows-177-185/snapshot.mjs`, sha256
-  `639fd28a2674aaa03ce824e3394b4052f21cdef7d6fa49bae61a9927ed341e67` (mos-0899). I check the sha before S1, S2
-  and any D3.
-
-## What NEW carries over OLD
-
-The path-limited log over `packages`, `scripts`, `roles`, `contracts`, `adapters`, `skills` and the package files:
-
-| Row | Commit | Live effect |
-|---|---|---|
-| 186 | 269134d8d | Tool only: the activate plan's backup line says what the run will do. |
-| 187 | 9a71e4e80 | Tool: activate sets, carries and drops the proof pair. The pointer has no pair, so nothing changes. |
-| 188 | 8fc0ee216 | Tool: proof file checks on a carried pair. No pair, no effect. |
-| 163 | 8ecc7a239 | Tool: `rehearse`, which P3 uses, and `bus start --no-launch`. CLI `cli.mjs` and `launcher.mjs` gain the `--no-launch` path; the default start is unchanged. |
-| 189 | ace27dc5e | Tool: `activate --no-send`. Live already runs without `--send`; the pointer carries that. |
-| 192 | 4429a104f | Console `--sso` (off here), `scripts/mosaic-config.mjs` load becomes async, `webui-service.sh` renders `--sso` only when given, and a new dependency, oauth4webapi 3.8.8. `cli.mjs` imports `sso.mjs` at the top, so the Console won't start from a copy without that module. |
-
-No schema step: `SCHEMA_VERSION` (`packages/bus/src/store.mjs:17`) is 3i at OLD and NEW, and no migration was
-added. `--plan` must say `migration: none`. No roles, skills, contracts, adapters or plug-in kinds changed. So: no
-harness set, no skill carry, no `pm-on`. One `activate --pm`.
-
-## npm ci in the new copy
-
-mos-1099 asks for npm ci in the new copy. `stack-copy.sh copy` already does it: it extracts the archive to a temp
-dir, refuses without `package.json` and `package-lock.json` (:55), runs `npm ci --no-audit --no-fund` there and
-writes no copy if it fails (:56). W0 checks the result: `node_modules/oauth4webapi/package.json` in the copy reads
-3.8.8, and `node --input-type=module -e "await import('oauth4webapi')"` from the copy exits 0. The live copy is
-163M; `/home` has 30G free (94% used), enough for one more.
-
-## Backups
-
-| Before | Backup | Taken by |
-|---|---|---|
-| W5 | the stopped store, `$DATA/backups/stack/<W5 activation id>/` with SHA256SUMS, DATA_ROOT, SCHEMA 3i, STAMP | `stack-release.sh` (row 185: every activate) |
-| W5 | the rollback set (units, wrapper, pointer) | `stack-release.sh` |
-| W9 | the business file, `cp -p` to `~/.config/mosaic-dev/businesses/mosaic-stack.json.pre-window-<stamp>` with its sha256, as evidence nothing wrote it | Sage, in W0b |
-
-## Before the window (nothing stopped)
-
-| # | Who | Step |
-|---|-----|------|
-| P0 | Mos | The `$P` sha check, as in the 177-185 plan P0. |
-| P1 | Sage | The business file, read only, the same values as the 177-185 plan P1. I report its sha256 now rather than assume the 06:15Z value. `business-check.mjs` for OLD now and for NEW after W0: LOAD_OK both. |
-| W0 | Sage | `cd $REPO && scripts/stack-copy.sh copy $NEW`, in a gap between gate-lane runs, since npm ci is heavy. Then the two npm checks above, and `diff <(git -C $REPO show $NEW:package-lock.json) $COPIES/$NEW/package-lock.json` empty. W0 writes only under `copies/` and changes nothing live, so it moves before P2 and P3, which need the copy. |
-| P2 | Sage | `console-check.sh $NEW` against a stub Console of NEW on a scratch port, once without and once with `--tester-port` on a second scratch port. CONSOLE_PASS both. |
-| P3 | Mos | `scripts/stack-release.sh rehearse $NEW mosaic-stack --backup 20261020T192956Z-490e2771d3d0 --port <scratch>`. It must pass every gate check but the PM's, with the pointer's Console flags. It stops no unit and writes no pointer. Transcript in `$WIN/p3/`. |
-| P4 | Sage | The tunnel read, as in the 177-185 plan P4. |
-| P5 | Sage | `git -C $REPO diff --quiet $NEW HEAD -- scripts/stack-release.sh scripts/webui-service.sh scripts/bus-service.sh scripts/stack-copy.sh` and an empty `git status --porcelain` on the same four. Row 190 round 3 touches `webui-service.sh`; if it lands before W5, P5 fails and the window waits for Mos's ruling. |
-| P6 | Sage | The 7332 matrix (a)-(g) on OLD, as in the 177-185 plan, saved as `$WIN/matrix-old.txt`. |
-
-## The window
-
-| # | Who | Step |
-|---|-----|------|
-| W0b | Sage | The business file copy. |
-| W1 | Sage | Idle check (`mosaic agents --business mosaic-stack --tester`, `mosaic launches list`), the start stamp from `date -u`, then S1 `node $SNAP --store "$DATA/bus/bus.sqlite" --held`. |
-| W2 | Sage | `stack-release.sh status mosaic-stack`: pointer on OLD, `pm: true`, 3i, last line ok, unit flags match. |
-| W3 | Sage | `stack-release.sh activate $NEW mosaic-stack --pm --plan`. Must show from OLD to NEW, `migration: none`, the backup line, and the Console line with OLD's flags exactly: no `--send`, no `--sso`, no proof pair, `--tester-port 7333`. Any other difference stops here. |
-| W4 | Sage | The unit reads, as in the 177-185 plan W4. |
-| W5 | Sage, on Mos's go | `stack-release.sh activate $NEW mosaic-stack --pm`. Exit 0, `result ok`, every gate check including `pm_launched`. Record the activation id, the backup path and STAMP, and the backup SHA256SUMS sha256. Then `status`. |
-| W9 | Sage, after Mos verifies W5 | The 177-185 plan's W9 list unchanged, the chief turn and the one `assistant` thread turn included (mos-0929 Q3), plus two lines: the webui journal since the W5 stamp (with `UTC`) has one `Proxy: proxy proof off` and no `Sign-in:` line, and `ls -l /proc/<Console pid>/cwd` names the NEW copy. |
-| W10 | Sage | The browser check on 127.0.0.1:7333 and the matrix again as `$WIN/matrix-new.txt`, identical to `matrix-old.txt`. Then P4 again. |
-| W11 | Sage | STATE report in `$WIN/STATE.md`, posted on P19 386 and P19 412 and on Gitea #1690. |
-
-## Stop conditions and rollback
-
-The same as the 177-185 plan. Two failures in one window: stop and report (mos-0823).
-
-Rollback: `stack-release.sh rollback mosaic-stack --plan`, then the real run. The previous distinct copy in the
-log is 490e2771d, both are 3i, so no `--restore` and no data loss. OLD takes the same Console flags. The R1 and
-R1post compares are as in the 177-185 plan. A restore past W5 follows that plan's D3 steps, with Mos deciding.
-
-Keep every copy. Prune nothing.
-
-## Questions for the plan check
-
-- Q1: NEW is row 192 alone, not bundled with row 190. Row 190 (several instances) changes `stack-release.sh`
-  and `webui-service.sh` and deserves its own window. I recommend running this one first.
-- Q2: Sage operates instead of Darkwing, who is on the row 190 gate. OK?
-- Q3: W0 before P2 and P3. It writes a copy only. OK?
-
-## What Sage ran for this plan
-
-Read only, 2026-10-20 between 21:36Z and 21:39Z (clock read 21:39:50Z at the commit): `stack-release.sh status mosaic-stack` (pointer, last five log
-lines, unit flags match, 106 commits of drift), `git rev-list --count`, `SCHEMA_VERSION` at both ends, the
-path-limited log, `git diff --stat` on the service scripts, CLI and config loader, `stack-copy.sh:23-56`,
-`webui/src/cli.mjs:15-120`, `docs/TOOLS.md` on `rehearse`, `du -sh` of the live copy and `df -h /home`. Nothing
-live was changed.

docs/SESSIONS.md

@@ -1363,5 +1363,3 @@ are never rewritten or removed; corrections are new entries.
 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-20T20:40:15Z | Filbert (Opus 5.5, 048f3c63) | row 190 (#1688) manifest round 1 review, candidate 8862feccc (static) | CHANGES: B1 base drift, row 189 ace27dc5e conflicts in stack-release.sh, rebase + full gate rerun; N1-N7 notes; Gitea 29634, queue rev 2362 (uncommitted, left for Sage)
-2026-10-20T21:29:20Z | Filbert (Opus 5.5, 048f3c63) | row 190 (#1688) manifest round 2 review, candidate 537a02392 (static) | CHANGES: B1 base drift, row 192 4429a104f conflicts in mosaic-config.mjs and webui-service.sh (async load); round 2 content fine; Gitea 29685, queue rev 2447 (uncommitted, left for Sage)

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 2455 by `queue render`. Do not edit between the markers; change the queue with `scripts/mosaic queue`.
+Generated from `docs/plans/queue.json` revision 2361 by `queue render`. Do not edit between the markers; change the queue with `scripts/mosaic queue`.
 
 | # | Piece | Owner | Issues | State | After | Gate | Brief | Note |
 |---|---|---|---|---|---|---|---|---|
@@ -226,14 +226,14 @@ Generated from `docs/plans/queue.json` revision 2455 by `queue render`. Do not e
 | 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 | done | 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 | Landed ace27dc5e on refactor (cherry-pick of candidate d6116771f onto a4a42dbac). Gate GATE_PASSED on 0c177e9ef (base 0217b71c8), 2026-10-20T19:09:37Z-19:20:36Z, 25 suites rc=0. patch-id ce89378718f6 for both 0c177e9ef and ace27dc5e; range-diff differs only in the message. Landed manifest hashes to 67af69bd (Dewey approve 29485). Base drift 0217b71c8..a4a42dbac: 7 doc/README files, none on manifest paths, no test reads them. Brief re-pinned to blob 29a9e6d2d. |
-| 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-review, round 2, request posted | — | 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 | — |
+| 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-review, round 1, request posted | — | 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 | — |
-| 192 | Q175 phase 1: the Console verifies SSO itself (--sso), OIDC RP with oauth4webapi 3.8.8, no live change (MVP T1.2, #412) | launchpad; reviewers webby | #1690 | done | — | Webby approves the manifest; webui and cli suites, scripts/test-config.sh and every scripts/test-*.sh green on Sage's gate; design section 9 mutants killed (sage) | `docs/plans/2026-10-20_sso-phase1.md` § Brief: Q175 phase 1, the Console verifies SSO itself (--sso) | Landed 4429a104f on refactor (squash of launchpad/row192 53bb59462..37582e820, round 2 manifest 6f8cee14...7787). patch-id 4a4869026 matches the reviewed diff on all 18 paths. Gate on 088087ac9: package suites 2758/0, scripts 429/0, mutants 22 of 23 killed (#23 equivalent, sage-1407). npm ci in canonical, oauth4webapi 3.8.8. Live re-pin is a window with Mos (mos-1099 item 3). |
+| 192 | Q175 phase 1: the Console verifies SSO itself (--sso), OIDC RP with oauth4webapi 3.8.8, no live change (MVP T1.2, #412) | launchpad; reviewers webby | #1690 | in-review, round 2, request posted | — | Webby approves the manifest; webui and cli suites, scripts/test-config.sh and every scripts/test-*.sh green on Sage's gate; design section 9 mutants killed (sage) | `docs/plans/2026-10-20_sso-phase1.md` § Brief: Q175 phase 1, the Console verifies SSO itself (--sso) | — |
 | 193 | many humans per business, human roles, private and shared threads, one access.json store (MVP T1.3, Vikunja #414/#415) | morgana; reviewers duckworth | #1691 | in-progress | — | Duckworth approves DESIGN.md then the manifest; bus, business, cli and webui suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_human-users.md` § Brief: many humans per business, human roles, private and shared threads | — |
 | 194 | agent lifecycle from the Console and the CLI (create, launch, terminate, regenerate, delete) with a per-agent hire/fire veto (MVP T1.5, Vikunja #414/#415) | honker; reviewers webby | #1692 | in-progress | — | Webby approves DESIGN.md then the manifest; bus, cli, business and webui suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_agent-lifecycle.md` § Brief: agent lifecycle from the Console and the CLI, with a per-agent hire/fire veto | — |
 | 195 | row 195: the Case 1 install on 10.1.1.53 as mosaic under /srv/mosaic, reusing C2-13's scripts by input under row 190's canon (Q181, Q182/Q183, Q185; ops-01 root steps under #423 step 1) | darkwing; reviewers duckworth | #1693 | briefed | 190 done | Duckworth approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_hub-own-uid.md` § Brief: the Case 1 install on 10.1.1.53 (row 195) | sage-1439: rewritten to Case 1 on .53 (f24f2cd40). Chains on C2-13's candidate too once C2-13 is queued. Darkwing starts DESIGN.md after row 190's mutants. |
 | 196 | the human boundary across uids and humans: Console, tester listener, broker.sock and the path-bound human proof (P19 333, before federation R3, mos-0989) | gander; reviewers duckworth | #1694 | in-progress | — | Duckworth approves DESIGN.md then the manifest; bus, webui and cli suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_human-boundary.md` § Brief: the human boundary across uids and humans (P19 333) | — |
-| 197 | a second gate lane: two full gates at once on dragon-lin, design first (mos-0977 item 6) | herb; reviewers webby | #1695 | in-review, round 1, request posted | — | Webby approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate, singly and in the two-lane proof (sage) | `docs/plans/2026-10-20_second-gate-lane.md` § Brief: a second gate lane, two full gates at once on dragon-lin | Order with row 198 (Sage, mos-1040 N1): 197 lands first. After B1 the shared tests are packages/webui/tests/serve.test.mjs:100 and preview.test.mjs:208. Row 198 rebases onto 197's landing before its manifest review. |
+| 197 | a second gate lane: two full gates at once on dragon-lin, design first (mos-0977 item 6) | herb; reviewers webby | #1695 | in-progress | — | Webby approves DESIGN.md then the manifest; cli suite and every scripts/test-*.sh green on Sage's gate, singly and in the two-lane proof (sage) | `docs/plans/2026-10-20_second-gate-lane.md` § Brief: a second gate lane, two full gates at once on dragon-lin | Order with row 198 (Sage, mos-1040 N1): 197 lands first. After B1 the shared tests are packages/webui/tests/serve.test.mjs:100 and preview.test.mjs:208. Row 198 rebases onto 197's landing before its manifest review. |
 | 198 | retire the control board writer on 7331 (unauthenticated loopback writer, Q175; mos-1008) | bushroot; reviewers webby | #1696 | in-progress | 192 done, 197 done | Webby approves INVENTORY.md then the manifest; control-board, webui and cli suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_retire-control-board.md` § Brief: retire the control board writer on 7331 | Order with row 197 (Sage, mos-1040 N1): 197 lands first. Row 198 rebases onto 197's landing before its manifest review; shared tests are packages/webui/tests/serve.test.mjs:100 and preview.test.mjs:208. |
 | 199 | MVP T1 item 6: a credential store per agent, own git identity, pushes to a remote (G11, G13; mos-0974) | megavolt; reviewers duckworth | #1697 | in-progress | — | Duckworth approves DESIGN.md; Mos rules on the authority model; Duckworth approves the manifest; bus, business, cli and tasks suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_agent-credentials.md` § Brief: a credential store per agent, own git identity, pushes to a remote | — |
 | 200 | stack-release.sh activate --sso for the Q175 phase 2 window (row 192 F3; chained on 192) | launchpad; reviewers webby | #1698 | in-review, round 2, request posted | — | Webby approves the manifest; cli suite and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_stack-release-sso.md` § Brief: stack-release.sh activates a Console with --sso (Q175 phase 2 prerequisite) | — |
@@ -248,25 +248,6 @@ Generated from `docs/plans/queue.json` revision 2455 by `queue render`. Do not e
 | 209 | FED R8: the hub window on 10.1.1.54, a recorded acceptance (#414, r4.11 b93f098f0; live window run by Jason and Mos, after the Case 2 install #416, Bean and Chet live and both Hermes gateways stopped) | sage; reviewers duckworth | — | queued | — | Every entry check's output is in the R8 record with who ran it; Jason signs in to the hub and sends one message, Melanie revokes, his next request is refused; Duckworth checks the record (sage) | `docs/plans/2026-10-20_federation-r1-r2-r5.md` § Brief: FED R8, the hub window on 10.1.1.54 | Stays queued until its entry gates near: Case 2 install on .54 (#416, by 2026-10-27), Bean and Chet live, both Hermes gateways on .54 stopped, R7, #412 phase 2, #419 answer. Filed per mos-1073 after duckworth-0034 (Sage) |
 | 210 | Agent host access with sudo through the credential store: grant per agent and host, the stack does ssh and sudo, the agent never sees the key (#1707, Vikunja #424, Q183/Q184, due 10-27; chained on row 199's candidate) | gizmoduck; reviewers duckworth | #1707 | in-progress | — | Duckworth approves DESIGN.md, then the manifest; bus, business, cli suites and every scripts/test-*.sh green on Sage's gate; the mutants killed (sage) | `docs/plans/2026-10-20_host-credentials.md` § Brief: agent host access with sudo through the credential store (#424) | Design runs before 199 lands (Q177 chain on 199's candidate). after cleared so Gizmoduck can claim; lands only after 199 and rebases onto it. |
 | 211 | Force-push guard: scripts/git-hooks/pre-push refuses non-fast-forward and delete pushes from every worktree, and scripts/slot-busy.sh exits 1 on BUSY (#1709, Vikunja #426, mos-1078/1083) | rocko; reviewers dewey | #1709 | briefed | — | Dewey approves the manifest; the new or changed scripts/test-*.sh and every other scripts/test-*.sh green on Sage's gate; the mutants killed; hook installed in the canonical checkout with a scripted refused force-push (sage) | `docs/plans/2026-10-20_force-push-guard.md` § Brief: a pre-push hook that refuses force-pushes, and a busy check that fails on BUSY (#426) | — |
-| 212 | Case 2 C2-01 packages/library: mapping, scope, reader, resolver, R-rules, renderItems, survey | gosalyn; reviewers webby | #1713 | in-progress | — | Webby approves the manifest. The library tests and the cli suite are green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-01 packages/library: mapping, scope, reader, resolver, R-rules, renderItems, survey | — |
-| 213 | Case 2 C2-08 creative roles, persona file and block, M1, M2, M6, M10, prompt passed by file | morgana; reviewers webby | #1714 | in-progress | — | Webby approves the manifest. The business, bus and harness suites, `scripts/test-config.sh` and every `scripts/test-*.sh` are green on Sage's gate, and the `models` mutant is killed. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-08 creative roles, persona file and block, M1, M2, M6, M10, prompt passed by file | — |
-| 214 | Case 2 C2-11a editor wikilink node, after measuring whether [[ round-trips | rocko; reviewers filbert | #1715 | briefed | — | Filbert approves the manifest. The webui suite is green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-11a editor wikilink node, after measuring whether [[ round-trips | — |
-| 215 | Case 2 C2-04 the library entry in the business file, consumer skips, M9, mirror, library.file and library.status | herb; reviewers filbert | #1716 | briefed | — | Filbert approves the manifest. The business, seat, cli, project, bus and webui suites are green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-04 the library entry in the business file, consumer skips, M9, mirror, library.file and library.status | — |
-| 216 | Case 2 C2-05a lookup index and queries | researcher; reviewers filbert | #1717 | briefed | — | Filbert approves the manifest. The library suite is green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-05a lookup index and queries | — |
-| 217 | Case 2 C2-06 the cited-reply guard, the page store and the three notices | launchpad; reviewers webby | #1718 | briefed | — | Webby approves the manifest. The library, bus and harness suites are green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-06 the cited-reply guard, the page store and the three notices | — |
-| 218 | Case 2 C2-12 the setup sheet for Melanie and the survey run sheet | sage; reviewers webby | #1719 | briefed | — | Doc only. Webby approves it against C2-01's real flags. Before landing, grep `packages/*/tests` and `scripts/test-*.sh` to confirm no test reads either file. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-12 the setup sheet for Melanie and the survey run sheet | — |
-| 219 | Case 2 C2-09a one thread per creative instance | rocko; reviewers dewey | #1720 | briefed | — | Dewey approves the manifest. The bus, cli and webui suites are green on Sage's gate, along with every `scripts/test-*.sh`. Watch for hash pins on `bus.js` and `broker.mjs` (`packages/bus/tests/channel-proof.test.mjs` pins a webui file). (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-09a one thread per creative instance | — |
-| 220 | Case 2 C2-10a no raw session view (M7) and no raw Discord engine (M8) | researcher; reviewers filbert | #1721 | briefed | — | Filbert approves the manifest. The conversation and discord suites and `scripts/test-discord.sh` are green on Sage's gate, along with every `scripts/test-*.sh`. No test reaches a Discord server. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-10a no raw session view (M7) and no raw Discord engine (M8) | — |
-| 221 | Case 2 C2-20 Bean and Chet persona import, with a count-only dry run | gosalyn; reviewers webby | #1722 | briefed | — | Webby approves the manifest. The test file runs green on its own and the cli suite is green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-20 Bean and Chet persona import, with a count-only dry run | — |
-| 222 | Case 2 C2-03a fetch-only sync | megavolt; reviewers dewey | #1723 | briefed | — | Dewey approves the manifest. The library and bus suites are green on Sage's gate, along with every `scripts/test-*.sh`, and the mutant is killed. A search of the test run's output for the fixture token finds nothing. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-03a fetch-only sync | — |
-| 223 | Case 2 C2-07 runner retry on a guard refusal, and the runner's notices | researcher; reviewers filbert | #1724 | briefed | — | Filbert approves the manifest. The harness suite is green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-07 runner retry on a guard refusal, and the runner's notices | — |
-| 224 | Case 2 C2-05b broker lookup verbs and typed tools | rocko; reviewers dewey | #1725 | briefed | — | Dewey approves the manifest. The bus and harness suites are green on Sage's gate, along with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-05b broker lookup verbs and typed tools | — |
-| 225 | Case 2 C2-10b Console chat: cited items and the status line | researcher; reviewers dewey | #1726 | briefed | — | Dewey approves the manifest. The webui suite is green on Sage's gate, along with every `scripts/test-*.sh`. Grep for hash pins on `bus.js` and `serve.mjs` before in-review. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-10b Console chat: cited items and the status line | — |
-| 226 | Case 2 C2-13 install script and precheck for the host | gosalyn; reviewers webby | #1727 | briefed | — | Webby approves the manifest. The test file and the cli suite are green on Sage's gate, along with every `scripts/test-*.sh`. The run on the host is a separate window with Jason's go. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-13b install script and library precheck | — |
-| 227 | Case 2 C2-14 end-to-end acceptance on a scratch root | launchpad; reviewers dewey | #1728 | briefed | — | Dewey runs the script and approves. It is green on Sage's gate with every `scripts/test-*.sh`. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-14 end-to-end acceptance on a scratch root | — |
-| 228 | Row A: ZAI_API_KEY passes through ENV_ALLOW to sessions, README line, pass-through test (XS, Haiku high) | researcher; reviewers webby | #1729 | in-review, round 1, request posted | — | Webby approves the manifest. The mutant is killed. The seat suite and the cli suite are green on Sage's gate with every scripts/test-*.sh. (sage) | `docs/plans/2026-10-20_case2-rows.md` § Brief: row A, ZAI_API_KEY in the session env allowlist | — |
-| 229 | Row B: per-instance pi agent dir for Chet's Codex login, design only, starts after 10-27 (#428) | gosalyn; reviewers webby | #1730 | queued | — | A live check, with Jason's or Mos's go, that two clients on one ChatGPT login don't revoke each other's refresh tokens. No build row starts before it passes. Held until after 10-27. (sage) | `docs/plans/2026-10-20_case2-rows.md` § Brief: row B, a per-instance pi agent dir for Chet's Codex login (#428) | — |
-| 230 | Case 2 C2-13a unit render and host precheck (case2-unit.sh, case2-precheck.sh) | gosalyn; reviewers webby | #1732 | briefed | — | Webby approves the manifest. The test file and the cli suite are green on Sage's gate, along with every scripts/test-*.sh. A run on a host is a separate window with Jason's go. (sage) | `docs/plans/2026-10-20_case2-rows.md` § C2-13a unit render and host precheck | — |
 
 <!-- mosaic-queue:end -->
 

package-lock.json

@@ -9,8 +9,7 @@
       "version": "0.0.3",
       "license": "UNLICENSED",
       "dependencies": {
-        "@earendil-works/pi-coding-agent": "0.85.1",
-        "oauth4webapi": "3.8.8"
+        "@earendil-works/pi-coding-agent": "0.85.1"
       }
     },
     "node_modules/@anthropic-ai/sdk": {
@@ -1934,15 +1933,6 @@
         "url": "https://opencollective.com/node-fetch"
       }
     },
-    "node_modules/oauth4webapi": {
-      "version": "3.8.8",
-      "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.8.8.tgz",
-      "integrity": "sha512-8N28E+a/oxfXWBgOMt+ZP/JUf/XR+IFbvkAEPP3gznXOMv9BpAAwiIj0TFNz3tGTPc0ZQ8zmWBNgN1nAys0gng==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/panva"
-      }
-    },
     "node_modules/openai": {
       "version": "6.40.0",
       "resolved": "https://registry.npmjs.org/openai/-/openai-6.40.0.tgz",

package.json

@@ -5,7 +5,6 @@
   "description": "Minimal Mosaic Stack container proof of concept: one Pi agent, four local contract files, one real model request returning MOSAIC_HELLO_OK.",
   "license": "UNLICENSED",
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "oauth4webapi": "3.8.8"
+    "@earendil-works/pi-coding-agent": "0.85.1"
   }
 }

packages/webui/README.md

@@ -129,45 +129,6 @@ Switching the Console, bus or wrapper, changing any unit, and starting or
 stopping either service requires Mos's go for that live step. Agents build
 and test fixtures; they stop before the live sequence.
 
-## Sign-in in the Console (Q175 phase 1, #1690)
-
-`serve --sso [--send] [--tester-port N]` makes the Console an OpenID Connect
-relying party. It reads `console.sso` from the system config (`publicOrigin`
-and one or more providers, each with its issuer, client id, a client secret
-slot, the signing algorithms it accepts and the subjects allowed in). The
-design is `agents/sage/work/q175-sso/DESIGN.md`. `--sso` can't be combined
-with `--public-host`, `--auth-header`, `--allow-user` or `--proof-*`; `--send`
-takes `--sso` in place of the preview set.
-
-- The client secret is read once at start from
-  `<config dir>/secrets/mosaic-stack/<slot>`. The start refuses a slot that is
-  a symbolic link, not a regular file, owned by another user, has any group or
-  other mode bit, or sits in the repository, the `--checkout` directory or a
-  stack copy. The value is never printed.
-- At start the Console fetches each provider's discovery document and JWKS. A
-  provider that can't be reached (a network error, a timeout, a status other
-  than 200, or a body that isn't JSON) leaves the Console up with that
-  provider's `/auth/login` at 503 and a retry every 5 s, doubling, capped at 5
-  minutes. A document that fails a check (issuer, algorithms, S256, a usable
-  key) refuses the start. `/healthz` adds `sso: { <id>: "ready" | "unreachable"
-  | "refused" }`.
-- The Console listener serves only the Host of `publicOrigin`, whatever port
-  it listens on. Any other Host, a loopback one included, gets 403 `public
-  Host required`, except `GET /healthz`, which stays open on loopback for the
-  status and release gates. The loopback operator path in the preview section
-  above does not exist under `--sso`.
-- Without a session, `/api/*` gets 401 `sign-in required` and a page load gets
-  a 303 to `/auth/login?return=<path>`. The page then shows the signed-out line
-  with a link back to sign-in. A session lasts at most 8 hours and ends after 1
-  hour without a page load or a write; a restart ends every session.
-- The page shows Sign out only under `--sso`. It posts to `/auth/logout`, which
-  ends the session and goes to the provider's end-session endpoint when it has
-  one, or to `/auth/signed-out`.
-- With `--tester-port`, the tester listener refuses any request carrying an
-  `Authorization` header, a `__Host-mosaic_session` or `__Host-mosaic_login`
-  cookie, or an `x-authentik-*` header (403 `tester listener takes no
-  sign-in`). It never serves `/auth/*`.
-
 ## Message a role (row 76, #1570)
 
 ```sh

packages/webui/src/chat-http.mjs

@@ -58,9 +58,8 @@ export async function chatHTTP(req, res, { path, search, chat, named, send, prev
       if (one(req, 'origin') !== preview.origin) return refuse(403, 'cross-origin');
     } else {
       if (!send || !named || !preview) return refuse(403, 'read-only');
-      // Q175 phase 1 (#1690): under --sso the session was checked before this route.
-      if (preview.sso !== true && one(req, preview.header) !== preview.user) return refuse(401, 'unauthenticated');
-      if (one(req, 'origin') !== (preview.origin ?? `https://${preview.host}`)) return refuse(403, 'cross-origin');
+      if (one(req, preview.header) !== preview.user) return refuse(401, 'unauthenticated');
+      if (one(req, 'origin') !== `https://${preview.host}`) return refuse(403, 'cross-origin');
     }
     if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site');
   }

packages/webui/src/cli.mjs

@@ -7,23 +7,20 @@ import { views } from '../../bus/src/views.mjs';
 import { loadSystem, socketPath, REPO, rolesDir } from '../../cli/src/config.mjs';
 import { configDir } from '../../business/src/business.mjs';
 import { consoleReads, redactor } from './reads.mjs';
-import { createSso, readSlot } from './sso.mjs';
 import { statSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
 import { ID_PATTERN } from '../../business/src/vocabulary.mjs';
 const args = process.argv.slice(2);
-const usage = 'node packages/webui/src/cli.mjs serve [--port N] [--tester-port N] [--checkout PATH] [--board http://127.0.0.1:7331] [--business ID] [--sso [--send]] [--public-host NAME --auth-header HEADER --allow-user ID [--send] [--proof-header NAME --proof-file PATH]]';
+const usage = 'node packages/webui/src/cli.mjs serve [--port N] [--tester-port N] [--checkout PATH] [--board http://127.0.0.1:7331] [--business ID] [--public-host NAME --auth-header HEADER --allow-user ID [--send] [--proof-header NAME --proof-file PATH]]';
 try {
   if (args.length === 1 && ['--help', '-h'].includes(args[0])) { console.log(usage); process.exit(0); }
   if (args.shift() !== 'serve') throw new Error(usage);
   const options = { board: DEFAULT_BOARD, port: 7330 }, preview = {}, proofFlags = {};
-  let sendOn = false, ssoOn = false, testerPort = null;
+  let sendOn = false, testerPort = null;
   while (args.length) {
     const flag = args.shift();
     // Row 76 (#1570): the one flag without a value.
     if (flag === '--send') { sendOn = true; continue; }
-    // Q175 phase 1 (#1690): the Console signs people in itself, from console.sso in config.json.
-    if (flag === '--sso') { ssoOn = true; continue; }
     const value = args.shift();
     if (!value) throw new Error(`missing value for ${flag}`);
     if (flag === '--port') {
@@ -54,10 +51,9 @@ try {
     else throw new Error(`unknown option: ${flag}`);
   }
   if (testerPort !== null && (testerPort === options.port || testerPort === 7332)) throw new Error('--tester-port must differ from --port and cannot be the forwarded port 7332');
-  if (ssoOn && (Object.keys(preview).length || Object.keys(proofFlags).length)) throw new Error('--sso cannot be combined with --public-host, --auth-header, --allow-user or --proof-*');
   options.preview = previewOptions(preview);
   const proof = proofOptions(proofFlags, options.preview);
-  if (sendOn && !options.preview && !ssoOn) throw new Error('--send needs the preview mode (--public-host, --auth-header and --allow-user) or --sso');
+  if (sendOn && !options.preview) throw new Error('--send needs the preview mode (--public-host, --auth-header and --allow-user)');
   // The bus views (slice 1 S5) need the system config. Without it the
   // board still serves and the bus routes answer not-configured.
   // The Queue, Business and Settings reads (row 54) need no bus; without
@@ -81,46 +77,31 @@ try {
     busLine = `Bus: ${options.business ?? 'the running bus host\'s business'}`;
   } catch (err) {
     const why = redactor({ configDir: configDir() })(err.message);
-    if (ssoOn) throw new Error(`--sso needs the system config (${why})`);
     if (sendOn) throw new Error(`--send needs the bus configured (${why})`);
     if (testerPort !== null) throw new Error(`--tester-port needs the bus configured (${why})`);
     busLine = `Bus: not configured (${why})`;
   }
   const reads = consoleReads({ root: REPO, queueRoot: options.checkout ?? REPO, system, configDir: configDir(), rolesDir: rolesDir(), business: options.business ?? null });
-  // The sign-in config is checked again here, then each slot file, before anything listens. A
-  // provider that can't be reached starts degraded; one whose discovery is refused stops the start.
-  let sso = null;
-  if (ssoOn) {
-    if (!system.console?.sso) throw new Error('--sso needs console.sso in the system config');
-    const secrets = new Map(system.console.sso.providers.map(p => [p.id, readSlot(configDir(), p, { repo: REPO, checkout: options.checkout ?? null })]));
-    sso = await createSso(system.console.sso, { secrets });
-  }
-  let server;
-  try {
-    server = await startServer({ board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite });
-  } catch (err) { sso?.close(); throw err; }
+  const server = await startServer({ board: options.board, port: options.port, bus, reads, preview: options.preview, proof, send, settingsWrite, projectFiles, projectFile, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite });
   let testerServer = null;
   if (testerPort !== null) {
     const call = busCaller({ dataRoot: system.dataRoot, socket: socketPath(system.dataRoot), business: options.business ?? null, cli: TESTER_CLI });
     const testerBus = { ...views({ call }), names: () => call('names'), instances: () => call('instances'), routes: () => call('routes') };
     try {
       testerServer = await startServer({ host: '127.0.0.1', port: testerPort, board: options.board,
-        tester: true, testerNoSignIn: ssoOn, testerProofHeader: proof?.header ?? null, testerAuthHeader: options.preview?.header ?? null, bus: testerBus, reads,
+        tester: true, testerProofHeader: proof?.header ?? null, testerAuthHeader: options.preview?.header ?? null, bus: testerBus, reads,
         projectFiles: args => call('project.files', args), projectFile: args => call('project.file', args),
         instancesWrite: args => call('instances.set', args), routesWrite: args => call('routes.set', args), nameWrite: args => call('name.set', args),
         // Row 177 (#1675): the tester's own chat, through the tester CLI; 7332's stays the human's.
         chat: createChat({ call }),
       });
-    } catch (err) { sso?.close(); await new Promise(resolve => server.close(resolve)); throw err; }
+    } catch (err) { await new Promise(resolve => server.close(resolve)); throw err; }
   }
   const previewLine = options.preview ? `\nPreview: https://${options.preview.host}/ through the proxy, signed-in user from ${options.preview.header}, ${send ? 'reads and human messages to roles (--send); one line per send below' : 'read-only'}` : '';
   const proofLine = `\nProxy: proxy proof ${proof ? 'on' : 'off'}`;
-  // One line per provider: id, issuer, subject count and state. No client id, secret or sub.
-  const health = sso?.health() ?? {};
-  const ssoLines = sso ? `\nSign-in: ${sso.publicOrigin}/ (--sso), ${send ? 'reads and human writes (--send)' : 'read-only'}` + sso.summary().map(p => `\nSign-in provider: ${p.id} issuer ${p.issuer} subjects ${p.subjects} (${health[p.id]})`).join('') : '';
   const queueLine = options.checkout ? '\nQueue: read from the --checkout directory' : '';
-  console.log(`Mosaic Console: http://127.0.0.1:${server.address().port}/\nBoard: ${options.board}\n${busLine}${queueLine}${previewLine}${ssoLines}${proofLine}${testerServer ? `\nTester Console: http://127.0.0.1:${testerServer.address().port}/ (binds the tester)` : ''}\nCtrl-C stops this server.`);
-  for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); });
+  console.log(`Mosaic Console: http://127.0.0.1:${server.address().port}/\nBoard: ${options.board}\n${busLine}${queueLine}${previewLine}${proofLine}${testerServer ? `\nTester Console: http://127.0.0.1:${testerServer.address().port}/ (binds the tester)` : ''}\nCtrl-C stops this server.`);
+  for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { server.close(); testerServer?.close(); });
 } catch (err) {
   console.error(`refused: ${err.message}`);
   process.exitCode = 2;

packages/webui/src/public/app.js

@@ -16,11 +16,6 @@
   // The first one sets body.signed-out (the listener below); after that no Console fetch is made.
   const out = () => document.body.classList.contains('signed-out');
   const signOut = () => { if (!out()) document.dispatchEvent(new Event('mosaic-signed-out')); };
-  // Q175 phase 1 (#1690): under --sso the Console itself answers a read without a session with 401
-  // `sign-in required`; that signs the page out too, and the line links to the Console's sign-in.
-  // Any other 401 stays an error. `sso` comes from /api/config.
-  let sso = false;
-  const signInRequired = (res, body) => res.status === 401 && body?.error === 'sign-in required';
   const signedOut = () => Object.assign(new Error('the sign-in proxy redirected it, so it never reached the Console'), { signedOut: true });
   const labels = { registration: 'registered', 'first-user-message': 'first message', 'tmux-pane': 'tmux pane', 'session-cwd': 'session cwd', 'workspace-git-root': 'git root' };
   const source = value => value ? `<span class="source">${esc(labels[value] || value)}</span>` : '';
@@ -115,7 +110,6 @@
     const res = await fetch(path, { cache: 'no-store', redirect: 'manual' });
     if (res.type === 'opaqueredirect') { signOut(); throw signedOut(); }
     let body; try { body = await res.json(); } catch { body = { error: `HTTP ${res.status}` }; }
-    if (signInRequired(res, body)) { sso = true; signOut(); throw signedOut(); }
     return { ok: res.ok, body };
   }
   function blockNode(b) {
@@ -310,7 +304,6 @@
     const res = await fetch(path, value === undefined ? { cache: 'no-store', redirect: 'manual' } : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(value), redirect: 'manual' });
     if (res.type === 'opaqueredirect') { signOut(); throw signedOut(); }
     const result = await res.json();
-    if (signInRequired(res, result)) { sso = true; signOut(); throw signedOut(); }
     if (!res.ok) throw Object.assign(new Error(result.error || `HTTP ${res.status}`), { status: res.status });
     return result;
   }
@@ -459,7 +452,7 @@
   });
   // Signed out: everything drawn from a Console read goes, because none of it can be refreshed. The
   // line says so once; the send form (bus.js) keeps its draft and receipt. Reload is the way back.
-  document.addEventListener('mosaic-signed-out', e => {
+  document.addEventListener('mosaic-signed-out', () => {
     if (out()) return;
     document.body.classList.add('signed-out');
     clearTimeout(timer); convGen++;
@@ -468,13 +461,9 @@
     for (const id of ['projects', 'waiting', 'seen', 'sessions']) $(id).replaceChildren();
     $('refresh').disabled = $('pause').disabled = true;
     const line = $('signed-out');
-    line.innerHTML = sso || e.detail?.signIn
-      ? `<p><b>Signed out.</b> <a href="/auth/login?${esc(new URLSearchParams({ return: location.pathname + location.search }))}">Sign in again</a>.</p>`
-      : '<p><b>Signed out.</b> Reload the page to sign in.</p>';
-    line.hidden = false; $('sign-out').hidden = true;
+    line.innerHTML = '<p><b>Signed out.</b> Reload the page to sign in.</p>'; line.hidden = false;
     // Focus moves to the line only if what had it is gone or disabled, never out of a form being typed in.
     setTimeout(() => { const a = document.activeElement; if (!a || a === document.body || a.disabled || !a.getClientRects().length) line.focus(); });
   });
-  // Sign out (sage-1347, F7): a plain same-origin form POST to /auth/logout, shown only under --sso.
-  api('/api/config').then(config => { board = config.board; $('board-url').textContent = `Board: ${board}`; if (config.sso === true) { sso = true; $('sign-out').hidden = out(); } }).catch(err => { if (machine) error(err); }).finally(refresh);
+  api('/api/config').then(config => { board = config.board; $('board-url').textContent = `Board: ${board}`; }).catch(err => { if (machine) error(err); }).finally(refresh);
 })();

packages/webui/src/public/bus.js

@@ -30,10 +30,6 @@
   const out = () => document.body.classList.contains('signed-out');
   const signOut = () => { if (!out()) document.dispatchEvent(new Event('mosaic-signed-out')); };
   const signedOut = () => new ReadError('signed-out', 'The sign-in proxy redirected the read.', 0);
-  // Q175 phase 1 (#1690, sage-1340 F1): under --sso a read without a session gets 401 `sign-in
-  // required` from the Console itself. That signs out the same way; any other 401 stays an error.
-  const signInRequired = (res, body) => res.status === 401 && body?.error === 'sign-in required';
-  const signOutSso = () => { if (!out()) document.dispatchEvent(new CustomEvent('mosaic-signed-out', { detail: { signIn: true } })); };
   // `replies` takes a message id as `id`; trail takes `subject`.
   async function fetchRead(verb, subject) {
     if (out()) throw signedOut();
@@ -42,7 +38,6 @@
     catch { throw new ReadError('unreachable', 'The Console server did not answer.', 0); }
     if (res.type === 'opaqueredirect') { signOut(); throw signedOut(); }
     try { body = await res.json(); } catch { throw new ReadError('unreachable', 'The Console server did not answer.', 0); }
-    if (signInRequired(res, body)) { signOutSso(); throw signedOut(); }
     if (!res.ok || !body || !Array.isArray(body.rows)) throw new ReadError(typeof body?.error === 'string' ? body.error : 'invalid-response', typeof body?.message === 'string' ? body.message : `HTTP ${res.status}`, res.status);
     return { ...body, rows: body.rows, at: body.at };
   }
@@ -55,7 +50,6 @@
     try { res = await fetch(`/api/${path}`, { cache: 'no-store', redirect: 'manual' }); } catch { throw unreachable(); }
     if (res.type === 'opaqueredirect') { signOut(); throw signedOut(); }
     try { body = await res.json(); } catch { throw unreachable(); }
-    if (signInRequired(res, body)) { signOutSso(); throw signedOut(); }
     if (!res.ok || !body || typeof body !== 'object' || Array.isArray(body)) throw Object.assign(new ReadError(typeof body?.error === 'string' ? body.error : 'invalid-response', typeof body?.message === 'string' ? body.message : `HTTP ${res.status}`, res.status), { module: true });
     return body;
   }

packages/webui/src/public/index.html

@@ -9,7 +9,7 @@
 <header class="cmdbar"><a href="/" class="wordmark"><svg class="mark" viewBox="0 0 16 17" aria-hidden="true"><use href="/icons.svg#mark"/></svg>Mosaic<small>Console</small></a>
 <button type="button" class="cmdk" id="cmdk" aria-haspopup="dialog" aria-controls="cmdk-dialog"><svg class="i" aria-hidden="true"><use href="/icons.svg#i-search"/></svg><span>Go to a view, decision or task</span><kbd>Ctrl K</kbd></button>
 <p class="fresh" id="fresh"><span id="fresh-board"></span><span id="fresh-bus"></span></p>
-<div class="cmd-right"><label>Palette<select id="palette"></select></label><label>Appearance<select id="mode"><option value="system">system</option><option value="light">light</option><option value="dim">dim</option><option value="dark">dark</option></select></label><button class="btn" id="refresh" type="button">Refresh</button><button class="btn" id="pause" type="button" aria-pressed="false">Pause</button><form id="sign-out" method="post" action="/auth/logout" hidden><button class="btn" type="submit">Sign out</button></form></div></header>
+<div class="cmd-right"><label>Palette<select id="palette"></select></label><label>Appearance<select id="mode"><option value="system">system</option><option value="light">light</option><option value="dim">dim</option><option value="dark">dark</option></select></label><button class="btn" id="refresh" type="button">Refresh</button><button class="btn" id="pause" type="button" aria-pressed="false">Pause</button></div></header>
 <div class="frame">
 <nav class="tree" aria-label="Console"><h2 class="tree-title">Console</h2><ul class="s1-sections" id="sections"></ul><div id="board-tree"><h2 class="tree-title">Projects</h2><div id="projects"><p class="muted">Loading projects…</p></div><p class="small muted">Select a project to filter sessions. Waiting on you always shows all projects.</p></div></nav>
 <main id="main" class="content" tabindex="-1"><div id="signed-out" class="banner ref" role="alert" tabindex="-1" hidden></div><div id="bus-down" class="banner err" role="alert" hidden></div><div class="page-head" id="board-head"><div><h1>Control board</h1><p id="status" class="small muted" role="status">Loading board…</p></div><div class="filters"><label><input id="show-machine" type="checkbox">Show machine sessions</label></div></div>

packages/webui/src/serve.mjs

@@ -61,8 +61,6 @@ async function body(req, max = 4096) {
 // Row 65 (mos-0840) adds `routes`: each instance's harness, model, thinking and fallback.
 const BUS_VERBS = ['inbox', 'tasks', 'agents', 'trail', 'decisions', 'credentials', 'replies', 'messages', 'usage', 'limits', 'names', 'instances', 'routes'];
 const DECISION_LISTS = ['roles', 'recent'];
-// Q175 phase 1 (#1690, F8): either sign-in cookie, which the tester listener refuses under --sso.
-const SIGN_IN_COOKIE = /(?:^|;)\s*__host-mosaic_(?:session|login)\s*=/i;
 // Row 177 (#1675): the chat writes the tester listener lets through, exactly the four chatHTTP routes.
 const TESTER_CHAT_WRITE = /^\/api\/chat\/(?:projects|threads|threads\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/(?:messages|open))$/i;
 async function busRead(res, bus, verb, search) {
@@ -162,18 +160,14 @@ async function busRead(res, bus, verb, search) {
 // broker's to refuse. Nothing retries; an outcome the bus can't confirm is reported as unknown.
 const SEND_KEYS = ['to', 'body', 'in_reply_to'];
 const one = (req, name) => (req.headersDistinct[name]?.length === 1 ? req.headersDistinct[name][0] : null);
-// Q175 phase 1 (#1690): under --sso the writer comes from a session the handler already checked,
-// so it carries `sso: true` and the public origin; the preview writer still checks its header.
-const signedIn = (req, p) => p.sso === true || one(req, p.header) === p.user;
-const ownOrigin = p => p.origin ?? `https://${p.host}`;
 async function busSend(req, res, { send, preview, log }) {
-  if (!signedIn(req, preview)) return json(res, 401, { error: 'sign-in required' });
+  if (one(req, preview.header) !== preview.user) return json(res, 401, { error: 'sign-in required' });
   let to = null;
   // `to` is quoted and cut short so a crafted value can't forge a log line.
   const line = outcome => log(`${new Date().toISOString()} send user=${JSON.stringify(preview.user)} to=${typeof to === 'string' ? JSON.stringify(to.slice(0, 64)) : 'none'} ${outcome}`);
   // `sent` tells the page which it was: false, nothing was written; 'unknown', it may have been.
   const refuse = (status, error, message, sent = false) => { line(`error=${error}`); return json(res, status, { error, message, sent }); };
-  if (one(req, 'origin') !== ownOrigin(preview)) return refuse(403, 'cross-origin request refused', 'a send needs the Console\'s own Origin');
+  if (one(req, 'origin') !== `https://${preview.host}`) return refuse(403, 'cross-origin request refused', 'a send needs the Console\'s own Origin');
   if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site request refused', 'a send needs Sec-Fetch-Site: same-origin');
   let value;
   try { value = JSON.parse((await body(req, 16384)).toString('utf8')); } catch (err) { return refuse(400, 'invalid-request', err.message); }
@@ -247,10 +241,10 @@ export function proofOptions({ proofHeader, proofFile } = {}, preview = null) {
 // REQ-WEB-1: same signed-in send boundary, a distinct strict settings payload.
 async function settingsSend(req, res, { settingsWrite, preview, log }) {
   const refuse = (status, error, message) => json(res, status, { error, message, sent: false });
-  if (!signedIn(req, preview)) {
+  if (one(req, preview.header) !== preview.user) {
     return refuse(401, 'sign-in required', 'sign in again');
   }
-  if (one(req, 'origin') !== ownOrigin(preview)) {
+  if (one(req, 'origin') !== `https://${preview.host}`) {
     return refuse(403, 'cross-origin request refused', 'settings need the Console origin');
   }
   if (one(req, 'sec-fetch-site') !== 'same-origin') {
@@ -298,8 +292,8 @@ async function seatSend(req, res, { route, write, preview, log }) {
   // The instance is quoted and cut short so a crafted value can't forge a log line.
   const line = outcome => log(`${new Date().toISOString()} ${route.kind} user=${JSON.stringify(preview.user)} instance=${quoted(instance)} ${outcome}`);
   const refuse = (status, error, message, sent = false) => { line(`error=${error}`); return json(res, status, { error, message, sent }); };
-  if (!preview.tester && !signedIn(req, preview)) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
-  if (one(req, 'origin') !== ownOrigin(preview)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
+  if (!preview.tester && one(req, preview.header) !== preview.user) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
+  if (one(req, 'origin') !== (preview.origin ?? `https://${preview.host}`)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
   if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site request refused', 'this needs same-origin Fetch Metadata');
   let value;
   try { value = JSON.parse((await body(req)).toString('utf8')); } catch (err) { return refuse(400, 'invalid-request', err.message); }
@@ -341,8 +335,8 @@ async function instanceSend(req, res, { instancesWrite, preview, log }) {
   // The instance is quoted and cut short so a crafted value can't forge a log line. Vars are never logged.
   const line = outcome => log(`${new Date().toISOString()} instance user=${JSON.stringify(preview.user)} instance=${quoted(instance)} ${outcome}`);
   const refuse = (status, error, message, sent = false) => { line(`error=${error}`); return json(res, status, { error, message, sent }); };
-  if (!preview.tester && !signedIn(req, preview)) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
-  if (one(req, 'origin') !== ownOrigin(preview)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
+  if (!preview.tester && one(req, preview.header) !== preview.user) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
+  if (one(req, 'origin') !== (preview.origin ?? `https://${preview.host}`)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
   if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site request refused', 'this needs same-origin Fetch Metadata');
   let value;
   try { value = JSON.parse((await body(req, 16384)).toString('utf8')); } catch (err) { return refuse(400, 'invalid-request', err.message); }
@@ -388,8 +382,8 @@ async function routesSend(req, res, { routesWrite, preview, log }) {
   let names = [];
   const line = outcome => log(`${new Date().toISOString()} routes user=${JSON.stringify(preview.user)} instances=${quoted(names.join(','))} ${outcome}`);
   const refuse = (status, error, message, sent = false) => { line(`error=${error}`); return json(res, status, { error, message, sent }); };
-  if (!preview.tester && !signedIn(req, preview)) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
-  if (one(req, 'origin') !== ownOrigin(preview)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
+  if (!preview.tester && one(req, preview.header) !== preview.user) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
+  if (one(req, 'origin') !== (preview.origin ?? `https://${preview.host}`)) return refuse(403, 'cross-origin request refused', 'this needs the Console\'s own Origin');
   if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site request refused', 'this needs same-origin Fetch Metadata');
   let value;
   try { value = JSON.parse((await body(req, 16384)).toString('utf8')); } catch (err) { return refuse(400, 'invalid-request', err.message); }
@@ -426,8 +420,8 @@ async function projectFileSend(req, res, { projectSave, preview, log }) {
   const line = outcome => log(`${new Date().toISOString()} project-file user=${JSON.stringify(preview.user)} project=${quoted(target?.project)} path=${quoted(target?.path)} ${outcome}`);
   // `sent` tells the page which it was: false, nothing was written; 'unknown', it may have been.
   const refuse = (status, error, message, sent = false) => { line(`error=${error}`); return json(res, status, { error, message, sent }); };
-  if (!signedIn(req, preview)) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
-  if (one(req, 'origin') !== ownOrigin(preview)) return refuse(403, 'cross-origin request refused', 'a save needs the Console\'s own Origin');
+  if (one(req, preview.header) !== preview.user) return json(res, 401, { error: 'sign-in required', message: 'sign in again', sent: false });
+  if (one(req, 'origin') !== `https://${preview.host}`) return refuse(403, 'cross-origin request refused', 'a save needs the Console\'s own Origin');
   if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse(403, 'cross-site request refused', 'a save needs same-origin Fetch Metadata');
   let value;
   try { value = JSON.parse((await body(req, FILE_SAVE_MAX)).toString('utf8')); } catch (err) { return refuse(400, 'invalid-request', err.message); }
@@ -466,17 +460,13 @@ async function projectFileRead(res, read, path, search) {
     return json(res, busStatus(code), { error: code, message: err instanceof BusReadError ? err.message : code });
   }
 }
-// `send` is the bus write (row 76): `args => Promise<{id}>`, only with the preview mode or `sso`.
-// `sso` is createSso() from sso.mjs (Q175 phase 1): the human listener signs people in itself.
-// `testerNoSignIn` makes the tester listener refuse anything that looks like a sign-in (--sso). `log`
+// `send` is the bus write (row 76): `args => Promise<{id}>`, only with the preview mode. `log`
 // takes one line per send attempt that got past sign-in; never the body. `fieldsFile` is for
 // tests; the field table is otherwise the committed packages/tasks/fields.json.
-export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerNoSignIn = false, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, log = line => console.log(line), fieldsFile = undefined } = {}) {
+export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, tester = false, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, log = line => console.log(line), fieldsFile = undefined } = {}) {
   if (!isLoopback(host)) throw new Error('refusing to bind to non-loopback host');
   if (host === 'localhost') host = '127.0.0.1';
   if (tester && preview !== null) throw new Error('tester listener cannot use preview mode');
-  if (tester && sso !== null) throw new Error('tester listener cannot use sso');
-  if (sso !== null && (preview !== null || proof !== null)) throw new Error('--sso cannot be combined with --auth-header, --allow-user or --proof-*');
   if (tester && host !== '127.0.0.1') throw new Error('tester listener must bind 127.0.0.1');
   // Row 177 (#1675): chat is allowed. The tester listener's chat binds the tester, so the bus keeps it on tester threads.
   if (tester && [send, settingsWrite, projectSave, assistantStop].some(value => value !== null)) throw new Error('tester listener permits only instance, route, name and chat writes');
@@ -486,26 +476,21 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
     throw new Error('preview mode needs --public-host, --auth-header and --allow-user together');
   }
   if (proof !== null && (preview === null || tester)) throw new Error('proxy proof needs preview mode');
-  if (send !== null && ((preview === null && sso === null) || typeof send !== 'function')) throw new Error('--send needs the preview mode (--public-host, --auth-header and --allow-user) or --sso');
+  if (send !== null && (preview === null || typeof send !== 'function')) throw new Error('--send needs the preview mode (--public-host, --auth-header and --allow-user)');
   const server = createServer(async (req, res) => {
     res.setHeader('x-content-type-options', 'nosniff');
     res.setHeader('referrer-policy', 'no-referrer');
-    // Under --sso the Sign out form's POST is redirected to the provider's end-session endpoint, and
-    // browsers apply form-action to that redirect, so those origins (from discovery) are allowed too.
-    res.setHeader('content-security-policy', `default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; font-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'${sso ? sso.formTargets().map(o => ` ${o}`).join('') : ''}`);
+    res.setHeader('content-security-policy', "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; font-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'");
     // Presence, even with an empty value: never turn the public listener into a tester ingress.
     if (!tester && Object.hasOwn(req.headers, 'x-mosaic-tester')) return json(res, 403, { error: 'tester listener required' });
     if (tester && testerAuthHeader && Object.hasOwn(req.headers, testerAuthHeader.toLowerCase())) return json(res, 403, { error: 'proxy header refused' });
     if (tester && testerProofHeader && Object.hasOwn(req.headers, testerProofHeader.toLowerCase())) return json(res, 403, { error: 'proxy proof header refused' });
-    // Under --sso the tester listener reads no cookie and takes no sign-in of any kind (design section 6).
-    if (tester && testerNoSignIn && (Object.hasOwn(req.headers, 'authorization') || SIGN_IN_COOKIE.test(req.headers.cookie ?? '') || Object.keys(req.headers).some(h => h.startsWith('x-authentik-'))))
-      return json(res, 403, { error: 'tester listener takes no sign-in' });
     let path, search;
     // Node keeps the first of repeated Host headers; a second one (a loopback Host, then NAME) is
     // never legitimate, so it is refused before any check reads the Host.
     if ((req.headersDistinct.host?.length ?? 0) > 1) return json(res, 400, { error: 'repeated Host refused' });
     // Preview mode: a request for the public name, exactly, as the proxy forwards it.
-    const named = preview !== null ? (req.headers.host ?? '').toLowerCase() === preview.host : sso !== null && (req.headers.host ?? '').toLowerCase() === sso.publicHost;
+    const named = preview !== null && (req.headers.host ?? '').toLowerCase() === preview.host;
     // The proof precedes every auth-header read, including the wrong-Host fence.
     if (proof !== null) {
       const values = req.headersDistinct[proof.header];
@@ -527,34 +512,19 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
       }
       ({ pathname: path, search } = new URL(req.url, 'http://localhost'));
     } catch { return json(res, 400, { error: 'invalid URL' }); }
-    // Under --sso the human listener serves only the public Host, whatever its port; GET /healthz
-    // alone stays open on a loopback Host for the status and release gates (Q-C).
-    if (sso !== null && !named && !(path === '/healthz' && req.method === 'GET')) return json(res, 403, { error: 'public Host required' });
     // No CORS. JSON content type and same-origin checks keep browser forms out.
-    if (req.headers.origin && req.headers.origin !== (named ? (sso ? sso.publicOrigin : `https://${preview.host}`) : `http://${req.headers.host}`)) return json(res, 403, { error: 'cross-origin request refused' });
-    let signer = preview;
-    if (sso !== null && named) {
-      if (path.startsWith('/auth/')) return sso.handle(req, res, path, search);
-      // Only a page load or a write keeps a session alive; the page's background reads don't (Q-D).
-      const session = path === '/healthz' ? null : sso.session(req, { touch: req.method === 'POST' || (req.method === 'GET' && !path.startsWith('/api/')) });
-      if (!session && path !== '/healthz') {
-        if (path.startsWith('/api/') || req.method !== 'GET') return json(res, 401, { error: 'sign-in required' });
-        res.writeHead(303, { location: `/auth/login?return=${encodeURIComponent(path + search)}`, 'cache-control': 'no-store' });
-        return res.end();
-      }
-      if (session) signer = { sso: true, user: session.name, host: sso.publicHost, origin: sso.publicOrigin };
-    }
-    if (named && preview !== null) {
+    if (req.headers.origin && req.headers.origin !== (named ? `https://${preview.host}` : `http://${req.headers.host}`)) return json(res, 403, { error: 'cross-origin request refused' });
+    if (named) {
       // One value, equal to the user id; the proxy strips client copies and sets it after sign-in.
       const values = req.headersDistinct[preview.header];
       if (!values || values.length !== 1 || values[0] !== preview.user) return json(res, 401, { error: 'sign-in required' });
     }
-    const writer = tester ? { tester: true, user: 'tester', origin: `http://127.0.0.1:${server.address().port}` } : signer;
+    const writer = tester ? { tester: true, user: 'tester', origin: `http://127.0.0.1:${server.address().port}` } : preview;
     if (tester && !['GET', 'HEAD'].includes(req.method) && !['/api/instances', '/api/routes', '/api/name'].includes(path) && !TESTER_CHAT_WRITE.test(path))
       return json(res, 403, { error: 'read-only', sent: false });
     if(path==='/api/settings'&&req.method==='POST'){
       if(!send||!settingsWrite||!named)return json(res,403,{error:'read-only',sent:false});
-      return settingsSend(req,res,{settingsWrite,preview:signer,log});
+      return settingsSend(req,res,{settingsWrite,preview,log});
     }
     if (Object.hasOwn(SEAT_ROUTES, path)) {
       if (req.method !== 'POST') return json(res, 405, { error: 'method not allowed' });
@@ -574,18 +544,18 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
     }
     if (path === '/api/project-file' && req.method === 'POST') {
       if (!send || !projectSave || !named) return json(res, 403, { error: 'read-only', sent: false });
-      return projectFileSend(req, res, { projectSave, preview: signer, log });
+      return projectFileSend(req, res, { projectSave, preview, log });
     }
     // Message sending has its own bounded payload and repeats the identity check.
     if (send && path === '/api/bus/message') {
       if (req.method !== 'POST') return json(res, 405, { error: 'method not allowed' });
-      return busSend(req, res, { send, preview: signer, log });
+      return busSend(req, res, { send, preview, log });
     }
     if (path === '/api/chat' || path.startsWith('/api/chat/')) {
       return chatHTTP(req, res, { path, search, chat, named, send, preview: writer, log });
     }
     // Nothing else but GET and HEAD gets past here in preview mode, whatever the Host.
-    if ((preview !== null || sso !== null) && req.method !== 'GET' && req.method !== 'HEAD') return json(res, 403, { error: 'read-only', message: 'the Console preview is read-only' });
+    if (preview !== null && req.method !== 'GET' && req.method !== 'HEAD') return json(res, 403, { error: 'read-only', message: 'the Console preview is read-only' });
     // The conversation routes (#1507, CHAT-02) keep their query; the board validates it.
     const conversation = path === '/api/conversations' || path === '/api/conversation';
     const allowed = path === '/api/board' || conversation ? 'GET' : ['/api/seen', '/api/reply'].includes(path) ? 'POST' : null;
@@ -637,8 +607,8 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
     if (req.method !== 'GET' && req.method !== 'HEAD') return json(res, 405, { error: 'method not allowed' });
     // `send`: the page shows the composer only where a send can pass (the public name, --send on).
     // `edit`: the editor shows Save only where a save can pass, the same test as the route's.
-    if (path === '/api/config') return json(res, 200, { board: upstream, ...(tester ? { tester: true } : {}), ...(sso ? { sso: true } : {}), send: !tester && Boolean(send) && named, edit: !tester && Boolean(send) && Boolean(projectSave) && named });
-    if (path === '/healthz') return json(res, 200, { ok: true, ...(sso ? { sso: sso.health() } : {}) });
+    if (path === '/api/config') return json(res, 200, { board: upstream, ...(tester ? { tester: true } : {}), send: !tester && Boolean(send) && named, edit: !tester && Boolean(send) && Boolean(projectSave) && named });
+    if (path === '/healthz') return json(res, 200, { ok: true });
     if (path === '/favicon.ico') { res.writeHead(204); return res.end(); }
     const file = files.get(path);
     if (!file) return json(res, 404, { error: 'not found' });

packages/webui/src/sso-config.mjs

@@ -1,75 +0,0 @@
-// Q175 phase 1 (#1690): the shape of config.json's optional `console` key. The one loader,
-// scripts/mosaic-config.mjs, runs this on every read, so a bad key refuses the config for every
-// tool (design section 4, C1). The Console's --sso start runs it again before it uses the value.
-// Shape only: nothing here touches the network or a slot file. A refusal names the key path and
-// never quotes a value, so a refusal can't print a client id or a subject.
-
-// The asymmetric algorithms oauth4webapi 3.8.8 verifies (its supported(), build/index.js). No HS*
-// and no none, so a client secret can never be a signing key.
-export const ALGS = Object.freeze(['PS256', 'ES256', 'RS256', 'PS384', 'ES384', 'RS384', 'PS512', 'ES512', 'RS512', 'Ed25519', 'EdDSA', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']);
-const PROVIDER_ID = /^[a-z0-9-]{1,32}$/;
-const SLOT = /^[a-z0-9-]{1,64}$/;
-const SUB = /^[\x21-\x7e]{1,255}$/;
-const CLIENT_ID = /^[\x21-\x7e]{1,255}$/;
-// The name goes where the preview's --allow-user went (serve.mjs USER): visible ASCII, no comma.
-const NAME = /^[\x21-\x2b\x2d-\x7e]{1,64}$/;
-// The bus keeps these for the tester and the human role (section 6), so no subject can sign in as one.
-const RESERVED_NAMES = ['tester', 'human'];
-
-const object = v => typeof v === 'object' && v !== null && !Array.isArray(v);
-function refuse(where, why) {
-  throw new Error(`${where} ${why}`);
-}
-function keys(value, where, allowed, required = allowed) {
-  if (!object(value)) refuse(where, 'must be a JSON object');
-  for (const key of Object.keys(value)) if (!allowed.includes(key)) refuse(`${where}.${key}`, 'is not a supported key');
-  for (const key of required) if (!Object.hasOwn(value, key)) refuse(`${where}.${key}`, 'is required');
-}
-function httpsURL(value, where) {
-  let url;
-  if (typeof value !== 'string' || value.length > 512) refuse(where, 'must be an https URL of at most 512 characters');
-  try { url = new URL(value); } catch { refuse(where, 'must be an https URL'); }
-  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash || value.includes('?') || value.includes('#')) {
-    refuse(where, 'must be https with no credentials, query or fragment');
-  }
-  return url;
-}
-
-// Returns the value unchanged when it passes; throws an Error naming the bad key path otherwise.
-export function checkConsole(value, where = 'console') {
-  keys(value, where, ['sso']);
-  const sso = value.sso, at = `${where}.sso`;
-  keys(sso, at, ['publicOrigin', 'providers']);
-  const origin = httpsURL(sso.publicOrigin, `${at}.publicOrigin`);
-  if (origin.origin !== sso.publicOrigin) refuse(`${at}.publicOrigin`, 'must be an https origin with no path, query, fragment or trailing slash');
-  if (!Array.isArray(sso.providers) || sso.providers.length === 0 || sso.providers.length > 8) refuse(`${at}.providers`, 'must be a list of 1 to 8 providers');
-  const ids = new Set();
-  sso.providers.forEach((p, i) => {
-    const pat = `${at}.providers[${i}]`;
-    keys(p, pat, ['id', 'issuer', 'clientId', 'clientSecret', 'algs', 'subjects']);
-    if (typeof p.id !== 'string' || !PROVIDER_ID.test(p.id)) refuse(`${pat}.id`, 'must match [a-z0-9-]{1,32}');
-    if (ids.has(p.id)) refuse(`${pat}.id`, 'repeats an earlier provider id');
-    ids.add(p.id);
-    httpsURL(p.issuer, `${pat}.issuer`);
-    if (typeof p.clientId !== 'string' || !CLIENT_ID.test(p.clientId)) refuse(`${pat}.clientId`, 'must be 1 to 255 visible characters');
-    keys(p.clientSecret, `${pat}.clientSecret`, ['slot']);
-    if (typeof p.clientSecret.slot !== 'string' || !SLOT.test(p.clientSecret.slot)) refuse(`${pat}.clientSecret.slot`, 'must match [a-z0-9-]{1,64}');
-    if (!Array.isArray(p.algs) || p.algs.length === 0) refuse(`${pat}.algs`, 'must be a non-empty list');
-    p.algs.forEach((alg, j) => {
-      if (!ALGS.includes(alg)) refuse(`${pat}.algs[${j}]`, `must be one of ${ALGS.join(', ')}; HS* and none are refused`);
-    });
-    if (new Set(p.algs).size !== p.algs.length) refuse(`${pat}.algs`, 'repeats an algorithm');
-    if (!Array.isArray(p.subjects) || p.subjects.length === 0 || p.subjects.length > 64) refuse(`${pat}.subjects`, 'must be a list of 1 to 64 subjects');
-    const subs = new Set();
-    p.subjects.forEach((s, j) => {
-      const sat = `${pat}.subjects[${j}]`;
-      keys(s, sat, ['sub', 'name']);
-      if (typeof s.sub !== 'string' || !SUB.test(s.sub)) refuse(`${sat}.sub`, 'must be 1 to 255 visible characters');
-      if (subs.has(s.sub)) refuse(`${sat}.sub`, 'repeats an earlier subject');
-      subs.add(s.sub);
-      if (typeof s.name !== 'string' || !NAME.test(s.name)) refuse(`${sat}.name`, 'must be 1 to 64 visible characters');
-      if (RESERVED_NAMES.includes(s.name.toLowerCase())) refuse(`${sat}.name`, `must not be ${RESERVED_NAMES.join(' or ')}`);
-    });
-  });
-  return value;
-}

packages/webui/src/sso.mjs

@@ -1,347 +0,0 @@
-// Q175 phase 1 (#1690, design agents/sage/work/q175-sso/DESIGN.md): the Console as an OIDC relying
-// party. Used only by the human listener under --sso; startServer refuses it on the tester listener.
-// Every URL handed to a provider is built from the configured publicOrigin, never from a request's
-// Host. A refusal logs one fixed code and the provider id, never an exception, its message or its
-// cause: oauth4webapi's errors carry token bodies and claims there.
-import { createHash, randomBytes } from 'node:crypto';
-import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, relative, isAbsolute, resolve } from 'node:path';
-import { checkConsole } from './sso-config.mjs';
-
-// oauth4webapi loads in createSso, not here: cli.mjs imports this module on every start, and a
-// Console without --sso must not need the package (pinned-copy.test.mjs builds copies whose lock
-// installs nothing). A real copy installs it from the root lock.
-let oauth;
-
-export const SESSION_COOKIE = '__Host-mosaic_session';
-export const LOGIN_COOKIE = '__Host-mosaic_login';
-const ATTRS = 'Path=/; Secure; HttpOnly; SameSite=Lax';
-const LOGIN_MAX_AGE = 600;
-const SESSION_ABSOLUTE = 8 * 3600 * 1000, SESSION_IDLE = 3600 * 1000;
-const MAX_SESSIONS = 64, MAX_LOGINS = 32;
-const FETCH_TIMEOUT = 10000;
-const RETRY_CAP = 300000;
-const CODES = new Set(['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']);
-
-const sha256 = value => createHash('sha256').update(value).digest('hex');
-const escape = text => String(text).replace(/[&<>"']/g, c => `&#${c.charCodeAt(0)};`);
-const under = (parent, child) => { const rel = relative(parent, child); return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel)); };
-
-// The slot file holding a provider's client secret (design section 4, D1). Only the Console's --sso
-// start calls this. A refusal names the provider and the check, never the path's contents.
-export function readSlot(configDir, provider, { repo, checkout = null, copies = join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'mosaic-stack', 'copies') } = {}) {
-  const where = `console.sso provider ${provider.id} client secret slot`;
-  const file = join(resolve(configDir), 'secrets', 'mosaic-stack', provider.clientSecret.slot);
-  let st;
-  try { st = lstatSync(file); } catch { throw new Error(`${where} is missing`); }
-  if (st.isSymbolicLink()) throw new Error(`${where} must not be a symbolic link`);
-  let fd, real, text;
-  try {
-    fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    st = fstatSync(fd);
-    if (!st.isFile()) throw new Error(`${where} must be a regular file`);
-    if (st.uid !== process.getuid()) throw new Error(`${where} must be owned by the Console's user`);
-    if (st.mode & 0o077) throw new Error(`${where} must have no group or other permission bits`);
-    real = realpathSync(file);
-    for (const root of [repo, checkout, copies].filter(Boolean)) {
-      let base;
-      try { base = realpathSync(root); } catch { base = resolve(root); }
-      if (under(base, real)) throw new Error(`${where} must not be inside the repository or a stack copy`);
-    }
-    text = readFileSync(fd, 'utf8');
-  } catch (err) {
-    throw err.message?.startsWith(where) ? err : new Error(`${where} is not readable`);
-  } finally {
-    if (fd !== undefined) closeSync(fd);
-  }
-  const secret = text.endsWith('\n') ? text.slice(0, -1) : text;
-  if (!secret || /[\r\n]/.test(secret)) throw new Error(`${where} must hold one non-empty line`);
-  return secret;
-}
-
-export function cookies(req, name) {
-  const found = [];
-  for (const part of (req.headers.cookie ?? '').split(';')) {
-    const at = part.indexOf('=');
-    if (at > 0 && part.slice(0, at).trim() === name) found.push(part.slice(at + 1).trim());
-  }
-  return found;
-}
-
-// The JWKS check at discovery, the same filter the library's key selection uses (kty, alg, use,
-// key_ops, crv; RSA at least 2048 bits), without a kid since no token is at hand yet.
-function usableKey(jwk, alg) {
-  const kty = { RS: 'RSA', PS: 'RSA', ES: 'EC', Ed: 'OKP', ML: 'AKP' }[alg.slice(0, 2)];
-  if (jwk === null || typeof jwk !== 'object' || jwk.kty !== kty) return false;
-  if (jwk.alg !== undefined && jwk.alg !== alg) return false;
-  if (jwk.use !== undefined && jwk.use !== 'sig') return false;
-  if (Array.isArray(jwk.key_ops) && !jwk.key_ops.includes('verify')) return false;
-  const crv = { ES256: 'P-256', ES384: 'P-384', ES512: 'P-521', Ed25519: 'Ed25519', EdDSA: 'Ed25519' }[alg];
-  if (crv && jwk.crv !== crv) return false;
-  if (kty === 'RSA' && (typeof jwk.n !== 'string' || Buffer.from(jwk.n, 'base64url').length * 8 < 2048)) return false;
-  return true;
-}
-
-class Unreachable extends Error {}
-class Refused extends Error {}
-const https = value => { try { return new URL(value).protocol === 'https:'; } catch { return false; } };
-
-// One provider's discovery and JWKS. Throws Unreachable (network, timeout, a status other than 200,
-// a body that isn't JSON) or Refused (a JSON document that fails a check). Q-B, design section 4.
-async function discover(p, fetchOptions) {
-  let response, text;
-  const options = () => ({ ...fetchOptions, signal: AbortSignal.timeout(FETCH_TIMEOUT) });
-  try {
-    response = await oauth.discoveryRequest(new URL(p.issuer), options());
-    if (response.status !== 200 || !/^application\/json\b/i.test(response.headers.get('content-type') ?? '')) throw new Error();
-    text = await response.text();
-    JSON.parse(text);
-  } catch { throw new Unreachable(); }
-  let as;
-  try {
-    as = await oauth.processDiscoveryResponse(new URL(p.issuer), new Response(text, { status: 200, headers: { 'content-type': 'application/json' } }));
-  } catch { throw new Refused(); }
-  if (as.issuer !== p.issuer) throw new Refused();
-  if (!Array.isArray(as.id_token_signing_alg_values_supported) || !p.algs.some(a => as.id_token_signing_alg_values_supported.includes(a))) throw new Refused();
-  if (!Array.isArray(as.code_challenge_methods_supported) || !as.code_challenge_methods_supported.includes('S256')) throw new Refused();
-  if (![as.authorization_endpoint, as.token_endpoint, as.jwks_uri].every(https)) throw new Refused();
-  if (as.end_session_endpoint !== undefined && !https(as.end_session_endpoint)) throw new Refused();
-  let jwks;
-  try {
-    const fetcher = fetchOptions[oauth.customFetch] ?? fetch;
-    const res = await fetcher(as.jwks_uri, { method: 'GET', headers: { accept: 'application/json, application/jwk-set+json' }, redirect: 'manual', signal: AbortSignal.timeout(FETCH_TIMEOUT) });
-    if (res.status !== 200) throw new Error();
-    jwks = JSON.parse(await res.text());
-  } catch { throw new Unreachable(); }
-  if (jwks === null || typeof jwks !== 'object' || !Array.isArray(jwks.keys)) throw new Refused();
-  const usable = p.algs.filter(alg => jwks.keys.some(k => usableKey(k, alg)));
-  if (!usable.length) throw new Refused();
-  return as;
-}
-
-// `config` is console.sso, checked again here; `secrets` maps provider id to its client secret
-// (readSlot). `fetch` is for tests: a fetch that trusts only the fake OP's certificate.
-// `retryFirst` is for tests too; production waits 5 s, doubling, capped at 5 minutes.
-export async function createSso(config, { secrets, fetch: customFetch = null, log = line => console.log(line), retryFirst = 5000 } = {}) {
-  checkConsole({ sso: config });
-  oauth ??= await import('oauth4webapi');
-  const publicOrigin = config.publicOrigin;
-  const publicHost = new URL(publicOrigin).host;
-  const redirectUri = `${publicOrigin}/auth/callback`;
-  const fetchOptions = customFetch ? { [oauth.customFetch]: customFetch } : {};
-  const sessions = new Map(), logins = new Map();
-  const timers = new Set();
-  let closed = false;
-  const refuse = (code, provider, extra = '') => {
-    if (!CODES.has(code)) throw new Error(`unknown sso log code ${code}`);
-    log(`${new Date().toISOString()} sso refused code=${code} provider=${provider}${extra}`);
-  };
-
-  const providers = new Map(config.providers.map(p => {
-    if (typeof secrets?.get(p.id) !== 'string') throw new Error(`console.sso provider ${p.id} has no client secret`);
-    return [p.id, {
-      config: p, state: 'unreachable', as: null, jwks: {},
-      client: { client_id: p.clientId, id_token_signed_response_alg: [...p.algs] },
-      auth: oauth.ClientSecretBasic(secrets.get(p.id)),
-      subjects: new Map(p.subjects.map(s => [s.sub, s.name])),
-    }];
-  }));
-
-  async function attempt(entry, atStart) {
-    try {
-      entry.as = await discover(entry.config, fetchOptions);
-      entry.jwks = {};
-      entry.state = 'ready';
-    } catch (err) {
-      if (err instanceof Refused) {
-        entry.state = 'refused';
-        refuse('discovery-failed', entry.config.id);
-        if (atStart) throw new Error(`console.sso provider ${entry.config.id} refused at discovery: the issuer, algorithms, S256 or JWKS check failed`);
-        return;
-      }
-      entry.state = 'unreachable';
-      refuse('discovery-failed', entry.config.id);
-      throw err;
-    }
-  }
-  function retry(entry, delay) {
-    if (closed) return;
-    const timer = setTimeout(async () => {
-      timers.delete(timer);
-      try { await attempt(entry, false); } catch { retry(entry, Math.min(delay * 2, RETRY_CAP)); }
-    }, delay);
-    timer.unref();
-    timers.add(timer);
-  }
-  for (const entry of providers.values()) {
-    try { await attempt(entry, true); } catch (err) {
-      if (!(err instanceof Unreachable)) throw err;
-      retry(entry, retryFirst);
-    }
-  }
-
-  const page = (res, status, title, html, headers = {}) => {
-    res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', ...headers });
-    res.end(`<!doctype html><meta charset="utf-8"><title>${escape(title)}</title><main style="font-family:sans-serif;max-width:32rem;margin:4rem auto"><h1>${escape(title)}</h1>${html}</main>\n`);
-  };
-  const redirect = (res, location, setCookie = []) => {
-    res.writeHead(303, { location, 'cache-control': 'no-store', ...(setCookie.length ? { 'set-cookie': setCookie } : {}) });
-    res.end();
-  };
-  const failed = (res, setCookie = []) => page(res, 403, 'Sign-in failed', '<p><a href="/auth/login">Sign in again</a></p>', setCookie.length ? { 'set-cookie': setCookie } : {});
-  const expire = name => `${name}=; ${ATTRS}; Max-Age=0`;
-  const remember = (map, key, value, cap) => {
-    while (map.size >= cap) map.delete(map.keys().next().value);
-    map.set(key, value);
-  };
-
-  // B2: only a URL on publicOrigin itself; anything else, or nothing, is publicOrigin's `/`. The
-  // Location is absolute and its origin checked again: dot segments can leave a pathname of `//host`,
-  // which as a relative Location a browser reads as another origin (webby-0019 B1, sage-1403).
-  function returnURL(ret) {
-    const home = `${publicOrigin}/`;
-    try {
-      if (typeof ret !== 'string' || !ret) return home;
-      const u = new URL(ret, publicOrigin);
-      if (u.origin !== publicOrigin) return home;
-      const out = new URL(`${publicOrigin}${u.pathname}${u.search}`);
-      return out.origin === publicOrigin ? out.href : home;
-    } catch { return home; }
-  }
-
-  async function start(res, entry, ret) {
-    const state = oauth.generateRandomState(), nonce = oauth.generateRandomNonce(), verifier = oauth.generateRandomCodeVerifier();
-    const challenge = await oauth.calculatePKCECodeChallenge(verifier);
-    const id = randomBytes(32).toString('base64url');
-    remember(logins, sha256(id), { provider: entry.config.id, state, nonce, verifier, ret: typeof ret === 'string' ? ret.slice(0, 2048) : '/', expires: Date.now() + LOGIN_MAX_AGE * 1000 }, MAX_LOGINS);
-    const url = new URL(entry.as.authorization_endpoint);
-    for (const [k, v] of Object.entries({ client_id: entry.config.clientId, response_type: 'code', scope: 'openid profile email', redirect_uri: redirectUri, state, nonce, code_challenge: challenge, code_challenge_method: 'S256' })) url.searchParams.set(k, v);
-    return redirect(res, url.href, [`${LOGIN_COOKIE}=${id}; ${ATTRS}; Max-Age=${LOGIN_MAX_AGE}`]);
-  }
-
-  function login(res, query) {
-    const asked = query.get('provider');
-    const ret = query.get('return');
-    if (asked === null && providers.size > 1) {
-      const items = [...providers.values()].map(e => `<li><a href="/auth/login?${escape(new URLSearchParams({ provider: e.config.id, ...(ret ? { return: ret } : {}) }))}">${escape(e.config.id)}</a></li>`).join('');
-      return page(res, 200, 'Sign in', `<ul>${items}</ul>`);
-    }
-    const entry = asked === null ? [...providers.values()][0] : providers.get(asked);
-    if (!entry) return page(res, 404, 'Unknown sign-in provider', '<p><a href="/auth/login">Sign in</a></p>');
-    if (entry.state !== 'ready') return page(res, 503, 'sign-in unavailable', '<p>The sign-in provider can\'t be reached. Try again shortly.</p>');
-    return start(res, entry, ret);
-  }
-
-  // Design section 1, steps 2-7. Each refusal ends here with one log line and the 403 page.
-  async function callback(res, query, req) {
-    const clear = [expire(LOGIN_COOKIE)];
-    const ids = cookies(req, LOGIN_COOKIE);
-    const key = ids.length === 1 ? sha256(ids[0]) : null;
-    const record = key === null ? undefined : logins.get(key);
-    if (key !== null) logins.delete(key);
-    // The provider comes from the record, never from the query.
-    const entry = record && providers.get(record.provider);
-    if (!record || record.expires <= Date.now() || !entry) {
-      refuse('login-record-missing', record?.provider ?? 'none');
-      return failed(res, clear);
-    }
-    const pid = entry.config.id;
-    if (entry.state !== 'ready') { refuse('discovery-failed', pid); return failed(res, clear); }
-    let params;
-    try { params = oauth.validateAuthResponse(entry.as, entry.client, query, record.state); } catch (err) {
-      refuse(err instanceof oauth.AuthorizationResponseError ? 'auth-error-response' : 'state-mismatch', pid);
-      return failed(res, clear);
-    }
-    const options = () => ({ ...fetchOptions, [oauth.jwksCache]: entry.jwks, signal: AbortSignal.timeout(FETCH_TIMEOUT) });
-    let response;
-    try { response = await oauth.authorizationCodeGrantRequest(entry.as, entry.client, entry.auth, params, redirectUri, record.verifier, options()); } catch {
-      refuse('grant-failed', pid); return failed(res, clear);
-    }
-    let result, claims;
-    try {
-      result = await oauth.processAuthorizationCodeResponse(entry.as, entry.client, response, { expectedNonce: record.nonce, requireIdToken: true });
-      claims = oauth.getValidatedIdTokenClaims(result);
-    } catch (err) {
-      refuse(err instanceof oauth.ResponseBodyError ? 'grant-failed' : 'id-token-invalid', pid);
-      return failed(res, clear);
-    }
-    // Step 5: the library skips this for a token-endpoint ID token; point 2 needs it, on the same
-    // Response object. Its throw ends the callback.
-    try { await oauth.validateApplicationLevelSignature(entry.as, response, options()); } catch (err) {
-      const fetching = !(err instanceof oauth.OperationProcessingError || err instanceof oauth.UnsupportedOperationError) || [oauth.RESPONSE_IS_NOT_CONFORM, oauth.RESPONSE_IS_NOT_JSON].includes(err.code);
-      refuse(fetching ? 'jwks-failed' : 'signature-invalid', pid);
-      return failed(res, clear);
-    }
-    // Step 6: our own checks on top of the library's.
-    let header;
-    try { header = JSON.parse(Buffer.from(result.id_token.split('.')[0], 'base64url').toString('utf8')); } catch { header = null; }
-    if (!header || !entry.config.algs.includes(header.alg)) { refuse('alg-refused', pid); return failed(res, clear); }
-    if (claims.iss !== entry.config.issuer) { refuse('issuer-mismatch', pid); return failed(res, clear); }
-    const name = typeof claims.sub === 'string' ? entry.subjects.get(claims.sub) : undefined;
-    if (name === undefined) {
-      refuse('subject-unknown', pid, ` iss=${JSON.stringify(String(claims.iss).slice(0, 255))} sub=${JSON.stringify(String(claims.sub).slice(0, 255))}`);
-      return failed(res, clear);
-    }
-    // Step 7: the session, then the return path.
-    const id = randomBytes(32).toString('base64url'), now = Date.now();
-    remember(sessions, sha256(id), { provider: pid, iss: claims.iss, sub: claims.sub, name, idToken: result.id_token, created: now, seen: now }, MAX_SESSIONS);
-    return redirect(res, returnURL(record.ret), [...clear, `${SESSION_COOKIE}=${id}; ${ATTRS}`]);
-  }
-
-  // The session for this request, or null. `touch` is true only for a page load or a write (Q-D).
-  function session(req, { touch = false } = {}) {
-    const ids = cookies(req, SESSION_COOKIE);
-    if (ids.length !== 1) return null;
-    const key = sha256(ids[0]);
-    const s = sessions.get(key);
-    if (!s) return null;
-    const now = Date.now();
-    if (now - s.created >= SESSION_ABSOLUTE || now - s.seen >= SESSION_IDLE) { sessions.delete(key); return null; }
-    if (touch) s.seen = now;
-    return s;
-  }
-
-  function logout(req, res) {
-    const one = name => (req.headersDistinct[name]?.length === 1 ? req.headersDistinct[name][0] : null);
-    if (one('origin') !== publicOrigin || one('sec-fetch-site') !== 'same-origin') {
-      return page(res, 403, 'Sign-out refused', '<p>Sign out from the Console page.</p>');
-    }
-    const ids = cookies(req, SESSION_COOKIE);
-    const key = ids.length === 1 ? sha256(ids[0]) : null;
-    const s = key === null ? undefined : sessions.get(key);
-    if (key !== null) sessions.delete(key);
-    const entry = s && providers.get(s.provider);
-    let location = `${publicOrigin}/auth/signed-out`;
-    if (entry?.as?.end_session_endpoint) {
-      const url = new URL(entry.as.end_session_endpoint);
-      url.searchParams.set('id_token_hint', s.idToken);
-      url.searchParams.set('post_logout_redirect_uri', `${publicOrigin}/auth/signed-out`);
-      url.searchParams.set('client_id', entry.config.clientId);
-      location = url.href;
-    }
-    return redirect(res, location, [expire(SESSION_COOKIE)]);
-  }
-
-  // `/auth/*` on the human listener; the caller has already checked the Host.
-  async function handle(req, res, path, search) {
-    const query = new URLSearchParams(search);
-    if (path === '/auth/logout') {
-      if (req.method !== 'POST') return page(res, 405, 'Method not allowed', '');
-      return logout(req, res);
-    }
-    if (req.method !== 'GET') return page(res, 405, 'Method not allowed', '');
-    if (path === '/auth/login') return login(res, query);
-    if (path === '/auth/callback') return callback(res, query, req);
-    if (path === '/auth/signed-out') return page(res, 200, 'Signed out', '<p><a href="/auth/login">Sign in</a></p>');
-    return page(res, 404, 'Not found', '');
-  }
-
-  return {
-    publicOrigin, publicHost, sessions, logins, handle, session, returnURL,
-    health: () => Object.fromEntries([...providers].map(([id, e]) => [id, e.state])),
-    formTargets: () => [...new Set([...providers.values()].filter(e => e.as?.end_session_endpoint).map(e => new URL(e.as.end_session_endpoint).origin))],
-    summary: () => config.providers.map(p => ({ id: p.id, issuer: p.issuer, subjects: p.subjects.length })),
-    close() { closed = true; for (const t of timers) clearTimeout(t); timers.clear(); },
-  };
-}

packages/webui/tests/helpers/fake-oidc.mjs

@@ -1,155 +0,0 @@
-// Q175 phase 1 (#1690, design section 9): a fake OpenID provider for the --sso tests. A loopback
-// https server with a self-signed certificate made in a temp dir; `op.fetch` is a fetch that trusts
-// only that certificate, so the code under test needs no insecure flag. It serves any number of
-// issuers (`/<name>/`) at once, each with discovery, a JWKS, authorization, token and end-session
-// endpoints. Keys come from node:crypto. Nothing here reaches any other host.
-import { constants, createHash, createHmac, generateKeyPairSync, randomBytes, sign } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { createServer, request } from 'node:https';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-export const b64url = value => Buffer.from(typeof value === 'string' ? value : JSON.stringify(value)).toString('base64url');
-
-export function rsaKey(kid = `rsa-${randomBytes(4).toString('hex')}`, bits = 2048) {
-  const { privateKey, publicKey } = generateKeyPairSync('rsa', { modulusLength: bits });
-  return { kid, alg: 'RS256', privateKey, jwk: { ...publicKey.export({ format: 'jwk' }), kid, use: 'sig', alg: 'RS256' } };
-}
-export function ecKey(kid = `ec-${randomBytes(4).toString('hex')}`) {
-  const { privateKey, publicKey } = generateKeyPairSync('ec', { namedCurve: 'P-256' });
-  return { kid, alg: 'ES256', privateKey, jwk: { ...publicKey.export({ format: 'jwk' }), kid, use: 'sig', alg: 'ES256' } };
-}
-export function psKey(kid = `ps-${randomBytes(4).toString('hex')}`) {
-  const k = rsaKey(kid);
-  return { ...k, alg: 'PS256', jwk: { ...k.jwk, alg: 'PS256' } };
-}
-
-// A compact JWS. `alg` HS256 uses `hmac` as the key, `none` has an empty signature.
-export function jwt(header, payload, { key = null, hmac = null } = {}) {
-  const input = `${b64url(header)}.${b64url(payload)}`;
-  let sig = '';
-  if (header.alg === 'HS256') sig = createHmac('sha256', hmac).update(input).digest('base64url');
-  else if (header.alg === 'RS256') sig = sign('sha256', Buffer.from(input), key).toString('base64url');
-  else if (header.alg === 'PS256') sig = sign('sha256', Buffer.from(input), { key, padding: constants.RSA_PKCS1_PSS_PADDING, saltLength: 32 }).toString('base64url');
-  else if (header.alg === 'ES256') sig = sign('sha256', Buffer.from(input), { key, dsaEncoding: 'ieee-p1363' }).toString('base64url');
-  return `${input}.${sig}`;
-}
-
-function certificate() {
-  const dir = mkdtempSync(join(tmpdir(), 'fake-oidc-'));
-  try {
-    const r = spawnSync('openssl', ['req', '-x509', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:P-256', '-nodes', '-days', '1',
-      '-subj', '/CN=127.0.0.1', '-addext', 'subjectAltName=IP:127.0.0.1', '-keyout', join(dir, 'key.pem'), '-out', join(dir, 'cert.pem')], { encoding: 'utf8' });
-    if (r.status !== 0) throw new Error(`openssl failed: ${r.stderr}`);
-    return { key: readFileSync(join(dir, 'key.pem')), cert: readFileSync(join(dir, 'cert.pem')) };
-  } finally { rmSync(dir, { recursive: true, force: true }); }
-}
-
-// One issuer's state. `discovery` is merged over the defaults; `mode` is 'ok', 'down' (the socket is
-// destroyed) or 'html' (200 with an HTML page) for discovery.
-function issuerState(name, base, opts) {
-  const keys = opts.keys ?? [rsaKey()];
-  return {
-    name, issuer: `${base}/${name}/`, keys, retired: [], clientId: opts.clientId ?? `client-${name}`, clientSecret: opts.clientSecret ?? `secret-${name}-${randomBytes(6).toString('hex')}`,
-    discovery: opts.discovery ?? {}, mode: 'ok', jwksOverride: null, codes: new Map(), acceptTwice: false, requirePkce: true,
-    tokenRequests: [], authorizeRequests: [], jwksFetches: 0, discoveryFetches: 0,
-  };
-}
-
-export async function fakeOidc() {
-  const { key, cert } = certificate();
-  const issuers = new Map();
-  const server = createServer({ key, cert }, (req, res) => {
-    const url = new URL(req.url, 'https://127.0.0.1');
-    const [, name, ...rest] = url.pathname.split('/');
-    const iss = issuers.get(name);
-    const route = rest.join('/');
-    const json = (status, body, type = 'application/json') => { res.writeHead(status, { 'content-type': type }); res.end(typeof body === 'string' ? body : JSON.stringify(body)); };
-    if (!iss) return json(404, { error: 'no issuer' });
-    if (route === '.well-known/openid-configuration') {
-      iss.discoveryFetches++;
-      if (iss.mode === 'down') return req.socket.destroy();
-      if (iss.mode === 'html') return json(200, '<!doctype html><title>Sign in</title>', 'text/html');
-      return json(200, discovery(iss));
-    }
-    if (route === 'jwks') {
-      iss.jwksFetches++;
-      return json(200, iss.jwksOverride ?? { keys: iss.keys.map(k => k.jwk) });
-    }
-    if (route === 'authorize') { iss.authorizeRequests.push(Object.fromEntries(url.searchParams)); return json(200, { ok: true }); }
-    if (route === 'end-session') return json(200, { ok: true });
-    if (route === 'token' && req.method === 'POST') {
-      let text = '';
-      req.on('data', c => (text += c));
-      req.on('end', () => {
-        const form = new URLSearchParams(text);
-        const basic = Buffer.from((req.headers.authorization ?? '').replace(/^Basic /, ''), 'base64').toString();
-        const [id, secret] = basic.split(':').map(decodeURIComponent);
-        iss.tokenRequests.push({ form: Object.fromEntries(form), clientId: id });
-        if (id !== iss.clientId || secret !== iss.clientSecret) return json(401, { error: 'invalid_client' });
-        const grant = iss.codes.get(form.get('code'));
-        if (!grant) return json(400, { error: 'invalid_grant' });
-        if (!iss.acceptTwice) iss.codes.delete(form.get('code'));
-        if (form.get('redirect_uri') !== grant.redirectUri) return json(400, { error: 'invalid_grant', error_description: 'redirect_uri' });
-        if (iss.requirePkce && createHash('sha256').update(form.get('code_verifier') ?? '').digest('base64url') !== grant.challenge) return json(400, { error: 'invalid_grant', error_description: 'pkce' });
-        return json(200, { access_token: randomBytes(16).toString('hex'), token_type: 'Bearer', expires_in: 300, id_token: grant.idToken });
-      });
-      return;
-    }
-    return json(404, { error: 'not found' });
-  });
-  await new Promise(r => server.listen(0, '127.0.0.1', r));
-  const base = `https://127.0.0.1:${server.address().port}`;
-
-  const discovery = iss => ({
-    issuer: iss.issuer, authorization_endpoint: `${iss.issuer}authorize`, token_endpoint: `${iss.issuer}token`, jwks_uri: `${iss.issuer}jwks`,
-    end_session_endpoint: `${iss.issuer}end-session`, response_types_supported: ['code'], subject_types_supported: ['public'],
-    id_token_signing_alg_values_supported: [...new Set(iss.keys.map(k => k.alg))], code_challenge_methods_supported: ['S256'],
-    ...iss.discovery,
-  });
-
-  // A fetch over node:https that trusts only this certificate. oauth4webapi passes a Headers object
-  // and a string or URLSearchParams body.
-  const opFetch = (input, init = {}) => new Promise((resolve, reject) => {
-    const url = new URL(typeof input === 'string' ? input : input.href ?? input.url);
-    if (url.protocol !== 'https:' || url.hostname !== '127.0.0.1' || url.port !== String(server.address().port)) return reject(new TypeError(`fake OP fetch refuses ${url.origin}`));
-    const headers = Object.fromEntries(new Headers(init.headers ?? {}));
-    const body = init.body === undefined || init.body === null ? undefined : String(init.body);
-    if (body !== undefined) headers['content-length'] = Buffer.byteLength(body);
-    const req = request(url, { method: init.method ?? 'GET', headers, ca: cert, signal: init.signal }, res => {
-      const chunks = [];
-      res.on('data', c => chunks.push(c));
-      res.on('end', () => {
-        const h = new Headers();
-        for (const [k, v] of Object.entries(res.headers)) h.set(k, Array.isArray(v) ? v.join(', ') : v);
-        const response = new Response(res.statusCode === 204 ? null : Buffer.concat(chunks), { status: res.statusCode, headers: h });
-        Object.defineProperty(response, 'url', { value: url.href });
-        resolve(response);
-      });
-      res.on('error', reject);
-    });
-    req.on('error', reject);
-    req.end(body);
-  });
-
-  return {
-    base, fetch: opFetch, cert,
-    issuer(name, opts = {}) { const iss = issuerState(name, base, opts); issuers.set(name, iss); return iss; },
-    // A code for `iss` whose ID token is built from the start redirect's nonce, the claims and header
-    // overrides. `challenge` defaults to the start redirect's; `idToken` replaces the token outright.
-    grant(iss, authorizeUrl, { sub = `user-${iss.name}`, claims = {}, header = {}, key = iss.keys[0], idToken = null, challenge = null, redirectUri = null } = {}) {
-      const q = new URL(authorizeUrl).searchParams;
-      const now = Math.floor(Date.now() / 1000);
-      const payload = { iss: iss.issuer, sub, aud: iss.clientId, iat: now, exp: now + 300, nonce: q.get('nonce'), ...claims };
-      for (const [k, v] of Object.entries(payload)) if (v === undefined) delete payload[k];
-      const token = idToken ?? jwt({ alg: key.alg, kid: key.kid, typ: 'JWT', ...header }, payload, { key: key.privateKey, hmac: iss.clientSecret });
-      const code = randomBytes(12).toString('base64url');
-      iss.codes.set(code, { idToken: token, challenge: challenge ?? q.get('code_challenge'), redirectUri: redirectUri ?? q.get('redirect_uri') });
-      return { code, idToken: token, payload };
-    },
-    rotate(iss, next = rsaKey()) { iss.retired.push(...iss.keys); iss.keys = [next]; return next; },
-    close: () => new Promise(r => { server.close(r); server.closeAllConnections(); }),
-  };
-}
-

packages/webui/tests/service.test.mjs

@@ -30,7 +30,7 @@ function fakeCopy(dir) {
   writeFileSync(join(copyRoot(dir), 'packages', 'webui', 'src', 'cli.mjs'), '');
   return copyRoot(dir);
 }
-const SEND_REFUSAL = /^webui-service: --send needs the preview mode \(--public-host, --auth-header and --allow-user\) or --sso$/m;
+const SEND_REFUSAL = /^webui-service: --send needs the preview mode \(--public-host, --auth-header and --allow-user\)$/m;
 const TEMPLATE = readFileSync(join(REPO, 'packages', 'webui', 'systemd', 'mosaic-webui.service.in'), 'utf8');
 
 // The unit as the base script renders it (row 75): the template with its four

packages/webui/tests/sso-browser.test.mjs

@@ -1,132 +0,0 @@
-// Q175 phase 1 (#1690, design test 24, sage-1340 F1, sage-1347 F7): the page under --sso. A read
-// the Console answers 401 `sign-in required` signs the page out the way a proxy redirect does, and
-// the line links to /auth/login with the current path and query; any other 401 stays an error. Both
-// fetch paths in app.js and both in bus.js (fetchRead and fetchApi) do it. The Sign out form shows
-// only when /api/config says sso. The board-held.test.mjs stub, with two lists of paths: those in
-// window.__signIn answer 401 `sign-in required`, those in window.__other 401 `unauthenticated`. A
-// page URL holding `sso` gets `sso: true` added to /api/config. Poll timers fire after 150 ms.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Store } from '../../bus/src/store.mjs';
-import { Broker } from '../../bus/src/broker.mjs';
-import { views } from '../../bus/src/views.mjs';
-import { startServer } from '../src/serve.mjs';
-import { browser } from './browser.mjs';
-import { fixture, close } from './fixture.mjs';
-
-const businesses = { demo: { id: 'demo', human: 'jason', arbiters: { technical: 'cto', delivery: 'pm' }, roles: { pm: { authority: { withinRole: ['message.send'], crossRole: [] } }, cto: { authority: { withinRole: ['message.send'], crossRole: [] } } } } };
-
-const stub = `(() => {
-  const real = window.fetch.bind(window);
-  window.__reqs = []; window.__signIn = []; window.__other = [];
-  const timeout = window.setTimeout.bind(window);
-  window.setTimeout = (f, ms, ...rest) => timeout(f, ms === 10000 ? 150 : ms, ...rest);
-  const answer = (status, body) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
-  window.fetch = async (url, init = {}) => {
-    const path = String(url).split('?')[0];
-    window.__reqs.push(path);
-    if (window.__signIn.includes(path)) return answer(401, { error: 'sign-in required' });
-    if (window.__other.includes(path)) return answer(401, { error: 'unauthenticated' });
-    if (path === '/api/config' && /sso/.test(location.search)) return answer(200, { ...(await (await real(url, init)).json()), sso: true });
-    return real(url, init);
-  };
-})();`;
-
-async function setup() {
-  const root = mkdtempSync(join(tmpdir(), 'webui-sso-browser-'));
-  const store = new Store(root), b0 = new Broker({ store, businesses });
-  b0.request(b0.bindLaunch({ business: 'demo', role: 'pm', run: 'pm-run', harness: 'pi', address: 'pm-run' }), { verb: 'role.claim' });
-  const reader = b0.bindReader({ business: 'demo' });
-  const bus = views({ call: async (verb, args = {}) => structuredClone(b0.request(reader, { verb, args })) });
-  const f = await fixture(), b = await browser({ machine: true });
-  const web = await startServer({ port: 0, board: f.boardURL, bus }), base = `http://127.0.0.1:${web.address().port}/`;
-  await b.call('Page.addScriptToEvaluateOnNewDocument', { source: stub });
-  await b.viewport(1280);
-  const wait = expr => b.evaluate(`(async()=>{for(let i=0;i<100;i++){if(${expr})return true;await new Promise(r=>setTimeout(r,50))}throw new Error('Condition timed out: '+${JSON.stringify(expr)})})()`);
-  const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
-  const shown = sel => b.evaluate(`(()=>{const e=document.querySelector(${JSON.stringify(sel)});return !!e && !e.hidden && getComputedStyle(e).display !== 'none' && !!e.getClientRects().length})()`);
-  const reqs = () => b.evaluate('window.__reqs.length');
-  const settle = () => new Promise(r => setTimeout(r, 600));
-  const done = async () => { await b.close(); await close(web); await f.close(); store.close(); rmSync(root, { recursive: true, force: true }); };
-  return { b, base, wait, text, shown, reqs, settle, done };
-}
-
-const LOADED = 'document.querySelector("table.sessions [data-open=\'proj/agent1\']")';
-const LINE = 'Signed out. Sign in again.';
-
-test('a 401 sign-in required on each fetch path signs the page out with a sign-in link and stops the refresh; another 401 stays an error', { timeout: 120000 }, async () => {
-  const { b, base, wait, text, shown, reqs, settle, done } = await setup();
-  // The line, its link back to this page, the Sign out form gone, and no further fetch.
-  const out = async ret => {
-    await wait('!document.querySelector("#signed-out").hidden');
-    assert.equal(await text('#signed-out'), LINE);
-    assert.equal(await b.evaluate('document.querySelector("#signed-out a").getAttribute("href")'), `/auth/login?return=${encodeURIComponent(ret)}`);
-    assert.equal(await shown('#sign-out'), false);
-    assert.equal(await b.evaluate('document.querySelector("#refresh").disabled'), true);
-    const n = await reqs();
-    await b.evaluate('document.querySelector("#refresh").click(), true');
-    await settle();
-    assert.equal(await reqs(), n, 'the page fetched after signing out');
-  };
-  try {
-    // app.js api(): the Board read, with sso on from /api/config.
-    await b.navigate(`${base}?sso&x=1`);
-    await wait(LOADED);
-    await b.evaluate(`window.__signIn.push('/api/board'), document.querySelector('#refresh').click(), true`);
-    await out('/?sso&x=1');
-
-    // app.js getJSON: the conversation catalogue behind History.
-    await b.navigate(`${base}?sso&conv`);
-    await wait(LOADED);
-    await b.evaluate(`window.__signIn.push('/api/conversations'), document.querySelector('table.sessions [data-history="proj/agent1"]').click(), true`);
-    await out('/?sso&conv');
-
-    // app.js api(): the board POST behind Seen.
-    await b.navigate(`${base}?sso&seen`);
-    await wait(LOADED);
-    await b.evaluate(`document.querySelector('table.sessions [data-open="proj/agent1"]').click(), true`);
-    await wait('document.querySelector("#inspection [data-seen]")');
-    await b.evaluate(`window.__signIn.push('/api/seen'), document.querySelector('#inspection [data-seen]').click(), true`);
-    await out('/?sso&seen');
-
-    // bus.js fetchRead and fetchApi, on a page whose /api/config has no sso: the link comes from
-    // the 401 itself (F1).
-    await b.navigate(`${base}?read#/inbox`);
-    await wait(LOADED);
-    await b.evaluate(`window.__signIn.push('/api/bus/inbox'), document.querySelector('#refresh').click(), true`);
-    await out('/?read');
-    await b.navigate(`${base}?module`);
-    await wait(LOADED);
-    await b.evaluate(`window.__signIn.push('/api/queue'), location.hash = '#/queue', true`);
-    await out('/?module');
-
-    // Any other 401 is an error: no sign-out, and the polls go on.
-    await b.navigate(`${base}?sso&other`);
-    await wait(LOADED);
-    await b.evaluate(`window.__other.push('/api/board', '/api/bus/inbox', '/api/queue'), document.querySelector('#refresh').click(), true`);
-    await settle();
-    assert.equal(await b.evaluate('document.querySelector("#signed-out").hidden'), true);
-    assert.equal(await b.evaluate('document.body.classList.contains("signed-out")'), false);
-    const n = await reqs();
-    await settle();
-    assert.ok(await reqs() > n, 'the refresh stopped on another 401');
-    assert.equal(await shown('#sign-out'), true);
-  } finally { await done(); }
-});
-
-test('the Sign out form shows only when /api/config says sso, and posts to /auth/logout', { timeout: 120000 }, async () => {
-  const { b, base, wait, shown, done } = await setup();
-  try {
-    await b.navigate(base);
-    await wait(LOADED);
-    await new Promise(r => setTimeout(r, 300));
-    assert.equal(await shown('#sign-out'), false);
-    await b.navigate(`${base}?sso`);
-    await wait(`${LOADED} && !document.querySelector("#sign-out").hidden`);
-    assert.equal(await shown('#sign-out'), true);
-    assert.deepEqual(await b.evaluate('(() => { const f = document.querySelector("#sign-out"); return [f.method, f.getAttribute("action"), f.querySelector("button").textContent, f.querySelector("button").type]; })()'), ['post', '/auth/logout', 'Sign out', 'submit']);
-  } finally { await done(); }
-});

packages/webui/tests/sso.test.mjs

@@ -1,589 +0,0 @@
-// Q175 phase 1 (#1690, design agents/sage/work/q175-sso/DESIGN.md section 9): the Console as an
-// OIDC relying party (--sso). Every provider is the fake OP in helpers/fake-oidc.mjs on loopback;
-// no test reaches a real provider, the live Console or a real config or slot file. The public name
-// is console.example.test, sent only as a Host header to the test's own loopback listener. Each
-// refusal checks the status, that no session cookie was set and that the send stub never ran.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { request } from 'node:http';
-import { spawn, spawnSync } from 'node:child_process';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { startServer } from '../src/serve.mjs';
-import { createSso, readSlot, SESSION_COOKIE, LOGIN_COOKIE } from '../src/sso.mjs';
-import { close } from './fixture.mjs';
-import { b64url, ecKey, fakeOidc, jwt, psKey, rsaKey } from './helpers/fake-oidc.mjs';
-
-const HOST = 'console.example.test', ORIGIN = `https://${HOST}`;
-const CLI = fileURLToPath(new URL('../src/cli.mjs', import.meta.url));
-const MSG = JSON.stringify({ to: 'coder', body: 'Please look at row 192.' });
-// Test 19: every log line any test here captured, and every token, code, state, nonce, verifier,
-// client secret and session id any test produced. The last test checks the one against the other.
-const ALL_LINES = [], PRODUCED = new Set();
-
-// node:http, not fetch: fetch can't set Host, Origin or Sec-Fetch-Site.
-function call(port, { method = 'GET', path = '/', headers = {}, body, host = HOST } = {}) {
-  return new Promise((resolve, reject) => {
-    const length = body === undefined ? {} : { 'content-length': Buffer.byteLength(body) };
-    const req = request({ host: '127.0.0.1', port, method, path, headers: { host, ...length, ...headers } }, res => {
-      let text = '';
-      res.on('data', c => (text += c));
-      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: text && (res.headers['content-type'] ?? '').startsWith('application/json') ? JSON.parse(text) : text }));
-    });
-    req.on('error', reject);
-    req.end(body);
-  });
-}
-const setCookies = r => [r.headers['set-cookie'] ?? []].flat();
-const sessionOf = r => setCookies(r).find(c => c.startsWith(`${SESSION_COOKIE}=`) && !c.includes('Max-Age=0'))?.split(';')[0] ?? null;
-const writeHeaders = cookie => ({ ...(cookie ? { cookie } : {}), origin: ORIGIN, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' });
-
-function providerFor(iss, extra = {}) {
-  return { id: iss.name, issuer: iss.issuer, clientId: iss.clientId, clientSecret: { slot: iss.name }, algs: [...new Set(iss.keys.map(k => k.alg))], subjects: [{ sub: `user-${iss.name}`, name: `person-${iss.name}` }], ...extra };
-}
-
-// A fake OP with `issuers`, createSso over them, and the human listener with a counting send.
-async function setup(t, { issuers = [{ name: 'a' }], provider = {}, before = null, retryFirst = 5000, server = {} } = {}) {
-  const op = await fakeOidc();
-  t.after(() => op.close());
-  const iss = issuers.map(o => op.issuer(o.name, o));
-  for (const i of iss) PRODUCED.add(i.clientSecret);
-  before?.(op, iss);
-  const config = { publicOrigin: ORIGIN, providers: iss.map(i => providerFor(i, provider[i.name] ?? {})) };
-  const lines = [];
-  const log = line => { lines.push(line); ALL_LINES.push(line); };
-  const sso = await createSso(config, { secrets: new Map(iss.map(i => [i.name, i.clientSecret])), fetch: op.fetch, log, retryFirst });
-  t.after(() => sso.close());
-  const sends = [];
-  const bus = Object.fromEntries(['inbox', 'tasks', 'agents', 'trail', 'decisions'].map(v => [v, async () => [{ verb: v }]]));
-  const web = await startServer({ port: 0, board: 'http://127.0.0.1:9', bus, sso, send: async args => { sends.push(args); return { id: 'msg-0001' }; }, log, ...server });
-  t.after(() => close(web));
-  return { op, iss, sso, port: web.address().port, lines, sends, config, bus };
-}
-
-// GET /auth/login; returns the authorize URL and the login cookie (name=value).
-async function begin(env, { provider = null, ret = null, query = null, host = HOST } = {}) {
-  const q = query ?? new URLSearchParams({ ...(provider ? { provider } : {}), ...(ret !== null ? { return: ret } : {}) }).toString();
-  const r = await call(env.port, { path: `/auth/login${q ? `?${q}` : ''}`, host });
-  assert.equal(r.status, 303, `login start: ${r.status} ${r.body}`);
-  const cookie = setCookies(r)[0].split(';')[0];
-  const location = r.headers.location;
-  const params = new URL(location).searchParams;
-  PRODUCED.add(cookie.split('=')[1]);
-  for (const k of ['state', 'nonce', 'code_challenge']) PRODUCED.add(params.get(k));
-  for (const record of env.sso.logins.values()) PRODUCED.add(record.verifier);
-  return { r, cookie, location, params };
-}
-function callback(env, begun, { code, state = begun.params.get('state'), extra = {}, cookie = begun.cookie } = {}) {
-  const q = new URLSearchParams({ ...(code !== undefined ? { code } : {}), state, ...extra });
-  return call(env.port, { path: `/auth/callback?${q}`, headers: cookie ? { cookie } : {} });
-}
-function grant(env, begun, iss, opts = {}) {
-  const g = env.op.grant(iss, begun.location, opts);
-  PRODUCED.add(g.code);
-  PRODUCED.add(g.idToken);
-  return g;
-}
-// A whole sign-in: start, a code at the OP, the callback. Returns the callback answer and the
-// session cookie (name=value) when one was set.
-async function signIn(env, { iss = env.iss[0], ret = null, opts = {} } = {}) {
-  const begun = await begin(env, { provider: env.iss.length > 1 ? iss.name : null, ret });
-  const g = grant(env, begun, iss, opts);
-  const r = await callback(env, begun, { code: g.code });
-  const session = sessionOf(r);
-  if (session) PRODUCED.add(session.split('=')[1]);
-  return { begun, g, r, session };
-}
-function refused(env, r, code) {
-  assert.equal(r.status, 403, `expected 403, got ${r.status}`);
-  assert.equal(sessionOf(r), null, 'a session cookie was set');
-  assert.equal(env.sends.length, 0, 'the send stub ran');
-  assert.ok(setCookies(r).includes(`${LOGIN_COOKIE}=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0`), 'the login cookie was not expired');
-  if (code) assert.match(env.lines.at(-1), new RegExp(` sso refused code=${code} provider=`), env.lines.at(-1));
-}
-
-test('positive: an RS256 provider signs in and sends one message, and the session reads', async t => {
-  const env = await setup(t);
-  assert.notEqual(env.port, 7332);
-  const { r, session } = await signIn(env, { ret: '/board?x=1' });
-  assert.equal(r.status, 303);
-  assert.equal(r.headers.location, `${ORIGIN}/board?x=1`);
-  assert.ok(session);
-  const send = await call(env.port, { method: 'POST', path: '/api/bus/message', headers: writeHeaders(session), body: MSG });
-  assert.equal(send.status, 200, JSON.stringify(send.body));
-  assert.deepEqual(env.sends, [{ to: 'coder', body: 'Please look at row 192.' }]);
-  assert.match(env.lines.at(-1), / send user="person-a" to="coder" id=msg-0001$/);
-  const read = await call(env.port, { path: '/api/bus/inbox', headers: { cookie: session } });
-  assert.equal(read.status, 200);
-  const config = await call(env.port, { path: '/api/config', headers: { cookie: session } });
-  assert.equal(config.body.sso, true);
-  assert.equal(config.body.send, true);
-});
-
-test('positive: an ES256 provider signs in and sends', async t => {
-  const env = await setup(t, { issuers: [{ name: 'e', keys: [ecKey()] }] });
-  assert.deepEqual(env.config.providers[0].algs, ['ES256']);
-  const { session } = await signIn(env);
-  assert.ok(session);
-  assert.equal((await call(env.port, { method: 'POST', path: '/api/bus/message', headers: writeHeaders(session), body: MSG })).status, 200);
-  assert.equal(env.sends.length, 1);
-});
-
-test('positive: two providers each sign in their own subjects, and one provider\'s subject is unknown to the other', async t => {
-  const env = await setup(t, { issuers: [{ name: 'a' }, { name: 'b', keys: [ecKey()] }] });
-  const list = await call(env.port, { path: '/auth/login?return=%2Fboard' });
-  assert.equal(list.status, 200);
-  assert.match(list.body, /provider=a&return=%2Fboard/);
-  assert.match(list.body, /provider=b&return=%2Fboard/);
-  const [a, b] = env.iss;
-  assert.ok((await signIn(env, { iss: a })).session);
-  assert.ok((await signIn(env, { iss: b })).session);
-  const names = [...env.sso.sessions.values()].map(s => s.name);
-  assert.deepEqual(names, ['person-a', 'person-b']);
-  const cross = await signIn(env, { iss: b, opts: { sub: 'user-a' } });
-  refused({ ...env, sends: [] }, cross.r, 'subject-unknown');
-});
-
-test('1: a forged x-authentik header without a cookie is 401 on the API and a sign-in redirect on a page', async t => {
-  const env = await setup(t);
-  const forged = { 'x-authentik-username': 'jason.woltje', origin: ORIGIN, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' };
-  for (const [method, path, body] of [['POST', '/api/bus/message', MSG], ['POST', '/api/settings', '{}'], ['GET', '/api/config', undefined]]) {
-    const r = await call(env.port, { method, path, headers: forged, body });
-    assert.equal(r.status, 401, `${method} ${path}`);
-    assert.deepEqual(r.body, { error: 'sign-in required' });
-  }
-  const page = await call(env.port, { path: '/', headers: forged });
-  assert.equal(page.status, 303);
-  assert.equal(page.headers.location, '/auth/login?return=%2F');
-  const deep = await call(env.port, { path: '/board?x=1' });
-  assert.equal(deep.headers.location, '/auth/login?return=%2Fboard%3Fx%3D1');
-  assert.equal(env.sends.length, 0);
-});
-
-test('2: an HS256 ID token keyed with the client secret and a real RSA kid is refused', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  const { r } = await signIn(env, { opts: { header: { alg: 'HS256', kid: iss.keys[0].kid } } });
-  refused(env, r, 'id-token-invalid');
-});
-
-test('3: a wrong aud, and an aud list holding another client with no azp, are refused', async t => {
-  const env = await setup(t);
-  refused(env, (await signIn(env, { opts: { claims: { aud: 'another-client' } } })).r, 'id-token-invalid');
-  refused(env, (await signIn(env, { opts: { claims: { aud: [env.iss[0].clientId, 'another-client'] } } })).r, 'id-token-invalid');
-});
-
-test('4: a token that expired 10 minutes ago is refused', async t => {
-  const env = await setup(t);
-  const now = Math.floor(Date.now() / 1000);
-  refused(env, (await signIn(env, { opts: { claims: { iat: now - 900, exp: now - 600 } } })).r, 'id-token-invalid');
-});
-
-test('5: another issuer, and the issuer without its trailing slash, are refused', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  refused(env, (await signIn(env, { opts: { claims: { iss: `${env.op.base}/other/` } } })).r, 'id-token-invalid');
-  refused(env, (await signIn(env, { opts: { claims: { iss: iss.issuer.slice(0, -1) } } })).r, 'id-token-invalid');
-});
-
-test('6: a nonce mismatch and a missing nonce are refused', async t => {
-  const env = await setup(t);
-  refused(env, (await signIn(env, { opts: { claims: { nonce: 'not-the-nonce' } } })).r, 'id-token-invalid');
-  refused(env, (await signIn(env, { opts: { claims: { nonce: undefined } } })).r, 'id-token-invalid');
-});
-
-test('7: state mismatch, no login cookie, a replay, an expired record and two login cookies are refused', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  let begun = await begin(env);
-  refused(env, await callback(env, begun, { code: grant(env, begun, iss).code, state: 'wrong-state' }), 'state-mismatch');
-  begun = await begin(env);
-  refused(env, await callback(env, begun, { code: grant(env, begun, iss).code, cookie: null }), 'login-record-missing');
-  // Replay: the OP takes the code twice, so only the take-and-delete rule refuses the second callback.
-  iss.acceptTwice = true;
-  begun = await begin(env);
-  const g = grant(env, begun, iss);
-  const first = await callback(env, begun, { code: g.code });
-  assert.equal(first.status, 303);
-  PRODUCED.add(sessionOf(first).split('=')[1]);
-  refused(env, await callback(env, begun, { code: g.code }), 'login-record-missing');
-  iss.acceptTwice = false;
-  begun = await begin(env);
-  for (const record of env.sso.logins.values()) record.expires = Date.now() - 1;
-  refused(env, await callback(env, begun, { code: grant(env, begun, iss).code }), 'login-record-missing');
-  begun = await begin(env);
-  const other = await begin(env);
-  refused(env, await callback(env, begun, { code: grant(env, begun, iss).code, cookie: `${begun.cookie}; ${other.cookie}` }), 'login-record-missing');
-});
-
-test('8: the token request carries the PKCE verifier, and the OP refuses a wrong one', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  const { r, begun } = await signIn(env);
-  assert.equal(r.status, 303);
-  const { form } = iss.tokenRequests.at(-1);
-  assert.equal(begun.params.get('code_challenge_method'), 'S256');
-  const { createHash } = await import('node:crypto');
-  assert.equal(createHash('sha256').update(form.code_verifier).digest('base64url'), begun.params.get('code_challenge'));
-  refused(env, (await signIn(env, { opts: { challenge: 'not-the-challenge' } })).r, 'grant-failed');
-});
-
-test('9: alg none, a changed payload under a real kid, and an unknown kid even after the refetch are refused', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  // (a) alg none: the alg rule, before any signature check.
-  refused(env, (await signIn(env, { opts: { header: { alg: 'none' } } })).r, 'id-token-invalid');
-  // (b) a real kid's signature over another payload: only the signature check catches it.
-  let begun = await begin(env);
-  const real = env.op.grant(iss, begun.location);
-  PRODUCED.add(real.idToken);
-  const [h, , s] = real.idToken.split('.');
-  const forged = `${h}.${b64url({ ...real.payload, name: 'changed' })}.${s}`;
-  refused(env, await callback(env, begun, { code: grant(env, begun, iss, { idToken: forged }).code }), 'signature-invalid');
-  // (c) a key the JWKS never held, again after the cache is old enough to refetch.
-  t.mock.timers.enable({ apis: ['Date'], now: Date.now() });
-  const stranger = rsaKey('not-in-jwks');
-  refused(env, (await signIn(env, { opts: { key: stranger } })).r, 'signature-invalid');
-  const fetches = iss.jwksFetches;
-  t.mock.timers.tick(61000);
-  refused(env, (await signIn(env, { opts: { key: stranger } })).r, 'signature-invalid');
-  assert.equal(iss.jwksFetches, fetches + 1, 'no refetch');
-});
-
-test('10: a valid token for a subject not configured is 403 with one subject-unknown line', async t => {
-  const env = await setup(t);
-  const before = env.lines.length;
-  const { r } = await signIn(env, { opts: { sub: 'stranger' } });
-  refused(env, r, 'subject-unknown');
-  const added = env.lines.slice(before);
-  assert.equal(added.length, 1);
-  assert.match(added[0], new RegExp(`^\\S+ sso refused code=subject-unknown provider=a iss=${JSON.stringify(env.iss[0].issuer).replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')} sub="stranger"$`));
-});
-
-test('11: start refusals: HS or none algs, reserved names, HS-only discovery, an empty JWKS, no S256, an issuer mismatch, a short RSA key', async t => {
-  const op = await fakeOidc();
-  t.after(() => op.close());
-  const start = (iss, extra = {}) => createSso({ publicOrigin: ORIGIN, providers: [providerFor(iss, extra)] }, { secrets: new Map([[iss.name, iss.clientSecret]]), fetch: op.fetch, log: l => ALL_LINES.push(l) });
-  const a = op.issuer('a');
-  PRODUCED.add(a.clientSecret);
-  for (const [extra, why] of [
-    [{ algs: ['HS256'] }, /algs\[0\] must be one of .*HS\* and none are refused/],
-    [{ algs: ['none'] }, /algs\[0\] must be one of/],
-    [{ subjects: [{ sub: 'u', name: 'tester' }] }, /subjects\[0\]\.name must not be tester or human/],
-    [{ subjects: [{ sub: 'u', name: 'Human' }] }, /subjects\[0\]\.name must not be tester or human/],
-  ]) await assert.rejects(start(a, extra), why);
-  const refusedAtDiscovery = /console\.sso provider \w+ refused at discovery/;
-  // The mosaic-preview shape: HS256 only.
-  const hs = op.issuer('hs', { discovery: { id_token_signing_alg_values_supported: ['HS256'] } });
-  await assert.rejects(start(hs, { algs: ['RS256'] }), refusedAtDiscovery);
-  const empty = op.issuer('empty');
-  empty.jwksOverride = { keys: [] };
-  await assert.rejects(start(empty), refusedAtDiscovery);
-  const plain = op.issuer('plain', { discovery: { code_challenge_methods_supported: ['plain'] } });
-  await assert.rejects(start(plain), refusedAtDiscovery);
-  const moved = op.issuer('moved');
-  moved.discovery = { issuer: `${op.base}/elsewhere/` };
-  await assert.rejects(start(moved), refusedAtDiscovery);
-  const small = op.issuer('small', { keys: [rsaKey('small', 1024)] });
-  await assert.rejects(start(small), refusedAtDiscovery);
-  // The control: the same OP and provider start.
-  const sso = await start(a);
-  assert.deepEqual(sso.health(), { a: 'ready' });
-  sso.close();
-  await assert.rejects(startServer({ port: 0, sso, preview: { host: HOST, header: 'remote-user', user: 'jason' } }), /--sso cannot be combined/);
-});
-
-test('11: slot files: a symlink, mode 0644, mode 0640 and a file under the repository are refused, and no message holds the value', t => {
-  const root = mkdtempSync(join(tmpdir(), 'webui-sso-slot-'));
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-  const dir = join(root, 'config'), slots = join(dir, 'secrets', 'mosaic-stack');
-  mkdirSync(slots, { recursive: true });
-  const provider = slot => ({ id: 'a', clientSecret: { slot } });
-  const value = 'slot-value-do-not-print';
-  const opts = { repo: join(root, 'repo'), copies: join(root, 'copies') };
-  writeFileSync(join(slots, 'good'), `${value}\n`, { mode: 0o600 });
-  assert.equal(readSlot(dir, provider('good'), opts), value);
-  writeFileSync(join(root, 'target'), value, { mode: 0o600 });
-  symlinkSync(join(root, 'target'), join(slots, 'link'));
-  for (const [slot, mode] of [['wide', 0o644], ['group', 0o640]]) { writeFileSync(join(slots, slot), value); chmodSync(join(slots, slot), mode); }
-  writeFileSync(join(slots, 'two'), `${value}\nmore\n`, { mode: 0o600 });
-  writeFileSync(join(slots, 'empty'), '\n', { mode: 0o600 });
-  const cases = [
-    ['missing', /slot is missing$/, opts],
-    ['link', /must not be a symbolic link$/, opts],
-    ['wide', /must have no group or other permission bits$/, opts],
-    ['group', /must have no group or other permission bits$/, opts],
-    ['two', /must hold one non-empty line$/, opts],
-    ['empty', /must hold one non-empty line$/, opts],
-    // The config dir itself under the repository, and under a --checkout.
-    ['good', /must not be inside the repository or a stack copy$/, { ...opts, repo: root }],
-    ['good', /must not be inside the repository or a stack copy$/, { ...opts, checkout: dir }],
-    ['good', /must not be inside the repository or a stack copy$/, { ...opts, copies: dir }],
-  ];
-  for (const [slot, why, o] of cases) {
-    let err = null;
-    try { readSlot(dir, provider(slot), o); } catch (e) { err = e; }
-    assert.ok(err, `${slot} was read`);
-    assert.match(err.message, /^console\.sso provider a client secret slot /);
-    assert.match(err.message, why, slot);
-    assert.equal(err.message.includes(value), false);
-    assert.equal(err.message.includes(root), false);
-  }
-});
-
-test('11: the CLI refuses --sso with the old flags and without console.sso, and starts with a good one', async t => {
-  const root = mkdtempSync(join(tmpdir(), 'wsso-'));
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-  const env = { ...process.env, MOSAIC_CONFIG: join(root, 'cfg', 'config.json'), XDG_DATA_HOME: join(root, 'xdg') };
-  for (const flags of [['--auth-header', 'remote-user'], ['--public-host', HOST], ['--allow-user', 'jason'], ['--proof-header', 'x-proof']]) {
-    const r = spawnSync(process.execPath, [CLI, 'serve', '--port', '0', '--sso', ...flags], { encoding: 'utf8', timeout: 10000, env });
-    assert.equal(r.status, 2, flags.join(' '));
-    assert.match(r.stderr, /^refused: --sso cannot be combined with --public-host, --auth-header, --allow-user or --proof-\*$/m);
-  }
-  const missing = spawnSync(process.execPath, [CLI, 'serve', '--port', '0', '--sso'], { encoding: 'utf8', timeout: 10000, env });
-  assert.equal(missing.status, 2);
-  assert.match(missing.stderr, /^refused: --sso needs the system config \(/);
-  const op = await fakeOidc();
-  t.after(() => op.close());
-  const a = op.issuer('a');
-  PRODUCED.add(a.clientSecret);
-  mkdirSync(join(root, 'cfg', 'secrets', 'mosaic-stack'), { recursive: true });
-  writeFileSync(join(root, 'ca.pem'), op.cert);
-  const base = { configVersion: 1, environment: 'development', dataRoot: join(root, 'data'), execution: { backend: 'docker', provider: 'zai', model: 'm' } };
-  writeFileSync(env.MOSAIC_CONFIG, JSON.stringify(base));
-  const noKey = spawnSync(process.execPath, [CLI, 'serve', '--port', '0', '--sso'], { encoding: 'utf8', timeout: 10000, env });
-  assert.equal(noKey.status, 2);
-  assert.match(noKey.stderr, /^refused: --sso needs console\.sso in the system config$/m);
-  writeFileSync(env.MOSAIC_CONFIG, JSON.stringify({ ...base, console: { sso: { publicOrigin: ORIGIN, providers: [providerFor(a)] } } }));
-  writeFileSync(join(root, 'cfg', 'secrets', 'mosaic-stack', 'a'), `${a.clientSecret}\n`, { mode: 0o644 });
-  const wide = spawnSync(process.execPath, [CLI, 'serve', '--port', '0', '--sso'], { encoding: 'utf8', timeout: 10000, env });
-  assert.equal(wide.status, 2);
-  assert.match(wide.stderr, /^refused: console\.sso provider a client secret slot must have no group or other permission bits$/m);
-  chmodSync(join(root, 'cfg', 'secrets', 'mosaic-stack', 'a'), 0o600);
-  // The child trusts the fake OP's certificate through NODE_EXTRA_CA_CERTS; the code under test has no flag for it.
-  const child = spawn(process.execPath, [CLI, 'serve', '--port', '0', '--sso'], { env: { ...env, NODE_EXTRA_CA_CERTS: join(root, 'ca.pem') } });
-  t.after(() => child.kill('SIGKILL'));
-  let out = '', err = '';
-  child.stderr.on('data', c => (err += c));
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`no start line: ${out} ${err}`)), 15000);
-    child.stdout.on('data', c => { out += c; if (out.includes('Ctrl-C')) { clearTimeout(timer); resolve(); } });
-    child.on('exit', () => { clearTimeout(timer); reject(new Error(`exited: ${err}`)); });
-  });
-  assert.match(out, new RegExp(`^Sign-in: ${ORIGIN}/ \\(--sso\\), read-only$`, 'm'));
-  assert.match(out, new RegExp(`^Sign-in provider: a issuer ${a.issuer.replace(/[.]/g, '\\.')} subjects 1 \\(ready\\)$`, 'm'));
-  assert.equal(out.includes(a.clientSecret) || err.includes(a.clientSecret), false);
-  assert.equal(out.includes(a.clientId), false);
-  const port = Number(out.match(/^Mosaic Console: http:\/\/127\.0\.0\.1:(\d+)\//m)[1]);
-  const health = await call(port, { path: '/healthz', host: `127.0.0.1:${port}` });
-  assert.deepEqual(health.body, { ok: true, sso: { a: 'ready' } });
-  child.kill('SIGTERM');
-});
-
-test('12: under --sso the tester listener refuses each kind of sign-in, has no /auth, and startServer refuses tester with sso', async t => {
-  const env = await setup(t);
-  const tester = await startServer({ port: 0, board: 'http://127.0.0.1:9', bus: env.bus, tester: true, testerNoSignIn: true, log: () => {} });
-  t.after(() => close(tester));
-  const port = tester.address().port, host = `127.0.0.1:${port}`;
-  const { session, g, begun } = await signIn(env);
-  assert.ok(session);
-  const plain = await call(port, { path: '/api/config', host });
-  assert.equal(plain.status, 200, 'control: a request with no sign-in is served');
-  for (const headers of [
-    { cookie: session },
-    { cookie: `theme=dark; ${begun.cookie}` },
-    { cookie: `${SESSION_COOKIE.toLowerCase()}=x` },
-    { authorization: `Bearer ${g.idToken}` },
-    { 'x-authentik-jwt': g.idToken },
-    { 'X-Authentik-Username': 'jason.woltje' },
-  ]) {
-    const r = await call(port, { path: '/api/config', host, headers });
-    assert.equal(r.status, 403, JSON.stringify(Object.keys(headers)));
-    assert.deepEqual(r.body, { error: 'tester listener takes no sign-in' });
-  }
-  assert.equal((await call(port, { path: '/auth/login', host })).status, 404);
-  await assert.rejects(startServer({ port: 0, tester: true, sso: env.sso }), /tester listener cannot use sso/);
-});
-
-test('13: idle and absolute expiry, logout then reuse, a cross-origin logout, and background reads that don\'t keep a session', async t => {
-  const env = await setup(t);
-  const read = cookie => call(env.port, { path: '/api/bus/inbox', headers: { cookie } });
-  const record = () => [...env.sso.sessions.values()].at(-1);
-  // Background reads don't move `seen`; a page load does.
-  let { session } = await signIn(env);
-  const old = Date.now() - 59 * 60 * 1000;
-  record().seen = old;
-  assert.equal((await read(session)).status, 200);
-  assert.equal(record().seen, old, 'a background read refreshed the session');
-  assert.equal((await call(env.port, { path: '/', headers: { cookie: session } })).status, 200);
-  assert.ok(record().seen > old, 'a page load did not refresh the session');
-  // Idle: 59 minutes of background reads, then one more past the hour.
-  record().seen = Date.now() - 61 * 60 * 1000;
-  assert.equal((await read(session)).status, 401);
-  // Absolute.
-  ({ session } = await signIn(env));
-  record().created = Date.now() - 8 * 3600 * 1000;
-  assert.equal((await call(env.port, { path: '/', headers: { cookie: session } })).headers.location, '/auth/login?return=%2F');
-  // Logout needs same-origin; refused, the session stays.
-  ({ session } = await signIn(env));
-  const cross = await call(env.port, { method: 'POST', path: '/auth/logout', headers: { cookie: session, origin: ORIGIN, 'sec-fetch-site': 'cross-site' } });
-  assert.equal(cross.status, 403);
-  assert.equal((await read(session)).status, 200);
-  const noOrigin = await call(env.port, { method: 'POST', path: '/auth/logout', headers: { cookie: session, 'sec-fetch-site': 'same-origin' } });
-  assert.equal(noOrigin.status, 403);
-  assert.equal((await read(session)).status, 200);
-  const out = await call(env.port, { method: 'POST', path: '/auth/logout', headers: { cookie: session, origin: ORIGIN, 'sec-fetch-site': 'same-origin' } });
-  assert.equal(out.status, 303);
-  const end = new URL(out.headers.location);
-  assert.equal(`${end.origin}${end.pathname}`, `${env.iss[0].issuer}end-session`);
-  assert.equal(end.searchParams.get('post_logout_redirect_uri'), `${ORIGIN}/auth/signed-out`);
-  assert.equal(end.searchParams.get('client_id'), env.iss[0].clientId);
-  assert.ok(end.searchParams.get('id_token_hint'));
-  assert.deepEqual(setCookies(out), [`${SESSION_COOKIE}=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0`]);
-  assert.equal((await read(session)).status, 401);
-  assert.equal((await call(env.port, { method: 'GET', path: '/auth/logout', headers: { cookie: session } })).status, 405);
-});
-
-test('13: the CSP lets the Sign out form reach the provider\'s end-session origin, and only under --sso', async t => {
-  const env = await setup(t);
-  const r = await call(env.port, { path: '/healthz', host: `127.0.0.1:${env.port}` });
-  assert.match(r.headers['content-security-policy'], new RegExp(`; form-action 'self' ${env.op.base.replace(/[.]/g, '\\.')}$`));
-  const plain = await startServer({ port: 0, board: 'http://127.0.0.1:9' });
-  t.after(() => close(plain));
-  const p = await call(plain.address().port, { path: '/healthz', host: `127.0.0.1:${plain.address().port}` });
-  assert.match(p.headers['content-security-policy'], /; form-action 'self'$/);
-});
-
-test('14: open redirects land on /, and a path on the Console lands there', async t => {
-  const env = await setup(t);
-  for (const [query, where] of [
-    ['return=%2F%2Fevil.example', `${ORIGIN}/`],
-    ['return=https%3A%2F%2Fevil.example', `${ORIGIN}/`],
-    ['return=%2F%5Cevil.example', `${ORIGIN}/`],
-    ['return=/%09/evil.example', `${ORIGIN}/`],
-    // Dot segments that leave a pathname of //evil.example stay on the Console (webby-0019 B1).
-    ['return=%2F.%2F%2Fevil.example', `${ORIGIN}//evil.example`],
-    ['return=%2Fx%2F..%2F%2Fevil.example', `${ORIGIN}//evil.example`],
-    [`return=${encodeURIComponent(`${ORIGIN}//evil.example`)}`, `${ORIGIN}//evil.example`],
-    ['return=%2Fboard%2F.%2Fx', `${ORIGIN}/board/x`],
-    ['return=%2Fboard%3Fx%3D1', `${ORIGIN}/board?x=1`],
-    ['', `${ORIGIN}/`],
-  ]) {
-    const begun = await begin(env, { query });
-    const r = await callback(env, begun, { code: grant(env, begun, env.iss[0]).code });
-    assert.equal(r.status, 303);
-    assert.equal(r.headers.location, where, query);
-    assert.equal(new URL(r.headers.location).origin, ORIGIN, query);
-    PRODUCED.add(sessionOf(r).split('=')[1]);
-  }
-});
-
-test('15: a callback for A carrying B\'s code and iss, and a provider= query, is refused', async t => {
-  const env = await setup(t, { issuers: [{ name: 'a' }, { name: 'b' }] });
-  const [, b] = env.iss;
-  for (const extra of [{ iss: b.issuer, provider: 'b' }, { provider: 'b' }]) {
-    const begun = await begin(env, { provider: 'a' });
-    // B's code against A's PKCE challenge and nonce, for B's own subject: only the record rule
-    // (this callback belongs to A) stands in the way.
-    const g = grant(env, begun, b, { sub: 'user-b' });
-    const r = await callback(env, begun, { code: g.code, extra });
-    refused(env, r);
-  }
-  assert.equal(b.tokenRequests.length, 0, 'B\'s token endpoint was called');
-});
-
-test('16: a provider with RS256 and ES256 takes either, and refuses PS256 with a usable PS256 key in the JWKS', async t => {
-  const rsa = rsaKey(), ec = ecKey(), ps = psKey();
-  const env = await setup(t, { issuers: [{ name: 'a', keys: [rsa, ec, ps] }], provider: { a: { algs: ['RS256', 'ES256'] } } });
-  assert.ok((await signIn(env, { opts: { key: rsa } })).session);
-  assert.ok((await signIn(env, { opts: { key: ec } })).session);
-  refused(env, (await signIn(env, { opts: { key: ps } })).r, 'id-token-invalid');
-});
-
-test('17: 33 started logins leave 32 records, and the first one\'s callback finds none', async t => {
-  const env = await setup(t);
-  const first = await begin(env);
-  for (let i = 0; i < 32; i++) await begin(env);
-  assert.equal(env.sso.logins.size, 32);
-  refused(env, await callback(env, first, { code: grant(env, first, env.iss[0]).code }), 'login-record-missing');
-});
-
-test('18: after a key rotation a sign-in works through one refetch, and the removed kid is refused', async t => {
-  const env = await setup(t);
-  const [iss] = env.iss;
-  t.mock.timers.enable({ apis: ['Date'], now: Date.now() });
-  const old = iss.keys[0];
-  assert.ok((await signIn(env)).session);
-  const fetches = iss.jwksFetches;
-  env.op.rotate(iss);
-  t.mock.timers.tick(61000);
-  assert.ok((await signIn(env)).session);
-  assert.equal(iss.jwksFetches, fetches + 1);
-  refused(env, (await signIn(env, { opts: { key: old } })).r, 'signature-invalid');
-});
-
-test('20 and 21: the store holds no raw session id, and the cookie strings are exact', async t => {
-  const env = await setup(t);
-  const begun = await begin(env);
-  assert.match(setCookies(begun.r)[0], new RegExp(`^${LOGIN_COOKIE}=[A-Za-z0-9_-]{43}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=600$`));
-  for (const key of env.sso.logins.keys()) assert.match(key, /^[0-9a-f]{64}$/);
-  const r = await callback(env, begun, { code: grant(env, begun, env.iss[0]).code });
-  const set = setCookies(r);
-  assert.equal(set.length, 2);
-  assert.equal(set[0], `${LOGIN_COOKIE}=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0`);
-  assert.match(set[1], new RegExp(`^${SESSION_COOKIE}=[A-Za-z0-9_-]{43}; Path=/; Secure; HttpOnly; SameSite=Lax$`));
-  const id = set[1].split(';')[0].split('=')[1];
-  PRODUCED.add(id);
-  for (const [key, value] of env.sso.sessions) {
-    assert.match(key, /^[0-9a-f]{64}$/);
-    assert.notEqual(key, id);
-    assert.equal(JSON.stringify(value).includes(id), false);
-  }
-});
-
-test('22: a loopback Host is 403 on a page, a read and a write; /healthz on loopback is 200; a redirect_uri never comes from the Host', async t => {
-  const env = await setup(t);
-  const { session } = await signIn(env);
-  const loop = `127.0.0.1:${env.port}`;
-  for (const [method, path, body] of [['GET', '/', undefined], ['GET', '/api/board', undefined], ['GET', '/api/bus/inbox', undefined], ['POST', '/api/bus/message', MSG]]) {
-    // A loopback Host on this listener's port; any other Host is already the older non-local refusal.
-    for (const host of [loop, `localhost:${env.port}`]) {
-      const r = await call(env.port, { method, path, host, body, headers: { cookie: session, 'content-type': 'application/json' } });
-      assert.equal(r.status, 403, `${method} ${path} ${host}`);
-      assert.deepEqual(r.body, { error: 'public Host required' });
-    }
-  }
-  const health = await call(env.port, { path: '/healthz', host: loop });
-  assert.equal(health.status, 200);
-  assert.deepEqual(health.body, { ok: true, sso: { a: 'ready' } });
-  assert.equal(env.sends.length, 0);
-  const begun = await begin(env, { host: HOST.toUpperCase() });
-  assert.equal(begun.params.get('redirect_uri'), `${ORIGIN}/auth/callback`);
-});
-
-test('23: a provider down at start leaves the Console up and 503, and the retry makes sign-in work', async t => {
-  let env = await setup(t, { retryFirst: 50, before: (op, [a]) => { a.mode = 'down'; } });
-  assert.equal((await call(env.port, { path: '/auth/login' })).status, 503);
-  assert.deepEqual((await call(env.port, { path: '/healthz', host: `127.0.0.1:${env.port}` })).body.sso, { a: 'unreachable' });
-  assert.match(env.lines.at(-1), / sso refused code=discovery-failed provider=a$/);
-  env.iss[0].mode = 'ok';
-  for (let i = 0; i < 100 && env.sso.health().a !== 'ready'; i++) await new Promise(r => setTimeout(r, 20));
-  assert.deepEqual(env.sso.health(), { a: 'ready' });
-  assert.ok((await signIn(env)).session);
-  // A 200 HTML page at the discovery URL is unreachable too, and the Console starts.
-  env = await setup(t, { before: (op, [a]) => { a.mode = 'html'; } });
-  assert.deepEqual(env.sso.health(), { a: 'unreachable' });
-  // HS-only discovery at start refuses the start.
-  await assert.rejects(setup(t, { before: (op, [a]) => { a.discovery = { id_token_signing_alg_values_supported: ['HS256'] }; } }), /refused at discovery/);
-});
-
-test('19: no captured log line holds a token, code, state, nonce, verifier, client secret or session id', () => {
-  assert.ok(ALL_LINES.length > 20, `only ${ALL_LINES.length} lines`);
-  assert.ok(PRODUCED.size > 50, `only ${PRODUCED.size} values`);
-  for (const line of ALL_LINES) {
-    for (const value of PRODUCED) if (value) assert.equal(line.includes(value), false, `a log line holds a produced value: ${line.slice(0, 80)}`);
-    assert.match(line, /^\S+ (sso refused code=[a-z-]+ provider=[a-z0-9-]+( iss="[^"]*" sub="[^"]*")?|send user="[^"]+" to="[^"]*" (id=msg-0001|error=[a-z -]+))$/, line);
-  }
-});

scripts/mosaic-config.mjs

@@ -26,7 +26,6 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { pathToFileURL } from "node:url";
 
 const SUPPORTED_CONFIG_VERSION = 1;
 const SUPPORTED_ENVIRONMENTS = new Set(["development", "production"]);
@@ -107,30 +106,13 @@ function isAncestorOf(ancestor, candidate) {
   return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 
-// Q175 phase 1 (#1690): the optional `console` key, checked for shape only by the Console's own
-// checker. It is imported only when the key is there, so a config without it never needs the
-// Console's code, and a copy of this file alone still reads one.
-async function validateConsole(value) {
-  let checkConsole;
-  try {
-    ({ checkConsole } = await import(pathToFileURL(path.join(import.meta.dirname, "..", "packages", "webui", "src", "sso-config.mjs")).href));
-  } catch {
-    fail(2, 'the "console" key needs packages/webui/src/sso-config.mjs beside this loader');
-  }
-  try {
-    return checkConsole(value);
-  } catch (error) {
-    fail(2, error.message);
-  }
-}
-
-async function validate(document, file) {
+function validate(document, file) {
   if (!isPlainObject(document)) {
     fail(2, "configuration must be a JSON object");
   }
   rejectUnknownKeys(
     document,
-    ["configVersion", "environment", "dataRoot", "execution", "console"],
+    ["configVersion", "environment", "dataRoot", "execution"],
     "configuration",
   );
 
@@ -164,10 +146,6 @@ async function validate(document, file) {
     fail(2, `unsupported execution.adapter: ${JSON.stringify(adapter)} (supported: ${[...SUPPORTED_ADAPTERS].join(", ")})`);
   }
 
-  // Last, so the older checks keep their order. The key is in the output only when the file has
-  // it, so a config without it prints what it always printed.
-  const consoleKey = Object.hasOwn(document, "console") ? await validateConsole(document.console) : undefined;
-
   return {
     configVersion: document.configVersion,
     environment: document.environment,
@@ -178,11 +156,10 @@ async function validate(document, file) {
       model: document.execution.model,
       adapter,
     },
-    ...(consoleKey === undefined ? {} : { console: consoleKey }),
   };
 }
 
-async function load(file) {
+function load(file) {
   const raw = readRaw(file);
   if (raw === null) {
     fail(3, `configuration not found: ${file} (run scripts/bootstrap.sh to create it)`);
@@ -193,7 +170,7 @@ async function load(file) {
   } catch (error) {
     fail(2, `configuration is not valid JSON (${file}): ${error.message}`);
   }
-  return await validate(document, file);
+  return validate(document, file);
 }
 
 function shellQuote(value) {
@@ -217,7 +194,7 @@ const file = configPath();
 switch (operation) {
   case "bootstrap": {
     if (fs.existsSync(file)) {
-      await load(file); // validate only; never rewrite
+      load(file); // validate only; never rewrite
       process.stderr.write(`mosaic-config: configuration already present, validated without changes: ${file}\n`);
       process.exit(0);
     }
@@ -229,26 +206,26 @@ switch (operation) {
       fs.writeFileSync(fd, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`);
     } catch (error) {
       if (error.code === "EEXIST") {
-        await load(file);
+        load(file);
         process.exit(0);
       }
       fail(1, `unable to create configuration: ${error.message}`);
     } finally {
       if (fd !== undefined) fs.closeSync(fd);
     }
-    await load(file);
+    load(file);
     process.stderr.write(`mosaic-config: created default configuration: ${file}\n`);
     process.exit(0);
   }
 
   case "validate": {
-    const resolved = await load(file);
+    const resolved = load(file);
     process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
     process.exit(0);
   }
 
   case "env": {
-    const resolved = await load(file);
+    const resolved = load(file);
     process.stdout.write(
       [
         `MOSAIC_DATA_ROOT=${shellQuote(resolved.dataRoot)}`,

scripts/test-config.sh

@@ -151,52 +151,6 @@ else
     FAIL=$((FAIL+1)); echo "${C_FAIL}FAIL${C_RESET} env exports resolve correctly"
 fi
 
-# --- Q175 phase 1 (#1690), design test 25: the optional console key ---
-# Shape only. The slot path is a FIFO, so a loader that opened the slot would block and the
-# timeout would fail the case; no case reads a slot file.
-mkdir -p "$SANDBOX/secrets/mosaic-stack"
-mkfifo "$SANDBOX/secrets/mosaic-stack/console-sso-test"
-sso_body() {
-    printf '{"configVersion":1,"environment":"development","dataRoot":"%s","execution":{"backend":"docker","provider":"zai","model":"m"},"console":%s}' "$DATA_ROOT" "$1"
-}
-# provider [ALGS] [CLIENT_SECRET]: one provider entry; an empty argument takes the valid value.
-provider() {
-    local algs='["RS256"]' secret='{"slot":"console-sso-test"}'
-    [ -n "${1:-}" ] && algs="$1"
-    [ -n "${2:-}" ] && secret="$2"
-    printf '{"id":"fake","issuer":"https://op.test/app/","clientId":"client-1","clientSecret":%s,"algs":%s,"subjects":[{"sub":"user-1","name":"jason.woltje"}]}' "$secret" "$algs"
-}
-cfg sso-valid.json "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider)"']}}')"
-OUT="$(MOSAIC_CONFIG="$SANDBOX/sso-valid.json" timeout 20 $CONFIG_OP validate 2>&1)"
-[ $? -eq 0 ] && printf '%s' "$OUT" | grep -q '"publicOrigin": "https://console.test"'
-check "valid console.sso loads and is in the output" $?
-
-# expect_refusal NAME PATH-IN-MESSAGE BODY: exit 2, and the message names the bad key path.
-expect_refusal() {
-    cfg sso-bad.json "$2"
-    local err rc
-    err="$(MOSAIC_CONFIG="$SANDBOX/sso-bad.json" timeout 20 $CONFIG_OP validate 2>&1 >/dev/null)"
-    rc=$?
-    [ "$rc" -eq 2 ] && printf '%s' "$err" | grep -qF -- "$3"
-    check "$1 (exit $rc)" $?
-}
-expect_refusal "console.sso HS256 alg exits 2 naming the path" \
-    "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider '["HS256"]')"']}}')" 'console.sso.providers[0].algs[0] must be one of'
-expect_refusal "console.sso alg none exits 2 naming the path" \
-    "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider '["RS256","none"]')"']}}')" 'console.sso.providers[0].algs[1] must be one of'
-expect_refusal "console.sso missing slot field exits 2 naming the path" \
-    "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider '' '{}')"']}}')" 'console.sso.providers[0].clientSecret.slot is required'
-expect_refusal "console.sso slot name outside the pattern exits 2 naming the path" \
-    "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider '' '{"slot":"../x"}')"']}}')" 'console.sso.providers[0].clientSecret.slot must match'
-expect_refusal "unknown key under console exits 2 naming the path" \
-    "$(sso_body '{"sso":{"publicOrigin":"https://console.test","providers":['"$(provider)"']},"extra":1}')" 'console.extra is not a supported key'
-
-# Without the key: the output is exactly what the loader printed before phase 1 (sage-1340, F2).
-cfg no-console.json '{"configVersion":1,"environment":"development","dataRoot":"'$DATA_ROOT'","execution":{"backend":"docker","provider":"zai","model":"m"}}'
-EXPECTED="$(printf '{\n  "configVersion": 1,\n  "environment": "development",\n  "dataRoot": "%s",\n  "execution": {\n    "backend": "docker",\n    "provider": "zai",\n    "model": "m",\n    "adapter": "pi"\n  }\n}' "$DATA_ROOT")"
-[ "$(MOSAIC_CONFIG="$SANDBOX/no-console.json" timeout 20 $CONFIG_OP validate)" = "$EXPECTED" ]
-check "config without console loads with unchanged output" $?
-
 # --- validation must not modify the file ---
 SUM_INVALID_BEFORE=$(sha256sum "$SANDBOX/invalid.json" | cut -d' ' -f1)
 MOSAIC_CONFIG="$SANDBOX/invalid.json" $CONFIG_OP validate >/dev/null 2>&1

scripts/webui-service.sh

@@ -49,9 +49,6 @@
 # character set and refused otherwise. --proof-header NAME --proof-file PATH
 # go together under preview; only the path is carried here, never the secret.
 # render checks ownership, mode and location without opening the proof file.
-# --sso (Q175 phase 1, #1690): the Console signs people in itself from
-# console.sso in config.json. It refuses the preview set and the proof pair,
-# and --send takes it in place of the preview set. Nothing secret is carried.
 #
 # There is no start, stop, enable or restart verb. The Console reads the
 # main listener's bus through the human transport; the optional loopback
@@ -71,7 +68,7 @@ REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 TEMPLATE="$REPO/packages/webui/systemd/mosaic-webui.service.in"
 UNIT_NAME="mosaic-webui.service"
 USAGE="usage: scripts/webui-service.sh copy COMMIT [--copies DIR] [--allow-worktree] | render [--copy ID [--copies DIR]] [FLAGS] | install --copy ID [--copies DIR] [--dir DIR] [--no-reload] [--allow-worktree] [FLAGS] | uninstall [--dir DIR] [--no-reload] | status [--dir DIR]
-  FLAGS: [--port N] [--business ID] [--board URL] [--sso [--send] | --public-host NAME --auth-header HEADER --allow-user ID [--send]] [--tester-port N] [--proof-header NAME --proof-file PATH]
+  FLAGS: [--port N] [--business ID] [--board URL] [--public-host NAME --auth-header HEADER --allow-user ID [--send]] [--tester-port N] [--proof-header NAME --proof-file PATH]
   --tester-port: 1024..65535, different from --port and never 7332; loopback tester listener.
   --allow-worktree is for the tests only: copy and install otherwise refuse outside the canonical checkout."
 
@@ -94,7 +91,6 @@ PUBLIC_HOST=""
 AUTH_HEADER=""
 ALLOW_USER=""
 SEND=0
-SSO=0
 PROOF_HEADER=""
 PROOF_FILE=""
 PROOF_SET=0
@@ -118,7 +114,6 @@ parse_flags() {
             --proof-header) [ $# -ge 2 ] || usage; PROOF_HEADER="$2"; PROOF_SET=1; SERVE_SET=1; shift 2 ;;
             --proof-file) [ $# -ge 2 ] || usage; PROOF_FILE="$2"; PROOF_SET=1; SERVE_SET=1; shift 2 ;;
             --send) SEND=1; SERVE_SET=1; shift ;;
-            --sso) SSO=1; SERVE_SET=1; shift ;;
             *) usage ;;
         esac
     done
@@ -171,13 +166,9 @@ serve_flags() {
     [ -z "$PUBLIC_HOST" ] || preview=$((preview + 1))
     [ -z "$AUTH_HEADER" ] || preview=$((preview + 1))
     [ -z "$ALLOW_USER" ] || preview=$((preview + 1))
-    # serve refuses --sso with the preview set or the proof pair, and --send
-    # without --sso or the preview set; refuse them here first, so no unit is
-    # written that would only exit 2 at start.
-    if [ "$SSO" = 1 ] && { [ "$preview" -ne 0 ] || [ "$PROOF_SET" = 1 ]; }; then
-        die "--sso cannot be combined with --public-host, --auth-header, --allow-user or --proof-*"
-    fi
-    [ "$SEND" = 0 ] || [ "$preview" -eq 3 ] || [ "$SSO" = 1 ] || die "--send needs the preview mode (--public-host, --auth-header and --allow-user) or --sso"
+    # serve refuses --send without the preview set; refuse it here first,
+    # so no unit is written that would only exit 2 at start.
+    [ "$SEND" = 0 ] || [ "$preview" -eq 3 ] || die "--send needs the preview mode (--public-host, --auth-header and --allow-user)"
     if [ "$preview" -ne 0 ]; then
         [ "$preview" -eq 3 ] || die "--public-host, --auth-header and --allow-user go together: all three or none"
         case "$PUBLIC_HOST" in [A-Za-z0-9]*) ;; *) die "public host must be a hostname, no port or scheme: $PUBLIC_HOST" ;; esac
@@ -210,7 +201,6 @@ serve_flags() {
         { [ "$proof_mode" = 600 ] || [ "$proof_mode" = 400 ]; } && [ "$proof_uid" = "$(id -u)" ] || die "invalid proxy proof file metadata"
         flags="$flags --proof-header $PROOF_HEADER --proof-file $PROOF_FILE"
     fi
-    [ "$SSO" = 0 ] || flags="$flags --sso"
     [ "$SEND" = 0 ] || flags="$flags --send"
     [ "$TESTER_SET" = 0 ] || flags="$flags --tester-port $TESTER_PORT"
     echo "$flags"
@@ -395,17 +385,14 @@ status_unit() {
     else
         echo "copy: none; the unit runs from $wd"
     fi
-    # render puts --send after the allowed user and optional proof pair, or
-    # after --sso, before the tester port. The allowed user
+    # render puts --send after the allowed user and optional proof pair,
+    # before the tester port. The allowed user
     # starts with a letter or digit (N5), so it is never the value --send.
-    if grep -Eq '^ExecStart=.*( --allow-user [^ ][^ ]*( --proof-header [^ ]+ --proof-file /[^ ]+)?| --sso) --send( --tester-port [0-9]+)?$' "$target"; then
+    if grep -Eq '^ExecStart=.* --allow-user [^ ][^ ]*( --proof-header [^ ]+ --proof-file /[^ ]+)? --send( --tester-port [0-9]+)?$' "$target"; then
         echo "send: on (--send; human messages to roles)"
     else
         echo "send: off (read-only)"
     fi
-    if grep -Eq '^ExecStart=.* --sso( --send)?( --tester-port [0-9]+)?$' "$target"; then
-        echo "sign-in: the Console's own (--sso)"
-    fi
     local tester_port
     tester_port="$(sed -n 's/^ExecStart=.* --tester-port \([0-9][0-9]*\)$/\1/p' "$target")"
     if [ -n "$tester_port" ]; then