row 195 follow-up: F9 runs node as root only at the pinned, root-only path; header lists root's commands; F6 refuses .. (Duckworth N1-N3, #1693 )

row 195: BUILD.md slot results, 22/22 single, 12/12 mutants killed, gate green on ddf7dce6c (cli 662/0, scripts 429/0) (#1693 )
row 195: case1-accept.sh, root's Case 1 acceptance (F1-F11, P1-P11), its test and TOOLS.md entry; DESIGN r7 doc fixes (#1693 )
2026-10-21 04:01:34 -05:00 · 2026-10-21 03:48:17 -05:00 · 2026-10-21 02:37:27 -05:00 · 2026-10-21 02:37:27 -05:00 · 2026-10-21 02:37:27 -05:00 · 2026-10-21 02:29:11 -05:00
23 changed files with 2582 additions and 35 deletions
@@ -5176,3 +5176,4 @@ Before: managed project/thread verbs had no Console conversation area. After: fi
 2026-10-20 05:10:34 UTC | Row 178 #1676 round 2 verified | Before: C1 render refusals lacked killing tests and row 181 base was pending. Rebased onto 931651f2d, kept all COUNTED/count code and tests, appended T178 tail; added independent owner/collision/absolute/charset/header and empty-loopback proof tests. Four files singly 156/156, all 24 mutants killed, metadata and sandbox fixture probes pass; scratch sweep empty. Packet agents/rocko/work/queue-178/r2/, candidate 9300a670, inventory d0dcde7b (59/59), scan 58 files no findings; in-review revs 2166-2167, expected no-token request failure. No live actions or commits.
 2026-10-21T01:28:05Z | Darkwing | row 232 #1734 installer I1 build, round 1 in review | Before: stack-release.sh managed only user units (systemctl --user), and stack-copy.sh had no bundle copy. After: --units external (adopt, activate, rollback --to, status, confirm, revert, gate --since, AWAITING-UNITS, stale-start, external-pm, --plan --expect-from) and stack-copy check --units external, copy --bundle FILE SHA, wrapper ID --create; user mode byte-identical to the base by test. First build 0af0c73c6 on 00d4cc1f6; rebased onto row 200 (cb5fdb064) as a0ffabc3f on darkwing/row232-r1; --sso refused under external (D9), row 200 config_checks run under external (D10). Gate on Sage's slot (sage-1618): cli 561/0, every scripts/test-*.sh green; 17/17 mutants killed. Results commit 84f1a91e6 (pushed, seat branch only). Manifest 7a3b4ea1 (9 paths), queue revs 2595-2596, request comment 29825, reviewer Filbert. Packet agents/darkwing/work/queue-232/BUILD.md.
 2026-10-21T04:50:44Z | Darkwing | row 233 #1735 installer I3 build, round 1 in review | Before: root had no upgrade driver for root-owned units and no host run sheet; stack-release.sh had no rehearse --backup last and no external plan refusals. After: scripts/stack-upgrade.sh upgrade and rollback (r6 A1-A5, A2f, R1-R4) with 20 tests, docs/guides/host-run-sheet.md, TOOLS.md lines, and on Sage's rulings stack-release.sh --backup last, BACKUP_STORE and the --plan refusals open-activation and migrate-required (3 tests). Base e65a3ab4d (row 232's landing). Gate on Sage's slot (sage-1704) on d99166ade: cli 616/0, every scripts/test-*.sh green, 1201/0 summed by awk; m1-m8 8/8 killed. Correction: the process sweep after the gate found an orphaned sleep 60 from the lock test's flock holder (N1); 08db6ac3f fixes it test only, Sage ruled the gate stands (sage-1707), rerun c0 20/0 and m1 killed with 0 left (sage-1708). Tip 1a1dc80ca (pushed, seat branch only). Manifest 464ce9eb (7 paths), queue revs 2644 and 2647, request comment 29901, reviewer Filbert. Packet agents/darkwing/work/queue-233/BUILD.md.
+2026-10-21T06:37:41Z | Darkwing | row 240 #1746 installer I4 build, round 1 in review | Before: root had no host check for the bwrap AppArmor profile, its pins or a boot unit, and stack-upgrade.sh exited 1 args-failed when the args move after A5 failed, while exit 1 means the old copy runs. After: scripts/case1-hostcheck.sh (seven items, --check, --enforce, --upstream), scripts/case1-pins.sh, mosaic-hostcheck.service and 16 tests; the args move failure exits 5 args-failed, documented in TOOLS.md and run sheet section 6 and tested; run sheet section 3 puts the pinned npm on PATH and names the bin/claude.exe --claude path; sections 8 and 10 have precheck lines. Verification: slot run r1 on 47ec9fe2f failed at the singles (the new N1 test's after hook threw ENOENT after the fixture cleanup removed the root); b45852daa drops the hook; r2 on b45852daa green: singles 16/0 and 21/0, c0 plus M1-M8 8/8 killed, cli 639/0, scripts 585/0. Candidate darkwing/row240-r3 ad1b23ab2 on c771a36f4, manifest 573ece95 (9 paths), revs 2694 and 2695, comment 29943.
@@ -0,0 +1,161 @@
+# Row 195 build: `scripts/case1-accept.sh`
+
+Row 195 (#1693), the Case 1 install on 10.1.1.53. Design r7 at 5425ea2f3, approved by Duckworth
+(duckworth-0087, `agents/duckworth/work/row195/REVIEW-r7.md` at 58d930f89; Gitea 29962). Sage's go to build
+is sage-1817.
+
+## What this commit holds
+
+- `scripts/case1-accept.sh` (new, 100755): section 5's acceptance, F1-F11 and P1-P11.
+- `packages/cli/tests/case1-accept.test.mjs` (new): section 5's cases.
+- `docs/TOOLS.md`: the `case1-accept.sh` entry after the hostcheck entry.
+- This file.
+- `DESIGN.md`, doc-only fixes Sage named in sage-1817, with no new design round:
+  - Duckworth's N1. Section 1's human-id row cited `broker.mjs:245`; the check is `broker.mjs:321`.
+  - Row 226's state at :21 and :326. It said "unclaimed"; 226 is assigned to Gosalyn, briefed and not
+    started (sage-1814).
+  - :340 said I'd send the section 6 items to Gosalyn once 226 was claimed. I sent them on 2026-10-21
+    and Gosalyn acknowledged (gosalyn-0085), so the line now says that.
+
+Nothing else changes. No `case2-*.sh`, `stack-upgrade.sh`, `stack-release.sh`, `case1-hostcheck.sh` or run
+sheet edit, and nothing touches .53 (sage-1809).
+
+## Deviations from section 5, and choices it left open
+
+1. P4's mark is the single token `accepted Q182+Q183`. Section 5 lists `accepted Q182` and `accepted
+   Q183` as marks and gives P4 both. One line can carry one mark, and P4 is the only Q182 path, so the
+   count list has `accepted Q182+Q183` in place of `accepted Q182`.
+2. The test seam replaces `getent`. Under `--root`, the script reads `DIR/etc/passwd` and `DIR/etc/group`
+   with awk. Without it, the same helper calls `getent`. The groups of a user are its primary gid, then
+   each group whose member list names it, which is what `id -G` prints. So there is no fake `id`, and
+   the script never calls `id` for another user.
+3. P10 reads the port floor from `/proc/sys/net/ipv4/ip_unprivileged_port_start` rather than calling
+   `sysctl`, so the seam covers it the way hostcheck's item 7 is covered. There is no fake `sysctl`.
+4. There is no fake `bwrap`, `claude`, `node` or `hostcheck.sh` on PATH. The script runs each by the
+   absolute path the args file or the install names, so the test puts stubs at those paths under
+   `--root`, and the fake `sudo` runs the stack's user's commands from the tree.
+5. The args file must say `--profile factory` and name `--business`. Both are new refusals beyond
+   `stack-upgrade.sh`'s rules. A library file, or one for another business, would make F4 and F7
+   check the wrong thing. After `--`, `--port` and `--tester-port` must be numeric. The args file is the
+   only source of the ports.
+6. F8, F9 and F11 read file metadata as root: `stat`, `-L` and `find -maxdepth 1 -name '*.json'`. None
+   opens the credential. F9 parses `managed-settings.json` with the pinned node, run by root: that node
+   and that file are both root's own, installed by ops-01.
+7. F7 reads `launch.by` from `$HOME/.config/mosaic-dev/businesses/<id>.json` as the stack's user. That
+   path is `businessFilePath(id)` under the default config, which is what the unit uses. It doesn't load
+   the copy's `business.mjs` as `stack-release.sh`'s `plugins launchby` does. The user runs the whole
+   check and prints one line, and root accepts only `ok <instance> run <run>` (sage-1653: root doesn't
+   parse the user's output beyond a fixed pattern).
+8. F5 names a process claude when its argv0's basename or its `comm` starts with `claude`. The window
+   confirms this against a real role session. If the bwrap'd claude shows another name, F5 fails closed
+   and the fix is this match, not the label check.
+9. F3 and F5 run together. `talk` goes out in the background under `timeout 330`, and the `/proc` scan
+   repeats every half second until it finds a labelled pair or `talk` exits. F3's line prints first, then
+   F4, then F5, so the output keeps id order. F3 passes on exit 0 with the `sent` line and a reply line,
+   both counted on stdout only (`cli.mjs:395` and the `formatMessage` write); talk's error goes to stderr.
+12. `--claude` must match `^/[A-Za-z0-9/._+@-]+$`. The `@` is for `node_modules/@anthropic-ai/...`;
+    `stack-upgrade.sh` doesn't check `--claude` at all.
+10. F1 requires all four uids in `/proc/<MainPID>/status` (real, effective, saved, filesystem) to be the
+    user's.
+11. Evidence text the stack's user controls (talk's last line, the precheck's last line, F6's and F10's
+    `--version`) is cut to printable ASCII, one line, 200 bytes.
+
+## Tests
+
+`packages/cli/tests/case1-accept.test.mjs`, 22 tests. Every case builds a scratch host with every F check
+passing and every P check closed or accepted, then changes one thing:
+- all pass: exit 0, ids in order, each P mark, the count lines match the check lines, and the stand-in
+  credential's value appears nowhere;
+- each F check failing alone exits 1 with only its line failing;
+- F3 on exit 0 with only the `sent` line, and its evidence taking talk's stderr;
+- F1 on a failed unit and on `User=root`; F2 on healthz failing and on another pid holding the port;
+- F5 on `unpriv_bwrap (enforce)`, `bwrap//&unpriv_bwrap (complain)`, a trailing space on either label,
+  no bwrap of the user's, and passing on `comm` alone;
+- F6 on a stub that prints nothing and on a path outside `claude-<pin>`;
+- F7 on two live PM launches, a live one for another business, and no `launch.by`;
+- F8 on 0640, on another owner and on a symlink, never printing the credential;
+- F9 on a group-writable mode, another owner and a number for the flag;
+- F11 on one `*.json` under `discord/`, and passing on an empty directory;
+- each P check's unnamed mark, with the line count each fault makes: P6 one line per member, P9 one per
+  missing item; P2, P5, P10 and P11 in more than one way;
+- every P check unnamed at once still exits 0;
+- nine bad args files refuse with exit 2 before any command runs, each with its own refusal text;
+- usage errors, and a user's run without `--root`, exit 2;
+- every in-instance call goes through `sudo -u mosaic -H env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin`,
+  read from the fake `sudo`'s argv, and root's other `sudo` calls are exactly `-l -U mosaic`,
+  `-l -U localadmin` and the jarvis bwrap probe;
+- the host check records `--check` and never `--enforce`.
+
+## Mutants
+
+Section 5's twelve, each one exact replacement in `scripts/case1-accept.sh`, run by
+`/mnt/storage/scratch/darkwing-195-out/mutants.py` in Sage's slot (sage-1865). All twelve were killed.
+After each one the script's bytes were restored, and the final sha256 matched (`d434f15ff638...`). The
+killers below are the tests that failed in each mutant's saved log.
+
+| # | Mutant | Killed by |
+|---|---|---|
+| 1 | F1 passes on a MainPID owned by root | each F alone |
+| 2 | F2 accepts a listener on 0.0.0.0 | each F alone |
+| 3 | F3 passes without a reply | each F alone; F3 exit 0 with no reply line |
+| 4 | F5 matches a substring | F5 labels (the trailing space) |
+| 5 | F6 skips the `--version` check | each F alone; F6 stub and path |
+| 6 | F8 skips the owner check | F8 0640, owner and symlink |
+| 7 | F11 ignores `discord/` | each F alone; F11 `*.json` |
+| 8 | P1 closes on any output | P unnamed; every P unnamed |
+| 9 | P5 maps to `closed` with jarvis in docker | P unnamed; every P unnamed; P2 and P5 names docker |
+| 10 | P9 drops the jarvis item | P unnamed; P9 per item |
+| 11 | P11 accepts any `Before=` | P unnamed; every P unnamed |
+| 12 | a P check's `unnamed` sets the exit to 1 | P unnamed; every P unnamed; P10 and P11; P2 and P5; P9 per item |
+
+Mutant 1 survived the F1 variants test (a failed unit, `User=root`), because those faults fail F1 on the
+unit's state and `User=`, not on the uid line. Each F alone covers the uid line.
+
+## Pre-slot read review
+
+Since every test run is slot work, a read-only subagent traced each case through the script before the
+first slot run, executing nothing. It found four defects, all fixed in this commit:
+- The `--claude` regex had no `@`, so every run refused the args file, the real .53 one included.
+- The fake `stat` logged the args-file call, so the bad-args test's "no command ran" check would fail.
+- The P5 and P6 faults each rewrote `etc/group` from the constant, so applying both lost P5's change.
+- F3 counted stderr into its line count, so a mutant dropping the exit check survived. F3 now counts
+  stdout only, and a `sent`-only case covers the line count.
+
+## Run environment
+
+The build commit ddf7dce6c sits on base 4ced5e63d (origin/refactor when it was pushed). It was first built
+on c515273db as 4a51d392c. Row 238 then changed `docs/TOOLS.md`, so I cherry-picked the three commits onto
+4ced5e63d as `darkwing/row195-b`. `git range-diff` shows all three identical. node v26.8.1 on dragon-lin,
+every run behind my busy check and Sage's, chained with `&&`.
+
+- Step 1, sage-1829 (07:41:54Z to 07:42:05Z), TMPDIR `/tmp/dw195`:
+  `node --test packages/cli/tests/case1-accept.test.mjs`, 22 pass, 0 fail, 11.0 s.
+- Step 2, sage-1865 (08:34:27Z to 08:36:21Z), TMPDIR `/mnt/storage/scratch/tmp/r195`: the twelve mutants
+  above, all killed.
+- Step 3, the gate (08:36:21Z to 08:47:06Z), same TMPDIR, `COMPOSE_PROJECT_NAME=darkwing-r195`:
+
+| Suite | Result |
+|---|---|
+| packages/cli (`node --test tests/*.test.mjs`) | 662 pass, 0 fail, 0 skipped |
+| test-auth.sh | 15 passed, 0 failed |
+| test-conductor.sh | 17 passed, 0 failed |
+| test-config.sh | 31 passed, 0 failed |
+| test-discord.sh | 78 passed, 0 failed |
+| test-extension-package.sh | 18 passed, 0 failed |
+| test-foundation.sh | 44 passed, 0 failed |
+| test-land-work.sh | 86 passed, 0 failed |
+| test-queue.sh | 156 node pass, 0 fail; 28 passed, 0 failed |
+| test-release.sh | 14 passed, 0 failed |
+| test-task.sh | 98 passed, 0 failed |
+
+Summed: 818 node tests passed with 0 failed, and 429 selftests passed with 0 failed. The compose network
+was removed afterwards, and the sweep found no process left in the worktree, the output directory or the
+TMPDIR. This file's results are a doc-only commit on top of the build, so nothing that ran has changed.
+
+## Correction to deviation 6 (follow-up, 2026-10-21)
+
+Deviation 6 says the node F9 runs is root's own. At 37171f65b the script didn't check that. F9 ran
+`--node` as root before F10's path check, so the header's "root itself only reads" was false
+(Duckworth's N1, `agents/duckworth/work/row195/REVIEW-m1.md` at 6afcee2a5). A host installed as designed
+was safe, because `case2-unit.sh` refused a non-root-owned `--node`. The fix and its tests are in
+`FOLLOWUP.md` next to this file.
@@ -0,0 +1,388 @@
+# Row 195 design: the Case 1 install on 10.1.1.53 (r7)
+
+Darkwing, 2026-10-21. Brief: `docs/plans/2026-10-20_hub-own-uid.md`, blob 45be7f09afc1, section "Brief: the
+Case 1 install on 10.1.1.53 (row 195)". Gitea #1693. Reviewer Duckworth, gate owner Sage. Branch
+`darkwing/row195-r7` on c515273db. r6 (b7239bb66 on `darkwing/row195`, approved duckworth-0055) is the base,
+carried unchanged as 7398b7dd7. The r6 text is in that commit and in b7239bb66.
+
+## Changes from r6
+
+Q187 (mos-1108) made install and upgrade product commands, and mos-1118 split r6 into the installer rows
+(`docs/plans/2026-10-20_installer-rows.md`). That brief says row 195 "shrinks to the factory profile's
+values and the Case 1 acceptance". So r7 is mostly a cut. What r6 designed now ships elsewhere:
+
+| r6 piece | Now | State |
+|---|---|---|
+| `stack-release.sh --units external`: `confirm`, `revert`, `gate`, `rollback --to`, external `adopt` and `status`; `stack-copy.sh check --units external` and bundle copies | row 232, I1 | landed |
+| `case1-repin.sh` (A1-A5, A2f, R1-R4) | `scripts/stack-upgrade.sh`, row 233, I3 | landed |
+| the host steps 2a, 2a', 2a'' and the window's root steps | `docs/guides/host-run-sheet.md` sections 1-10, row 233 | landed |
+| `case1-hostcheck.sh`, `case1-pins.sh`, `mosaic-hostcheck.service` (the drift stop, r6 B2) | row 240, I4 | landed c515273db |
+| the unit render, `--profile factory`, `--pm`, `--claude`, the factory serve flags, the precheck | row 230, C2-13a, I2 | landed |
+| the install as `mosaic`: bootstrap, business file, copy | row 226, C2-13b, I2, `scripts/case2-install.sh` | assigned to Gosalyn, briefed, not started |
+| `docs/guides/case1-install.md` | the host run sheet, plus section 6 of this file | |
+
+Other changes:
+
+- Claude moves under `/opt` (sage-1522, run sheet section 3). `--claude` is
+  `/opt/mosaic-stack/claude-<pin>/node_modules/@anthropic-ai/claude-code/bin/claude.exe`, root's, and root
+  installs and upgrades it. r6's `/srv/mosaic/.local/bin/claude` is gone. F6 reads the new path.
+- The args file is `/etc/mosaic-stack/dev.args` (run sheet section 7), not `case1-unit.args`. It holds
+  `--copy` too, and `stack-upgrade.sh` rewrites only that line, after confirm passes.
+- Both units are `WantedBy=multi-user.target` and start at boot (Q189, mos-1122). r6's "the Console has no
+  `[Install]`, root starts it by hand after a reboot" no longer holds.
+- The business id is stated, with the DEFERRED 240 N1 reasoning (sage-1809, sage-1813). Section 7.
+- The window can't run until row 226 lands. Sage added 226 to row 195's after list at rev 2718
+  (sage-1813). Section 6 lists what row 195 needs from 226's install.
+- The acceptance runs as root through ops-01, not as `localadmin`. `aa-status`, `sudo -l -U`,
+  `systemd-run --uid` and the hostcheck all need root. It gains four functional checks for items the run
+  sheet marks "precheck line missing" (F8-F11) and one host line (P11). Section 5.
+- The Discord row in section 2 changed. The precheck's "no Discord binding" line is C2-13b's and is
+  library-only, so for the factory it's F11 in the acceptance.
+
+What row 195 still builds: `scripts/case1-accept.sh` and its test (section 5). The rest of this file is
+inputs, the window order and the record the reviewer checks.
+
+## 0. What I checked on the host
+
+Read only, as `localadmin` over ssh, 2026-10-20 between 20:40Z and 21:51Z. Nothing in r7 touched .53
+(sage-1809). The window's first step re-reads these, since they can drift in a day: unattended-upgrades
+runs daily.
+
+| Item | 10.1.1.53 on 2026-10-20 | 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 | run sheet section 1 |
+| node | `/usr/local/bin/node` v22.22.2, root-owned | 24 or later, under `/opt` (run sheet section 2) |
+| claude | not on localadmin's PATH | under `/opt` (run sheet section 3) |
+| bwrap | absent; apt candidate `bubblewrap 0.9.0-1ubuntu0.3` | run sheet section 4 |
+| user namespaces | `kernel.apparmor_restrict_unprivileged_userns = 1`, apparmor 4.0.1, no bwrap profile loaded | run sheet section 4 |
+| profiles that name bwrap | none (`grep -rlw bwrap /etc/apparmor.d` exits 1) | hostcheck item 3 |
+| `fs.protected_hardlinks` | 1 | hostcheck item 6 |
+| `net.ipv4.ip_unprivileged_port_start` | 1024 | run sheet section 5 |
+| listeners below 1024 | 22 (sshd) and 53 (the resolver); 732 is free | the Console's port |
+| ports 7330-7333 | free | 7333 is the tester port |
+| `localadmin` | NOPASSWD sudo (#423 step 1, mos-1066, mos-1077) | ops-01's root path |
+| `jarvis` | groups sudo, docker, lxd, adm | #423 step 4 removes them (P5) |
+| unattended-upgrades | on, with the security pocket, which carries bubblewrap | the drift stop (row 240) |
+| journald | `SplitMode=uid` | the PM check reads `launches list`, not the journal (row 232) |
+
+## 1. The factory profile's values
+
+Instance `dev`, row 190's default (mos-1118 choice 4). `~` is `mosaic`'s home.
+
+| Input | Value | Who gives it |
+|---|---|---|
+| user | `mosaic`, primary group `mosaic` with no other member | fixed |
+| home | `/srv/mosaic`, 0700 | fixed |
+| config dir | `/srv/mosaic/.config/mosaic-dev` | row 190 |
+| data root | `/srv/mosaic/.mosaic-dev`, marker `{"instanceVersion":1,"name":"dev"}` | row 190 |
+| business | `mosaic-stack`, file `<configDir>/businesses/mosaic-stack.json` | fixed (section 7) |
+| profile | `factory` for `case2-install.sh`, `case2-unit.sh` and `case2-precheck.sh` | fixed |
+| roles | the factory set from `roles/`, with a chief that has a harness var | the go names the set (section 2) |
+| human id | Jason's, not `tester` (`broker.mjs:321`) | the go |
+| model credential | `<configDir>/secrets/claude-session.env`, `mosaic` 0600, one line `CLAUDE_CODE_OAUTH_TOKEN=...` | Jason places it (section 3) |
+| token slot path | none | section 2 |
+| node | `/opt/mosaic-stack/node-<v>/bin/node`, `<v>` 24 or later | the go names `<v>` and its sha256 |
+| claude | `/opt/mosaic-stack/claude-<pin>/node_modules/@anthropic-ai/claude-code/bin/claude.exe`, `<pin>` 2.1.304 unless the go names a newer one | the go |
+| PM | on (`--pm`) | fixed |
+| Console | `--port 732` on 127.0.0.1, with the unit's `CAP_NET_BIND_SERVICE` | fixed |
+| tester | `--tester-port 7333` on 127.0.0.1 (P10) | fixed |
+| board | none | fixed |
+| release | a git bundle of `refs/heads/refactor` and the 40-hex commit (run sheet section 6) | the go names both and the bundle's sha256 |
+
+The args file. `/etc/mosaic-stack/dev.args`, `root:root` 0644, one argument per line (run sheet section 7):
+
+```
+--profile
+factory
+--user
+mosaic
+--home
+/srv/mosaic
+--business
+mosaic-stack
+--copy
+<40-hex commit>
+--node
+/opt/mosaic-stack/node-<v>/bin/node
+--claude
+/opt/mosaic-stack/claude-<pin>/node_modules/@anthropic-ai/claude-code/bin/claude.exe
+--pm
+--
+--port
+732
+--business
+mosaic-stack
+--tester-port
+7333
+```
+
+`case2-unit.sh` takes exactly these before `--` (`scripts/case2-unit.sh:54`), and `stack-upgrade.sh`
+refuses `args-unreadable` on anything else (`scripts/stack-upgrade.sh:126-148`). The factory profile
+refuses the preview trio, `--send` and the proof pair (`case2-unit.sh:169`). .53 has no proxy, and Jason
+reaches the Console with `ssh -L` (sage-1451 Q3). Changing a serve flag is a re-install with its own go,
+not an upgrade.
+
+Why the port is 732 (r6, mos-1101 item 5). Role sessions share the host's network namespace
+(`packages/seat/src/sandbox.mjs:67`), so while the Console is down a session could bind a port above the
+floor and answer in its place. Below 1024 only the Console unit can bind, through its capability. The
+tester port can't go below 1024 (`packages/webui/src/cli.mjs:33`), so P10 records it.
+
+PATH for `mosaic`'s steps. `sudo -u mosaic -H` resets PATH to sudo's `secure_path`, which finds
+`/usr/local/bin/node`, v22. So every `mosaic` step runs as
+`sudo -u mosaic -H env PATH=/opt/mosaic-stack/node-<v>/bin:/usr/local/bin:/usr/bin:/bin ...`, the list
+`case2-unit.sh` renders as the units' PATH. `stack-upgrade.sh` builds it from the args file's `--node`.
+
+## 2. Where Case 1 differs from Case 2
+
+| Case 2 (library) | Case 1 (factory) | Reason |
+|---|---|---|
+| business file with the library mapping | `mosaic-stack` with no `library` key. The precheck refuses a library project under `factory` (`profile-library-business`, `case2-precheck.sh:127-128`) | the factory has no books repo |
+| `bean`, `chet`, persona vars and files, specialists | the factory roles from `roles/`, with a chief that has a harness var | the go names the set. I haven't read Jason's live business file and won't. The acceptance needs only the chief (F3); a chief with no harness var answers `no-route`. The human adds roles later 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) |
+| `bus.tester` off | on; the precheck refuses it off under `factory` (`case2-precheck.sh:135`) | the acceptance and the Q173 test system need the tester |
+| persona modes and digests, `library.sync`, `library.status` | skipped | no persona files, no library (C2-13b brief, `factory` profile) |
+| `ZAI_API_KEY` in `claude-session.env` | not checked; the file holds `CLAUDE_CODE_OAUTH_TOKEN` | no instance has provider `zai` (run sheet section 9) |
+| no Discord binding (C2-13b, library only) | none either. F11 checks that `<dataRoot>/discord/` holds no binding | the factory's connector stays on dragon-lin. Two connectors on one bot token would split its events |
+| the claude marker prompt | runs, since the chief's harness is claude-code | |
+| serve flags: preview trio, `--send`, proof pair | `--port 732`, `--business mosaic-stack`, `--tester-port 7333` | no proxy on .53 |
+| bus: no `--pm`, no `MOSAIC_CLAUDE_BIN` | `--pm`, and `Environment=MOSAIC_CLAUDE_BIN=<--claude>` | the PM dispatches the factory's work; without the path the bus finds no claude on the unit's PATH |
+| Console proof file (run sheet section 9, .54) | none | no proof pair |
+
+All of these are inputs to the landed scripts. Row 230 implemented the four factory items r6 asked for
+(serve flags, `--pm`, `--claude`, row 190's tokens), and nothing in them hardcodes a Case 1 value.
+
+## 3. Model access
+
+Q185: Case 1 uses the account the factory uses today, the Claude subscription behind dragon-lin's
+`claude-session.env`. No script copies that file and none reads its value. 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 (run sheet
+section 9). Nobody prints it. The check is `stat -c '%U %a %F' PATH` only (F8).
+
+The bus unit reads it through `EnvironmentFile=-` (`case2-unit.sh:243`). The leading `-` means a missing
+file doesn't stop the bus, so the chief's first launch would fail instead. The window places the file
+before the units start (section 6, W9), and the precheck's claude marker prompt then proves it works
+without printing it.
+
+Quota: the factory on dragon-lin and on .53 share one subscription. Q185's "use existing" accepts that.
+The pi harness stays off on .53 until P19 #383 settles (mos-0865). The business file names claude only.
+
+## 4. Upgrade, rollback and backup on .53
+
+All three are `scripts/stack-upgrade.sh` (row 233), run as root by ops-01 from `/root/mosaic-stack` at the
+reviewed commit. Usage, exits and the step log are in `docs/TOOLS.md`, "Root's upgrade driver", and run
+sheet section 6.
+
+| Action | Command | Who | Go |
+|---|---|---|---|
+| upgrade | `stack-upgrade.sh upgrade --instance dev --bundle /srv/mosaic/incoming/<sha>.bundle --sha <sha>` after run sheet section 6's per-upgrade lines | ops-01 | Mos per run; `--migrate` also needs Jason present (decision 96) |
+| rollback | `stack-upgrade.sh rollback --instance dev --to <copy> [--restore <ACT> [--events N]]` | ops-01 | Mos per run. Mos or Sage picks `<copy>` from `stack-release.sh status mosaic-stack --units external`, read as `mosaic`. The plan refuses unless it is the previous distinct copy |
+| backup of the store | A3's `backup_store` into `<dataRoot>/backups/stack/<ACT>`, inside every upgrade | the driver | the upgrade's |
+| rehearsal | `stack-release.sh rehearse` against the log's newest backup, before anything stops, on `--rehearse-port`, default 7339, which section 0 found free | the driver | the upgrade's |
+| backup of the VM | a PBS backup of VM 1008 before the install window and before any `--migrate` | ops-01 | the window's go (Q182, Q183: agents keep PBS) |
+
+Three .53 specifics:
+
+1. The first upgrade after install needs `--no-rehearsal` in its go. The install's adopt takes no backup,
+   so the log records none, the rehearsal exits 3 (`no-backup`), and the driver goes on only with the
+   flag (`stack-upgrade.sh:323-324`). Every later upgrade refuses the flag (`rehearsal-required`).
+2. Exit 5 (`args-failed`): the new stack is live and confirmed, but `dev.args` still names the old copy.
+   ops-01 moves the file the result line names into place with `mv -f`, and nothing else (run sheet
+   section 6).
+3. Exit 2 leaves both units stopped and the activation open. ops-01 sends Mos the exit and the last
+   lines of `/var/log/mosaic-stack/upgrade-dev.log`, and Jason or Mos settles it with `confirm` or `revert`
+   as on dragon-lin. A unit that doesn't stop within `--timeout` ends here on purpose (A2f's
+   `stale-start`, duckworth-0055 N1, now in run sheet section 6).
+
+The store backup doesn't hold the config dir or the credential. PBS backups of VM 1008 hold the whole disk,
+the credential included (P4). A restore swaps only the store and leaves `claude-session.env` in place.
+
+Re-install, for a serve flag or role change, is not an upgrade. It needs its own go and runs: stop the
+Console, then the bus; rewrite `dev.args` with the same `--copy`; `case2-unit.sh` with it; both units start
+again from the render. Row 230 N1 (webby-0046) holds here: a re-render with the units running leaves each on
+its old copy, so ops-01 stops both first. `stack-upgrade.sh` already stops both before it renders.
+
+## 5. Acceptance: `scripts/case1-accept.sh`
+
+New in this row. ops-01 runs it as root on .53, from `/root/mosaic-stack`:
+
+```
+case1-accept.sh --business mosaic-stack --args /etc/mosaic-stack/dev.args --claude-pin <pin> --node-pin <v>
+```
+
+It reads the user, home, node, claude and ports from the args file and refuses (exit 2) when that file
+fails `stack-upgrade.sh`'s rules. Every check inside the instance runs as
+`sudo -u mosaic -H env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin`. It changes nothing on the host
+except what F3's message writes to the store. It prints one line per check, `<id> <path> <mark>
+<evidence>`, then a count of each mark. Marks: `closed`, `accepted Q182`, `accepted Q183`, `accepted
+mos-1096`, `accepted mos-1101`, and `unnamed`, which means "not named in Q182, Q183 or a Mos ruling".
+It exits 1 when any F check fails and 0 otherwise. A P check never changes the exit. Each `unnamed`
+line goes to Mos, who takes it to Jason (R8 N1). Duckworth reads the whole output.
+
+It prints no value from `claude-session.env` and never opens it.
+
+Functional checks. Any failure fails the row:
+
+| Id | Check | How |
+|---|---|---|
+| F1 | the units run as `mosaic` | for `[email protected]` and `mosaic-webui.service`: active, `User=mosaic`, and the uid in `/proc/<MainPID>/status` is `mosaic`'s |
+| F2 | the Console answers on 127.0.0.1:732 only | `curl -fsS http://127.0.0.1:732/healthz` succeeds, and `ss -Hltnp` shows 732 bound to 127.0.0.1 only, by the Console's MainPID. Jason reaches it with `ssh -L 7332:127.0.0.1:732 [email protected]`. A LAN listener waits for Q175 SSO (sage-1451 Q3) |
+| F3 | one tester message gets a reply | as `mosaic`: `mosaic talk chief <marker> --business mosaic-stack --tester --wait 300`. A stored reply to the marked message passes. The inbox shows decisions only, so it isn't used |
+| F4 | the precheck passes | `case2-precheck.sh --business mosaic-stack --profile factory` as `mosaic` exits 0 |
+| 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 child. Its `/proc/<pid>/attr/current` equals `bwrap (enforce)` and the child's equals `bwrap//&unpriv_bwrap (enforce)`, exact strings after the trailing newline is cut |
+| F6 | claude is the pin | the args file's `--claude` path sits under `/opt/mosaic-stack/claude-<pin>/`, and its `--version` as `mosaic` prints `<pin> (Claude Code)` |
+| F7 | the PM run is live | `launches list --json` as `mosaic` has exactly one live entry for the PM's instance (`launch.by`), the check `confirm` runs |
+| F8 | the credential's file | `stat -c '%U %a %F'` on `claude-session.env` reads `mosaic 600 regular file`, and it isn't a symlink. Run sheet section 9 marks this "precheck line missing" |
+| F9 | the autoupdater is off | `/etc/claude-code/managed-settings.json` is `root:root` 0644 and its `env.DISABLE_AUTOUPDATER` is `"1"`. Run sheet section 3 marks this "precheck line missing" |
+| F10 | node is the pin | the args file's `--node` is `/opt/mosaic-stack/node-<v>/bin/node` with `<v>` the `--node-pin`, and its `--version` prints `<v>`. Run sheet section 2 marks this "precheck line missing" |
+| F11 | no Discord binding | `/srv/mosaic/.mosaic-dev/discord/` is absent or holds no `*.json` (section 2) |
+
+Host paths. These report and never fail the row:
+
+| Id | Path | Mark | Evidence |
+|---|---|---|---|
+| P1 | `mosaic` has sudo | closed only when `sudo -l -U mosaic` prints "is not allowed to run sudo"; 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 | `sudo -l -U localadmin` |
+| P4 | root on pve over VM 1008, and PBS backups that hold `/srv/mosaic` with the credential | accepted Q182 and Q183 | a fixed line; the script can't see pve |
+| P5 | `jarvis`, which runs Hermes, reaches `/srv/mosaic` through sudo, docker or lxd | closed when `jarvis` is in none of the three; unnamed otherwise. #423 step 4 removes all four groups before the install (mos-1091 4c) | `id jarvis` |
+| P6 | other members of sudo, docker, lxd | closed when sudo holds only `localadmin` and docker and lxd are empty; each other member is its own unnamed line | `getent group` lines |
+| P7 | a file under `/etc/sudoers.d` naming `mosaic` | closed when none | 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 eight hold, unnamed otherwise: hostcheck items 1 to 6, read from `/usr/local/lib/mosaic-stack/hostcheck.sh --check`'s own `ok N` lines (item 7 is P10's floor); `sudo -u jarvis /usr/bin/bwrap --version` fails with "Permission denied"; `getent group mosaic` lists no member and no other account has its gid. F5 adds the label of a real role session | the hostcheck lines and each item |
+| P10 | a session binds the tester port 7333 while the Console is down | accepted mos-1101 while the port floor is above 732 and 7333 is held by the Console's MainPID | the floor, the owner pid |
+| P11 | the boot check runs before the bus | closed when `mosaic-hostcheck.service` is enabled and `systemctl show -p Before` on it names `mosaic-bus@<business>.service` for the args file's business; unnamed otherwise (section 7) | the `Before=` value |
+
+P9 reads hostcheck's output, which root's own script prints, by matching `^ok [1-6] ` lines. It runs `--check` only,
+never `--enforce`, so the acceptance can't close bwrap.
+
+Tests, in `packages/cli/tests/case1-accept.test.mjs`. The script takes a test seam, `--root DIR`, for
+`/proc`, `/etc`, `/srv/mosaic` and `getent`, and refuses it when run as root, as the hostcheck does. Fake
+`systemctl`, `curl`, `ss`, `sudo`, `bwrap`, `sysctl`, `stat`, `claude`, `node` and `hostcheck.sh` on PATH.
+Nothing reaches .53 or dragon-lin's live state, and no test reads a real credential. Cases:
+- every check passing exits 0, with the counts matching the lines;
+- each F check failing alone exits 1 with its line;
+- F5 fails on `unpriv_bwrap (enforce)`, `bwrap//&unpriv_bwrap (complain)` and a trailing space;
+- F6 fails on a stub `claude.exe` that prints nothing and on a path outside `claude-<pin>`;
+- F8 fails on mode 0640, on another owner and on a symlink, and the stand-in credential's value never
+  appears in the output;
+- F11 fails on one `*.json` under `discord/`;
+- each P check in each of its marks: P1 with output that grants nothing but lacks the refusal text
+  (unnamed), P9 unnamed once for each item missing, P10 unnamed with the floor at 700 and with 7333 held
+  by another pid, P11 unnamed with `Before=` naming another business;
+- every P check `unnamed` still exits 0;
+- a bad args file refuses with exit 2 before any check;
+- every in-instance call goes through `sudo -u mosaic -H env PATH=<node dir>:...`, read from the fake
+  `sudo`'s recorded argv;
+- the hostcheck fake records `--check` and never `--enforce`.
+
+Mutants, each killed by a named case:
+1. F1 passes on a MainPID owned by root.
+2. F2 accepts a listener on 0.0.0.0.
+3. F3 passes without a reply.
+4. F5 matches a substring.
+5. F6 skips the `--version` check.
+6. F8 skips the owner check.
+7. F11 ignores `discord/`.
+8. P1 closes on any output.
+9. P5 maps to `closed` with `jarvis` in docker.
+10. P9 drops the jarvis item.
+11. P11 accepts any `Before=`.
+12. A P check's `unnamed` sets the exit to 1.
+
+## 6. The .53 window
+
+Nothing in this row touches .53 (sage-1809). Every root step below is ops-01's, over
+`ssh [email protected]` with `sudo`, and waits on a Jason decision (mos-1086). The window needs:
+- row 226 landed;
+- Jason's or Mos's go naming the commit, the bundle's sha256, the node and claude pins, the role set and
+  Jason's human id;
+- a backup first;
+- a STATE report after.
+
+| # | Step | Runs as | Source |
+|---|---|---|---|
+| W0 | re-read section 0's items; stop on any change and report it | `localadmin`, read only | section 0 |
+| W1 | PBS backup of VM 1008 | ops-01 on pve | section 4 |
+| W2 | the stack's user and home | root | run sheet 1 |
+| W3 | node under `/opt` | root | run sheet 2 |
+| W4 | claude under `/opt`, managed settings | root | run sheet 3 |
+| W5 | bubblewrap, the profile, the statoverride, the no-new-privs test, the drift stop; `hostcheck.sh --check` exits 0 with item 7 at 1023 | root | run sheet 4 |
+| W6 | the port floor (read) | root | run sheet 5 |
+| W7 | the bundle, root's checkout at `<sha>`, `mosaic`'s clone | root, then `sudo -u mosaic -H` | run sheet 6 |
+| W8 | `case2-install.sh --profile factory` with section 1's inputs: bootstrap, the business file, roles, human id, the copy | `sudo -u mosaic -H env PATH=...` | row 226 |
+| W9 | place `claude-session.env` | Jason, or who he names | run sheet 9, section 3 |
+| W10 | write `dev.args` (section 1); `case2-unit.sh` from it, which enables both units and starts the bus, then the Console | root | run sheet 7, 10 |
+| W11 | `case2-precheck.sh --business mosaic-stack --profile factory` exits 0; `hostcheck.sh --check` exits 0 with item 7 at 732 | `mosaic`; root | row 230, 240 |
+| W12 | `stack-release.sh adopt mosaic-stack --units external`, unless row 226's install does it | `sudo -u mosaic -H` | row 232 |
+| W13 | `case1-accept.sh` (section 5); the output to Duckworth, then Mos confirms | root | this row |
+| W14 | STATE report to Mos | ops-01 | brief |
+
+Install rollback, any step before W13 passes. Stop and disable both units, remove their files and
+`dev.args`, then the run sheet's rollbacks for sections 4, 3 and 2 in that order. Removing the user and
+home (`userdel -r mosaic`) needs its own Mos go, since it deletes the home. W1's backup covers the rest.
+
+What row 195 needs from row 226. Row 226 is assigned to Gosalyn, briefed and not started, so I'm listing what the window
+needs from its design, not designing it:
+
+1. `--profile factory` writes the business file with `bus.tester` on and no `library` key, and the roles
+   the go names.
+2. It writes no token slot and no persona files (its brief says so).
+3. It runs before the unit render, since the copy must exist for `case2-unit.sh --copy`, and it starts no
+   unit.
+4. Who writes `dev.args`. The C2-13b brief says the install doesn't write unit files, and the run sheet
+   says "I2's install writes it". `mosaic` can't write `/etc/mosaic-stack`. So either root's part of I2
+   writes it, or ops-01 writes it from section 1 at W10. Either works for row 195. The file's content is
+   fixed above.
+5. Whether it runs `adopt`. If it doesn't, W12 does.
+
+I sent these to Gosalyn on 2026-10-21 (gosalyn-0085 acknowledged), and the run sheet takes whichever answer 226 gives.
+
+## 7. The business id
+
+.53's business id is `mosaic-stack` (sage-1813). It appears in:
+- the args file, twice;
+- the bus unit `[email protected]`;
+- the business file name;
+- `case1-accept.sh --business`.
+
+The landed boot unit `packages/cli/systemd/mosaic-hostcheck.service` has
+`[email protected]`. So at boot the drift stop runs before .53's bus, and DEFERRED 240
+N1 (da3051ccc: `After=mosaic-hostcheck.service` in `mosaic-bus.service.in`) doesn't bind this row.
+
+If a go ever names another id for .53, the window stops before W8, and the N1 fix lands first as its own
+reviewed row. P11 is the check on the host. It reads `unnamed` when the boot unit's `Before=` doesn't
+name the installed bus.
+
+DEFERRED 240 N2 (the apt hook goes in before the first `--check`) is a run sheet order note. This row
+doesn't edit the run sheet, so it stays deferred.
+
+## 8. Rulings this design rests on
+
+- sage-1451: Q1 system units; Q3 the Console on 127.0.0.1 with `ssh -L`; Q4 a rebase goes to a new branch
+  name (#426(a), mos-1086).
+- mos-1091, mos-1096, mos-1098, mos-1101: the bwrap path, its profile and P9; the port squat and P10; .53
+  runs the PM. Their r6 sections stand, and rows 232, 233, 240 and 230 implemented them.
+- mos-1108 (Q187) and mos-1118: the installer rows and the scope cut. mos-1122 (Q189): both units start at
+  boot.
+- sage-1522: claude under `/opt`, root-owned.
+- sage-1809: no step on .53, root steps named and left to ops-01, the business id stated.
+- sage-1813: 226 in the after list (rev 2718); the id is `mosaic-stack` and 240 N1 doesn't apply.
+- Q185: the factory's model account. Q173: credentials placed by Jason or his named person.
+
+## 9. Manifest (planned)
+
+- `scripts/case1-accept.sh` (new), mode 100755.
+- `packages/cli/tests/case1-accept.test.mjs` (new). Section 5's cases and mutants.
+- `docs/TOOLS.md`: a `case1-accept.sh` entry with usage, marks and exits, beside the hostcheck entry.
+- `agents/darkwing/work/queue-195/BUILD.md` (new): run environment, the mutant results, deviations.
+- No change to `case2-*.sh`, `stack-upgrade.sh`, `stack-release.sh`, `case1-hostcheck.sh` or the run
+  sheet. Two follow-ups stay out of this row:
+  - row 230 r2 N1. The "still on copy" line reads the id from the unit file. On .53 neither the install
+    nor `stack-upgrade.sh` reaches that line, since both start from stopped units.
+  - DEFERRED 240 N2.
+- No change to `~/.mosaic-dev`, `~/.config/mosaic-dev`, dragon-lin's units or `~/.mosaic`.
+
+Gate: Duckworth approves this design, then the manifest; the cli suite and every `scripts/test-*.sh`
+green on Sage's gate; section 5's twelve mutants killed in a slot Sage grants.
@@ -0,0 +1,64 @@
+# Row 195 follow-up: Duckworth's N1-N3 on `scripts/case1-accept.sh`
+
+Duckworth approved row 195's manifest round 1 (duckworth-0088, `agents/duckworth/work/row195/REVIEW-m1.md`
+at 6afcee2a5) with three notes that don't block. Sage asked for this follow-up in sage-1876 and opens the
+row after 195 lands. The branch is `darkwing/row195-n1`, on 37171f65b.
+
+## What changes
+
+N1. F9 ran `$ROOT$NODE` as root (`case1-accept.sh:298` at 37171f65b) before F10 checked that `--node` is
+the pinned path. Duckworth offered two fixes: F9's parse through `AS_USER`, or F10's path check first. I
+took the path check, plus one more:
+- F9 now runs node only when `--node` equals `/opt/mosaic-stack/node-<--node-pin>/bin/node`.
+- Then `not_root_only` walks from that file up to `/`. Each entry must be the running user's (root's on the
+  host) with no group or other write, the rule `case2-unit.sh` `root_only` applied when it rendered the
+  units. A symlink fails it, because its mode is 777. The first entry that breaks the rule goes in the
+  evidence.
+
+I didn't run the parse through `AS_USER`. That would hand a check about a root file to the stack's user,
+and a process running as `mosaic` could change what that node prints. Rechecking ownership costs one
+loop and doesn't depend on how the host was installed.
+
+N2. The header (:9-15) and the `docs/TOOLS.md` entry now list what root runs: `systemctl show` and
+`is-enabled` (F1, P11), `curl` on the loopback healthz (F2), `sudo -l` (P1, P3), `sudo -u jarvis bwrap
+--version` and `hostcheck.sh --check` (P9), and node for F9 under the rule above.
+
+N3. F6 matched `--claude` by prefix, so `/opt/mosaic-stack/claude-<pin>/../claude-2.0.9/...` passed the
+path check. F6 now fails on any `..` segment, before it runs `--version`. F10 compares for equality, so
+it needed no change.
+
+BUILD.md gets a correction entry for deviation 6. DESIGN.md is unchanged. Gosalyn's Q4 answer makes the
+"either works" wording at `DESIGN.md:336-338` stale, but an approved design changes only with Sage's
+authorization, so it's left for Sage to rule on.
+
+## Tests
+
+`packages/cli/tests/case1-accept.test.mjs`:
+- The node stub touches `node-as-root` in the state directory when something runs it outside the fake
+  `sudo` (which sets HOME to the stack's home). `host()` sets the node file's directories and the scratch
+  root to 0755, so the umask can't fail F9.
+- "every check passing" also asserts that root ran the pinned node.
+- New: "F9 won't run --node as root off the pin path or with a writable directory above it". Another node
+  path fails F9 and F10, with no root run. A group-writable `bin/` and a symlinked node each fail F9
+  alone, with the bad path in the evidence and no root run.
+- The F6 test gains a `..` case: a path under `claude-<pin>/` by prefix that names 2.0.9's binary, which
+  prints the pin. F6 alone fails, with "has a .. segment".
+
+That makes 23 tests. None has run. Every run waits for Sage's grant.
+
+## Mutants
+
+The twelve from row 195 still apply, unchanged. These four are new, each one exact replacement:
+
+| # | Mutant | Expected killer |
+|---|---|---|
+| 13 | F9 runs any `--node` (the pin check becomes `true`) | F9 won't run (another node) |
+| 14 | F9 skips the ownership walk (`bad=""`) | F9 won't run (writable `bin/`, symlink) |
+| 15 | `not_root_only` checks only the file, not the directories above it | F9 won't run (writable `bin/`) |
+| 16 | F6 accepts a `..` segment | F6 stub, path and `..` |
+
+## Slot plan
+
+Same shape as row 195's steps, on the follow-up's tip: the single test file, then the sixteen mutants,
+then the gate (the cli suite and every `scripts/test-*.sh`), each behind the busy checks and chained
+with `&&`. The scripts are ready in `/mnt/storage/scratch/darkwing-195n-out/`.
@@ -0,0 +1,173 @@
+# Row 240 (I4): root's host check, its pins and the boot unit
+
+Brief: `docs/plans/2026-10-20_installer-rows.md` section I4, blob `4a5a65020f00` (commit b00d7d94d, rev 2665,
+the pin row 240 carries; the I3 carry items came in with it). Sage split it out of I3 (sage-1650). Gitea #1746, Vikunja P19 #432. Owner Darkwing, reviewer Filbert, gate owner Sage.
+Design: row 195 DESIGN r6 B2, `agents/darkwing/work/queue-195/DESIGN.md` at b7239bb66, :262-303 (the script,
+the three callers) and :839-860 (files, test cases, mutants). Where the brief and r6 differ, the brief wins.
+
+## Files
+
+Drafted on `darkwing/row240-r1` from d99166ade (row 233's candidate) while row 233's gate ran, then applied
+as one patch onto row 233's landing, 57f59e0c3, on `darkwing/row240-r2` (sage-1753). It applied cleanly; between
+the two bases the only change on this row's paths is 233's N1 test fix in `stack-upgrade.test.mjs`. Row 234
+then landed as c771a36f4 on 57f59e0c3. Sage preferred that the gate run with it in the tree (sage-1773), so both
+commits were picked onto c771a36f4 as `darkwing/row240-r3`. That was a clean pick: the 42 paths changed from
+57f59e0c3 to c771a36f4 share none with this row's 9.
+
+- `scripts/case1-pins.sh` (new, 0644): `PIN_PROFILES_VERSION`, `PIN_PROFILE_SHA256`, `PIN_BUBBLEWRAP_VERSION`,
+  r6 section 0's values.
+- `scripts/case1-hostcheck.sh` (new, 0755): the seven items and `--check`, `--enforce`, `--upstream`.
+- `packages/cli/systemd/mosaic-hostcheck.service` (new): the boot oneshot.
+- `packages/cli/tests/case1-hostcheck.test.mjs` (new, 16 tests). The cli suite's `tests/*.test.mjs` glob picks
+  it up.
+- `docs/guides/host-run-sheet.md` section 4: the install lines that replace "Install them from row 240's run
+  sheet lines once it lands", plus rollback, drift recovery and `--upstream` before a re-pin window. Sections
+  3, 6, 8 and 10 for the I3 carry items below.
+- `scripts/stack-upgrade.sh` and `packages/cli/tests/stack-upgrade.test.mjs`: I3 N1 below.
+- `docs/TOOLS.md`: a new subsection "Root's host check (`scripts/case1-hostcheck.sh`, row 240)" after the
+  upgrade driver's.
+
+Brief line 257 said I3's `stack-upgrade.sh` doesn't change. Sage's ruling sage-1727 widened the row to it for
+N1 alone. Its default `STACK_UPGRADE_HOSTCHECK=/usr/local/lib/mosaic-stack/hostcheck.sh` is where the run
+sheet installs this script.
+
+## Carried from I3
+
+Filbert's row 233 approve (Gitea 29922) left five notes. Sage ruled N1, N4 and N5 into this row and N2 and N3
+to DEFERRED.md (sage-1727).
+
+| Note | Change |
+|---|---|
+| N1: `stack-upgrade.sh` exits 1 `args-failed` when the args move after A5 fails, but exit 1 means the old copy runs | The move's failure exits 5 `args-failed`. The header, TOOLS.md's step 5 and exit line, and run sheet section 6's exit list name exit 5 and what root does: move the new file the result line names into place. Test `row 240: I3 N1: a failed args move after A5 exits 5 ...` makes `/etc/mosaic-stack` read-only at confirm and checks exit 5, the step names, `args rc=1`, the result line, both units on the new copy, the old args file's bytes and the new file beside it. The step log regex takes `exit=5`. Mutant M8. |
+| N4: section 3's `npm install` has no npm on root's PATH, and the `--claude` path is unnamed while `node_modules/.bin/claude` is a symlink `case2-unit.sh:140` refuses | The install line runs with section 2's pinned node first on PATH (the postinstall runs `node` too). The `--claude` path is `node_modules/@anthropic-ai/claude-code/bin/claude.exe`, and a `--version` line catches the postinstall's 500-byte stub. |
+| N5: sections 8 and 10 lack precheck lines | Each gets "Precheck line: none" and its missing line. |
+
+Exit 5 is new rather than 2 because 2 means both units are stopped, and here both run. Exit 4 stays usage.
+
+The `claude.exe` path comes from the 2.1.304 package itself: `npm view` gives `bin.claude` as `bin/claude.exe`,
+and its `install.cjs` hardlinks the platform binary over that placeholder, or copies it across devices, then
+sets 0755. I downloaded the tarball into `/mnt/storage/scratch/tmp/r240/cc304` and read it; nothing ran. The
+run sheet says a newer pin needs the same check.
+
+## The brief, item by item
+
+| Brief line | Where |
+|---|---|
+| 247 `case1-pins.sh` holds the three pins | `scripts/case1-pins.sh`; the pins test checks the values against r6's |
+| 248-249 seven items, `--check` exits 0 or 1 | `items()` and the final dispatch; the check tests |
+| 250-251 `--enforce`: `apparmor_parser -R`, `root:root 0700`, `DRIFT`, a log line, exit 0 | `enforce()` and `stop_bwrap()`; the four enforce tests |
+| 252 `--upstream` compares the current deb to the pin | `upstream()`; the upstream test |
+| 253 the boot oneshot | `mosaic-hostcheck.service`; the boot unit test |
+| 254-255 fakes for every host tool, r6's seven case groups, seven mutants | the test file; Tests and Mutants below |
+| 257 the I3 run sheet item points here | run sheet section 4 |
+
+## Tests
+
+Fakes on PATH, each logging its argv to `$HC/calls.log`: `aa-status`, `dpkg`, `dpkg-statoverride`,
+`apparmor_parser`, `systemd-run`, `stat`, `chown`, `chmod`, `apt-get`, `dpkg-deb`. `host(t)` builds a scratch
+root (`/etc`, `/proc/sys`, `/usr/bin/bwrap`, `/var/log`) and a lib dir with a copy of the script and fixture
+pins that hold the fixture profile's sha256. Every run passes `--root`.
+
+r6's case groups (:843-856) against the tests:
+
+| r6 case | Tests |
+|---|---|
+| `--check` exits 0 with all seven, 1 with each failing alone, its line naming it | `check: exits 0 ...`, `check: exits 1 with each item failing alone ...`, plus one test per item for the item's edge cases |
+| item 3: a second file naming `bwrap` as a word, `/{usr/,}bin/bwrap` included; passes with the profile alone | `check: item 3 ...` |
+| item 4: `unpriv_bwrap (enforce)` or a trailing space fails; the argv carries `-p NoNewPrivileges=yes` and the 2a' properties | `check: item 4 ...` checks the whole argv |
+| item 7: the floor at 732 fails | `check: item 6 ...; item 7 ...` (733 passes as the control) |
+| `--enforce` exits 0 on a pass and every failure; unload, close, `DRIFT`, one log line; `DRIFT` present with every item passing still closes | `enforce: a pass ...`, `enforce: each failure ...`, `enforce: with DRIFT present ...` |
+| `--enforce` never calls `dpkg-statoverride` with `--update`, `--add` or `--remove` | `enforce: no unload ...; never writes the statoverride` (every call is `--list /usr/bin/bwrap`) |
+| a bubblewrap version other than the pin is a line, not a failure | `check: a bubblewrap version other than the install pin ...` |
+| `--upstream` against a differing deb prints the difference, exits 0 | `upstream: ...` (also: a match, a deb with no profile, a failed download) |
+| the unit: `Type=oneshot`, `After=apparmor.service`, `[email protected]`, runs `--enforce` | `boot unit: ...` |
+
+The last test also checks that the repo script reads `scripts/case1-pins.sh` beside it, that bad usage exits
+2, and that a non-root run without `--root` refuses.
+
+Singles are the two files that run a changed script: `case1-hostcheck.test.mjs` and `stack-upgrade.test.mjs`.
+Sage asked (sage-1759) whether `stack-release.test.mjs` or `stack-release-external.test.mjs`, which share
+`stack-release-fixture.mjs`, run `stack-upgrade.sh` or `case1-pins.sh`. They don't. `grep -cF` for
+`stack-upgrade`, `case1-pins`, `case1-hostcheck` and `hostcheck` gives 0 in all three files; the control
+`stack-release.sh` gives 2 in the fixture and 8 in `stack-release.test.mjs`. `scripts/stack-release.sh` names
+`stack-upgrade.sh` once, in a comment (:2061). The gate's cli suite runs both files anyway.
+
+## Mutants
+
+r6's seven (:858-860) and one for I3 N1, scripted in `~/darkwing-scratch/r240/mutants.sh` with r233's method: a checked backup,
+an exact replacement that must match once, `bash -n`, the named killer by `--test-name-pattern`, the restore
+and a sha256 check. A dry run matched all eight once each. Results below.
+
+| Mutant | Change | Killer |
+|---|---|---|
+| M1 | `--enforce` exits 1 after the stop | `enforce: each failure exits 0 ...` |
+| M2 | `[ ! -e "$DRIFT" ] \|\| had=1` becomes `true \|\| had=1` | `enforce: with DRIFT present ...` |
+| M3 | item 1's `dpkg -S` becomes `owner=""; rc=1` | `check: item 1 fails when a package owns ...` |
+| M4 | item 3's `grep -rlw bwrap` becomes `grep -rlF /usr/bin/bwrap` | `check: item 3 ...` |
+| M5 | item 4's `[ "$label" = "$LABEL" ]` becomes a substring match | `check: item 4 ...` |
+| M6 | item 4 drops `-p NoNewPrivileges=yes` | `check: item 4 ...` (argv) |
+| M7 | item 7's `-gt` becomes `-ge` | `check: item 6 ...; item 7 fails with the floor at 732 ...` |
+| M8 | `stack-upgrade.sh`'s `finish 5 args-failed` becomes `finish 1 args-failed` (I3 N1) | `row 240: I3 N1: a failed args move ...` |
+
+## Deviations
+
+- Repo name `scripts/case1-hostcheck.sh` (r6), installed as `/usr/local/lib/mosaic-stack/hostcheck.sh`, the
+  name in brief line 239 and I3's `stack-upgrade.sh` default. r6's apt hook line says `case1-hostcheck.sh`;
+  the run sheet's hook uses the installed name.
+- `stat` is a fake too. r6 lists seven fakes; a test can't make a root-owned file, so item 5's `stat` reads a
+  fixture.
+- Item 7 with no Console unit installed reads the port as 1023 and says so ("1023, because no Console unit
+  is installed"). Until I2 installs the unit the floor must be above 1023. A unit with no `--port` fails.
+- Item 4 runs under `timeout 60`. A hung `systemd-run` would otherwise hang the apt hook and the boot unit.
+
+## Decisions
+
+- Fail closed where r6 is silent:
+  - pins with no 64-hex sha fail item 1;
+  - `dpkg -S` exit 1 (no owner) passes, exit 0 fails with the owner, any other exit fails with the code;
+  - a failed `aa-status` fails item 2 and counts as loaded, so `--enforce` tries the unload.
+- `--root DIR` is the test seam (r6 :840). Root refuses it; a non-root user needs it. Both exit 2. Root runs
+  with `PATH=/usr/sbin:/usr/bin:/sbin:/bin`.
+- `DRIFT` is append-only (`<stamp> <failed line>`), and `--enforce` never removes it. The log line is written
+  only when the stop runs: `<stamp> enforce stop items=<ids or none> drift-before=<0|1> unload=<rc=N|no-file|skipped> chown=N chmod=N`.
+- `--upstream` exits 1 when the download or the unpack fails, since it then compared nothing. A deb without
+  the profile file is a difference (exit 0), per r6 :302-303.
+- The bubblewrap note reads the version from `dpkg -s bubblewrap`.
+- The run sheet's recovery steps (`chown root:mosaic`, `chmod 0750`, `apparmor_parser -r`, then `--check`
+  before root removes `DRIFT`) are mine. r6 says only that root removes `DRIFT` in a reviewed step.
+
+## Run environment
+
+Worktree `/mnt/storage/scratch/darkwing-r240b`, branch `darkwing/row240-r3` on c771a36f4, with `node_modules`
+linked to the canonical checkout's. Node v26.8.1, kernel 7.2.2-1-cachyos, 16 CPUs, TMPDIR
+`/mnt/storage/scratch/tmp/r240`, compose project `darkwing-r240b`. Sage's slot (sage-1773, 06:16Z). Each run is
+one chain behind `busy.sh`, launched from `/`: `~/darkwing-scratch/r240/run-all.sh` checks the HEAD pin and a
+clean tree, runs the singles, then the mutants (8 killed, none surviving, the tree clean after), then the gate
+(the cli suite and every `scripts/test-*.sh`), each stopping the chain on failure, then sweeps `/proc` cwd links
+for anything left in the r240 trees.
+
+## Results
+
+Run r1, 06:17:10Z on 47ec9fe2f, failed at the singles. `case1-hostcheck.test.mjs` passed 16/0/0, and
+`stack-upgrade.test.mjs` went 20 pass, 1 fail. The failure was the N1 test's own `t.after` hook, which ran
+`chmodSync(e.etc, 0o755)` after the fixture's cleanup had already removed the scratch root, so it threw ENOENT.
+Every assertion in the test body had passed, exit 5 included. The fixture's cleanup runs `chmod -R u+w` on the
+root before `rmSync`, so the 0555 dir never needed the hook. b45852daa drops it and changes nothing else. The
+mutants and the gate didn't run. The sweep found nothing left. Sage counted r1 as this slot's one failure
+(sage-1788).
+
+Run r2, 06:20:41Z to 06:33:28Z on b45852daa, passed. The counts come from awk over the .out files
+(`~/darkwing-scratch/r233/sum.sh`):
+
+| Step | Result |
+|---|---|
+| `case1-hostcheck.test.mjs` | 16/0/0 |
+| `stack-upgrade.test.mjs` | 21/0/0 |
+| c0 control | exit 0 |
+| M1-M8 | 8/8 killed, none survived, every restore's sha256 matched, tree clean after |
+| `packages/cli` suite | 639/0/0 |
+| `scripts/test-*.sh` | auth 15, conductor 17, config 31, discord 78, extension-package 18, foundation 44, land-work 86, queue 156 node + 28 selftest, release 14, task 98; 585 pass, 0 fail |
+| Gate total | 11 suites, 1224 pass, 0 fail |
+| Sweep | nothing left in the r240 trees; the compose network was removed |
+
+This commit adds only these BUILD.md lines. No test reads BUILD.md.
@@ -20,12 +20,12 @@ so Mos doesn't check this draft. Draft 1 names NEW and goes to Mos for the P0 ch

 - OLD, live: `4429a104f6d65ccf165f6c83b5d1dce3147dfde0`, schema 3i, pointer `pm: true` (record 99a406ed3).
  P1 re-reads the activation id and the Console flags from `status`. I don't copy them from the last window.
- NEW: open. It's the row 234 landing, or a later code landing if Mos rules. Candidates in landing order:
-  194, 234 (210, 237, 232, 241 and 242 have landed).
+- NEW: `c771a36f4bd0b6c359282425c668996a90072f93`, the row 234 landing (2026-10-21 06:16Z), unless Mos rules a
+  later code landing. 194 is the open candidate. 210, 237, 232, 241, 242, 233 and 234 have landed.
 - REPO, `P`, `WIN=agents/sage/work/window-repin-<NEW12>/`, `SNAP`: as in `repin-4429a104f.md`, with the
  sha checks at P0 and before S1, S2 and any D3.

-## What NEW carries over OLD (so far, refactor 04ce8dfd5)
+## What NEW carries over OLD (refactor c771a36f4)

 `git log --first-parent 4429a104f..HEAD`, path-limited to packages, scripts, roles, contracts, adapters, skills
 and the package files:
@@ -44,7 +44,8 @@ and the package files:
 | 232 | e65a3ab4d | Installer I1: `stack-release.sh --units external` and `stack-copy.sh copy --bundle`, `wrapper --create`. Both are opt-in, and this window uses neither. The default units path must render the same units, so the P2 unit diff covers it with row 190. P0 checks that no window command line carries `--units external`. |
 | 241 | 5d4a61776 | Test only (bus land.test.mjs). No live effect. |
 | 242 | 5fb736b92 | Bus publish hold: after publish-timeout the bus holds the decision until its push ends, then records a late push. The live business has no publish in flight at W1, and P3 shows none open. Its follow-up fc1cb856b is comments only (git-socket.mjs). |
-| 234 | open | Machine grant row a and the 3i to 3j schema step. `--plan` must say `migration: 3i -> 3j`. |
+| 233 | 57f59e0c3 | Installer I3: new tool `scripts/stack-upgrade.sh` and a `stack-release.sh` change. This window doesn't run `stack-upgrade.sh`. The P2 unit diff covers the `stack-release.sh` change with rows 190 and 232. |
+| 234 | c771a36f4 | Machine grant row a and the 3i to 3j schema step (new tables `hosts` and `host_grants`). `--plan` must say `migration: 3i -> 3j`. |
 | PRD 1.7+1.8 | 0adf8ddfe | `docs/prd/mosaic-stack.md` and `packages/tasks/requirements.json` move to version 1.8 (mos-1154, mos-1156, DECISIONS Q192). The live pm cites 1.6 until this window. Check after: the pm's requirements read answers version 1.8. |

 Service script drift OLD to HEAD is 415+/91- over the four scripts, mostly row 190. P5 holds them at NEW.
@@ -56,7 +57,8 @@ Service script drift OLD to HEAD is 415+/91- over the four scripts, mostly row 1
 - W0b: the business file copy, as in the last window.
 - Rollback after a migration isn't the plain rollback. OLD is 3i and the store is 3j, so going back needs
  `--restore <W5 activation>`, and that loses the events written after W5. The row 181 restore guard counts
-  11 tables, and the untimed ones need the D3 snapshot. Mos decides any restore past W5, as before.
+  11 tables, and the untimed ones need the D3 snapshot. Row 234 adds `hosts` and `host_grants` to the untimed
+  list (T46), so at 3j the D3 snapshot covers them too. Draft 1 recounts the list from NEW. Mos decides any restore past W5, as before.
 - Grant look-alikes (row 234 A22b, gizmoduck-0107). `3i-3j.sql` adds `events_grant_actor` but doesn't check
  rows already in the store, so after the migration only the actor filter in `GRANT_EVIDENCE` (actor_role NULL,
  actor_run 'grant') ignores an old session-written row. P3, and again just before `--migrate`: on the
@@ -74,8 +76,11 @@ history unless the window fails.

 ## Open before draft 1

- Q1: NEW, once 234 lands. Do 194 and 237 go in if they land first? I recommend yes for 237 (small, bus
-  only) and asking Mos about 194, since 194 changes the lifecycle verbs and roles/chief-of-staff.*.
+- Q1, ruled by mos-1161: draft 1 doesn't wait for 194. NEW is the latest code landing when I cut draft 1. If
+  194 has landed with a green full gate (15 packages, ten script suites), NEW is the 194 landing and P3 also runs
+  the lifecycle verbs once on the backup copy and gets one pm reply under the new roles/chief-of-staff files. A
+  P3 failure that traces to 194 drops NEW back to c771a36f4 before anything touches live, and the window goes on.
+  Otherwise NEW is c771a36f4 and 194 rides a later window.
 - Q2, settled by mos-1148: phase 2 is its own window on 10-23. Draft 1 takes OLD and the Console flags,
  `--sso` included, from `status` after that window.
 - Q3: who operates. If Darkwing is free, Darkwing operates and I check. Otherwise I operate as in the last
@@ -1399,3 +1399,8 @@ are never rewritten or removed; corrections are new entries.
 2026-10-21T04:50:44Z | Darkwing (Opus 5.5, 7525c8e4) | row 233 I3 gate, mutants and review request (sage-1704, sage-1707, sage-1708) | gate green on d99166ade (1201/0, cli 616/0) and m1-m8 8/8 killed; N1 flock-holder orphan fixed test-only in 08db6ac3f, rerun c0 20/0 + m1 killed, sweep 0 left; in review round 1, manifest 464ce9eb at 1a1dc80ca on darkwing/row233-r1, comment 29901, revs 2644 and 2647 (lock race resolved); Filbert woken
 2026-10-21T04:58:01Z | Filbert (Opus 5.5, 048f3c63) | row 233 (I3, #1735) review round 1 on manifest 464ce9eb177a (1a1dc80ca) | APPROVE, Gitea 29922, rev 2659 (left for Sage); static, no slot; 5 non-blocking notes N1-N5 (args-failed exit 1, REPO ownership, signals, run sheet npm/claude path, sections 8/10 precheck)
 2026-10-21T05:47:45Z | Sage (Opus 5.5, 1ef1e4f8) | rows 233+234 landing gate, row 233 landing, 240 brief, drift sweep (sage-1742..1758) | combined gate stopped on two row 234 failures (bus schema.test.mjs:522 counts, cli stack-release T46 restore-guard lists; mos-0823); 233 landed alone 57f59e0c3 (patch-id b16ac924, verify-commit ok, cli 617/0, scripts 585/0), pushed with b00d7d94d, 5465fd52d and riders 642a9b87d, 16019b80e; #1735 closed 29931, done rev 2675, Vikunja 432 comment 436; 240 briefed rev 2676; 234 r3 c783d5e39 rebuilt on the landing in Gizmoduck's slot; 197 and 238 drifted, rebase sent (sage-1754, 1755, 1757 stash fix)
+2026-10-21T06:20:30Z | Sage (Opus 5.5, 1ef1e4f8) | row 234 r3 landing gate (2890/0 packages, 585/0 scripts) and landing c771a36f4, pushed 06:16Z; #1740 closed 29938, Vikunja 436 c437; 235 briefed rev 2686, rotateBy ruling; 238/228/197 rebuilt on 234, slot order Darkwing 240 then 238, 228, 197; 10-24 draft NEW c771a36f4 (sage-1766..1787) | landed
+2026-10-21T06:37:41Z | Darkwing (Opus 5.5, 7525c8e4) | row 240 I4 build, slot run and review request (sage-1759, sage-1773, sage-1788, sage-1795) | r1 on 47ec9fe2f stopped at singles (stack-upgrade 20/1: the N1 test's own after hook threw ENOENT once the fixture removed the root), b45852daa drops it; r2 green: singles 37/0, M1-M8 8/8 killed, cli 639/0, scripts 585/0; darkwing/row240-r3 pushed at ad1b23ab2 on c771a36f4, manifest 573ece95 (9 paths), in-review revs 2694 and 2695, request comment 29943 on #1746, Filbert woken | in review
+2026-10-21T06:41:13Z | Filbert (Opus 5.5, 048f3c63) | row 240 (I4, #1746) round 1 review on manifest 573ece95 (ad1b23ab2) | approve, Gitea 29945, rev 2696; 233 carries N1/N4/N5 present; notes N1 boot unit Before= names one business, N2 doc-only, N3 info
+2026-10-21T07:15:48Z | Darkwing (Opus 5.5, 7525c8e4) | row 195 (#1693) DESIGN r7, Case 1 install on .53 after the installer split | darkwing/row195-r7 5425ea2f3 pushed (r6 carried as 7398b7dd7 on c515273db), DESIGN.md blob 17dfbad95ba5; business id mosaic-stack named in §7, so DEFERRED 240 N1 doesn't apply (sage-1813); root steps left to ops-01, nothing run on .53 (sage-1809); Duckworth review requested 07:14Z, Gitea 29960; row 226 items (dev.args writer, adopt) sent to Gosalyn and copied to Sage per sage-1814; r7 :21 and :326 still say 226 is unclaimed, to fix next revision
+2026-10-21T07:29:11Z | Sage (Opus 5.5, 1ef1e4f8) | row 240 landing gate (cli 639/0, scripts 585/0) and landing c515273db with DEFERRED da3051ccc; 238 r3/r4 and 228 r3 requests posted as jarvis; combined 228+238 gate (seat 165/0, cli 640/0, scripts 585/0, 238 mutant killed), landings 86249ac55 and d49b1f2bd, DEFERRED e7078e6a8; #1746, #1729, #1744 closed; 197 r2 request posted (29961), r5 rebuild on 238; 195 after 226, Duckworth r7 note posted (29962); slots Herb 197, Gosalyn 212 (sage-1788..1826) | landed
@@ -599,7 +599,8 @@ error. Before anything stops, a run whose Console flags hold `--sso` refuses
 `sso-target` for a target Console without it, `sso-config` when the target's own
 `checkConsole` refuses the config's `console` key (or there is none, in which
 case, from another copy, it names the first step: activate the target without
-`--sso`, then write `console.sso`), and `sso-slot` for each provider's slot file
+`--sso`, then write `console.sso`; on a named instance both commands carry
+`--instance NAME`), and `sso-slot` for each provider's slot file
 that is missing, a symlink, not a regular file, not owned by this uid, has group
 or other bits, resolves inside the repository or the copies, or is empty. It
 uses `lstat`, `stat` and `realpath` on the slot and never reads it. `--plan`
@@ -837,8 +838,9 @@ user's clone `<home>/src/mosaic-stack`:
   `--copy` (which also starts the bus, then the Console), A5 `confirm`.
   The driver writes the new args file beside the old one before A2
   (`args-failed`, exit 3) and moves it into place after A5. A failed move
-   exits 1 `args-failed`: the new copy is live and confirmed, and root puts
-   the file in place by hand.
+   exits 5 `args-failed`: the new copy is live and confirmed, the args file
+   still names the old one, and root moves the new file (the result line
+   names it) into place by hand.

 A failure in A2 or a stage that exits 3 starts the old units again and gates
 them (A2f). A later failure stops both units, runs `revert`, renders the old
@@ -854,11 +856,80 @@ against a fixed pattern (`BACKUP_STORE none` otherwise). The step log
 `<time> result exit=N <code> <text>` line.

 Exit 0 ok, 1 failed with the old stack running and gated, 2 rollback-failed
-with both units stopped, 3 refused with nothing stopped, 4 usage. A refusal
+with both units stopped, 3 refused with nothing stopped, 4 usage, 5
+args-failed with the new stack live and confirmed. A refusal
 after step 2 leaves the user's clone fast-forwarded and the new copy made. After exit
 2 the activation stays open, so the next run's plan refuses until root
 finishes it.

+#### Root's host check (`scripts/case1-hostcheck.sh`, row 240)
+
+```
+/usr/local/lib/mosaic-stack/hostcheck.sh --check | --enforce | --upstream
+```
+
+Installed from `scripts/case1-hostcheck.sh` as `hostcheck.sh`, with
+`scripts/case1-pins.sh` beside it (`docs/guides/host-run-sheet.md` section 4).
+The pins are the profile's sha256, the `apparmor-profiles` version it came
+from and the bubblewrap install pin; changing one is a reviewed commit.
+Seven items, one `ok N` or `FAIL N` line each: the profile file matches the
+pin and no package owns it; `aa-status` has `bwrap` and `unpriv_bwrap` in
+enforce mode and no `mosaic-bwrap`; no other file under `/etc/apparmor.d`
+names `bwrap`; a bwrap child under the units' no-new-privs reads
+`bwrap//&unpriv_bwrap (enforce)`; `/usr/bin/bwrap` is `root mosaic 0750` by
+the statoverride and by `stat`; the user-namespace restriction and
+`fs.protected_hardlinks` are 1; `net.ipv4.ip_unprivileged_port_start` is
+above the Console unit's `--port`, or above 1023 with no unit. A `note` line
+says whether bubblewrap is the install pin and never fails.
+
+`--check` exits 0 or 1; `stack-upgrade.sh` refuses `profile-drift` on 1.
+`--enforce` exits 0. On a failure, or while `/etc/mosaic-stack/DRIFT` exists,
+it unloads the profile if loaded, sets `/usr/bin/bwrap` to `root:root` 0700,
+appends the failed items to `DRIFT` and one line to
+`/var/log/mosaic-stack/hostcheck.log`. It never writes the statoverride. The
+apt hook runs it after every package run, and `mosaic-hostcheck.service`
+(`packages/cli/systemd/`) at boot before the bus. `--upstream` compares the
+`apparmor-profiles` candidate's profile to the pin, prints any difference
+and exits 0, or 1 when the download fails. Exit 2 is usage or a refusal:
+root takes no `--root` (the test seam), and other users run only with it.
+
+#### Root's acceptance run (`scripts/case1-accept.sh`, row 195)
+
+```
+case1-accept.sh --business ID --args FILE --claude-pin PIN --node-pin vN.N.N
+```
+
+Root runs it on the Case 1 host after the install window, from a root-owned
+checkout. It reads the user, home, copy, node, claude and both ports from the
+args file (`/etc/mosaic-stack/dev.args` on .53), which must pass
+`stack-upgrade.sh`'s rules, say `--profile factory` and name `--business`.
+Every command that runs the stack's code runs as
+`sudo -u USER -H env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin` from `/`.
+Root itself reads `ss`, `/proc`, the account database and file metadata. It
+runs `systemctl show` and `is-enabled`, `curl` on the Console's loopback
+`/healthz`, `sudo -l`, `sudo -u jarvis bwrap --version`, `hostcheck.sh
+--check`, and node to parse `managed-settings.json` for F9. F9 runs node only
+when `--node` is the `--node-pin` path, and the file and every directory above
+it are root's with no group or other write. The one write is F3's message and
+its reply, and it never opens `claude-session.env`.
+
+It prints one line per check, `<id> <path> <mark> <evidence>`, then
+`count <mark> N` for each mark and a result line. The functional checks
+F1-F11 are `pass` or `FAIL`: both units active as the user, the Console on
+127.0.0.1 only, a tester message to chief answered, `case2-precheck.sh
+--profile factory`, the bwrap labels of a live role session, the claude and
+node pins, one live PM launch, the credential file's owner and mode, the
+autoupdater off, no Discord binding. The host paths P1-P11 are `closed`,
+`accepted <ruling>` (Q182, Q183, mos-1096, mos-1101) or `unnamed`, which means
+no ruling names the path; each `unnamed` line goes to Mos. P9 runs
+`hostcheck.sh --check`, never `--enforce`.
+
+Exit 0 when every F check passes, 1 when one fails, 2 on usage or a refusal:
+a bad args file, or `--root` misused. A P check never changes the exit.
+`--root DIR` is the test seam for `packages/cli/tests/case1-accept.test.mjs`;
+root takes none, and other users run only with it. Design: row 195 r7
+section 5 (`agents/darkwing/work/queue-195/DESIGN.md`).
+
 ## Console service (`scripts/webui-service.sh`)

 ```bash
@@ -66,8 +66,10 @@ The pin is 2.1.304 unless the window names a newer one.

 ```sh
 install -d -o root -g root -m 0755 /opt/mosaic-stack/claude-<pin> /etc/claude-code
-npm install --prefix /opt/mosaic-stack/claude-<pin> @anthropic-ai/claude-code@<pin>
+PATH=/opt/mosaic-stack/node-<v>/bin:/usr/sbin:/usr/bin:/sbin:/bin \
+  npm install --prefix /opt/mosaic-stack/claude-<pin> @anthropic-ai/claude-code@<pin>
 chown -R root:root /opt/mosaic-stack/claude-<pin>
+/opt/mosaic-stack/claude-<pin>/node_modules/@anthropic-ai/claude-code/bin/claude.exe --version
 printf '%s\n' '{"env":{"DISABLE_AUTOUPDATER":"1"}}' > /etc/claude-code/managed-settings.json
 chown root:root /etc/claude-code/managed-settings.json
 chmod 0644 /etc/claude-code/managed-settings.json
@@ -75,8 +77,16 @@ chmod 0644 /etc/claude-code/managed-settings.json

 Rollback: `rm -r /opt/mosaic-stack/claude-<pin> /etc/claude-code/managed-settings.json`.

-The args file's `--claude` names the binary under `/opt/mosaic-stack/claude-<pin>`. `case2-unit.sh`
-refuses one that isn't a root-owned regular file outside the home.
+Root's PATH has no npm, so the install line puts section 2's pinned node first; the package's postinstall
+also runs `node`. The `--version` line must print `<pin> (Claude Code)`. Anything else means the postinstall
+left its 500-byte stub in `bin/claude.exe` (no native package for the platform, or scripts were off): stop and
+roll back.
+
+The args file's `--claude` is
+`/opt/mosaic-stack/claude-<pin>/node_modules/@anthropic-ai/claude-code/bin/claude.exe`, the regular file the
+postinstall hardlinks or copies the native binary to. Not `node_modules/.bin/claude`: that is npm's symlink
+to it, and `case2-unit.sh` refuses a symlink, as it does anything that isn't a root-owned regular file outside
+the home. Checked against the 2.1.304 package's `install.cjs`; a newer pin needs the same check.

 Precheck lines:
 - `ok      claude replaces its prompt with --system-prompt-file (<n> input tokens)`. It runs the claude the bus
@@ -120,17 +130,41 @@ lists no member, and `sysctl fs.protected_hardlinks` prints 1. `sysctl
 kernel.apparmor_restrict_unprivileged_userns` prints 1 too (Ubuntu 24.04's default); leave it, so nothing
 else on the host gains user namespaces.

-The drift stop is row 240's (I4, #1746): `hostcheck.sh` and its pins in `/usr/local/lib/mosaic-stack/`, the
-apt hook `/etc/apt/apt.conf.d/80mosaic-hostcheck`
-(`DPkg::Post-Invoke { "/usr/local/lib/mosaic-stack/hostcheck.sh --enforce || true"; };`) and the boot unit
-`mosaic-hostcheck.service`. Install them from row 240's run sheet lines once it lands. Until then
-`stack-upgrade.sh` refuses `profile-drift` on every run, because it runs `hostcheck.sh --check` and a
-missing file refuses.
+The drift stop (row 240, I4, #1746) goes in last, after the profile and the statoverride. As root, from
+the root-owned checkout of the reviewed commit:
+
+```sh
+install -d -o root -g root -m 0755 /usr/local/lib/mosaic-stack
+install -o root -g root -m 0755 scripts/case1-hostcheck.sh /usr/local/lib/mosaic-stack/hostcheck.sh
+install -o root -g root -m 0644 scripts/case1-pins.sh /usr/local/lib/mosaic-stack/case1-pins.sh
+printf '%s\n' 'DPkg::Post-Invoke { "/usr/local/lib/mosaic-stack/hostcheck.sh --enforce || true"; };' \
+  > /etc/apt/apt.conf.d/80mosaic-hostcheck
+install -o root -g root -m 0644 packages/cli/systemd/mosaic-hostcheck.service /etc/systemd/system/
+systemctl daemon-reload && systemctl enable mosaic-hostcheck.service
+/usr/local/lib/mosaic-stack/hostcheck.sh --check
+```
+
+`--check` prints one `ok` line for each of its seven items and exits 0. Item 7 reads 1023 as the port
+until I2 installs the Console unit (section 10), then the unit's `--port`. `stack-upgrade.sh` runs `--check`
+before its plan and refuses `profile-drift` on any exit but 0, a missing file included. Rollback:
+`systemctl disable mosaic-hostcheck.service`, then `rm` the unit, the hook file and
+`/usr/local/lib/mosaic-stack`.
+
+On drift, `--enforce` (the apt hook after every package run, and the unit at boot) unloads the profile,
+closes `/usr/bin/bwrap` to `root:root` 0700, appends the failed items to `/etc/mosaic-stack/DRIFT` and logs
+a line in `/var/log/mosaic-stack/hostcheck.log`. Every role session then refuses to start. ops-01 reads the
+log in each STATE report and sends any `DRIFT` to Mos. Only root removes `DRIFT`, in a reviewed step with
+a new pin or a Mos go. After that, `chown root:mosaic /usr/bin/bwrap`, `chmod 0750 /usr/bin/bwrap` and
+`apparmor_parser -r /etc/apparmor.d/bwrap-userns-restrict` put bwrap back, and `--check` must exit 0.
+
+Before each re-pin window, ops-01 runs `/usr/local/lib/mosaic-stack/hostcheck.sh --upstream`. It
+downloads the `apparmor-profiles` candidate and compares its `bwrap-userns-restrict` to the pin. A
+`DIFFERS` line goes to Mos as a new-pin request; it refuses nothing.

 Precheck lines:
 - `ok      bwrap --unshare-all runs`
 - The AppArmor profile, the statoverride, the no-new-privs result and the P9 checks: precheck line missing.
-  A line that runs `/usr/local/lib/mosaic-stack/hostcheck.sh --check` would cover them once row 240 lands.
+  `/usr/local/lib/mosaic-stack/hostcheck.sh --check` covers them (row 240).

 ## 5. The port floor

@@ -187,6 +221,9 @@ When a run doesn't exit 0, send Mos the exit and the last lines of `/var/log/mos
  it is finished with `confirm` or `revert`. One way here: a unit that doesn't stop within `--timeout`
  keeps its old start time, A2f's gate fails it `stale-start`, and the driver stops both (duckworth-0055
  N1). That is on purpose; a unit that won't stop is a reason to stop.
+- Exit 5: `args-failed`. The new copy is live and passed confirm, but `/etc/mosaic-stack/dev.args` still names
+  the old copy. The next run refuses `args-differ`, and a render from that file would put the old copy back.
+  Move the file the result line names into place with `mv -f`. The two differ only in the `--copy` value.

 Precheck lines: none. Root's checkout at `<sha>` and the stack's user's clone: precheck line missing.
 After install, `stack-copy.sh check --units external` reads the copy the units run.
@@ -209,6 +246,8 @@ their sudoers line and the sshd drop-in `/etc/ssh/sshd_config.d/<nn>-mosaic-keys
 it (`hosts.enroll`, the `host-enroll` decision) are rows 234 and 235, not yet on refactor. This item has no
 commands until they land.

+Precheck line: none. The enrolled host's key and its `mosaic-keys` sudoers line: precheck line missing.
+
 ## 9. Credential slots

 Jason places these, all in one sitting per host. No value appears here or in any message. Check a placed
@@ -238,3 +277,5 @@ leaves.

 None by hand. I2's `case2-unit.sh` enables both units, starts the bus, then the Console (Q189, mos-1122).
 `stack-upgrade.sh` stops and starts both units itself.
+
+Precheck line: none. Both units active after the render: precheck line missing.
@@ -238,6 +238,38 @@ at every gate. Started 2026-09-12 during the control board MVP.
  lands, as a follow-up row or in the next row that edits role.mjs.
  Webby N1 on row 213 r3 (REVIEW-r3.md, 3ab3c010b), mos-1160.
  (2026-10-21)
+- **The boot host check orders only one business's bus.**
+  `mosaic-hostcheck.service` (row 240) has
+  `[email protected]`. `case2-unit.sh` enables the
+  bus as `mosaic-bus@<business>.service`, so on a host whose business id
+  isn't `mosaic-stack` nothing orders the two. The bus can start before
+  the boot stop runs, and after a boot-time drift role sessions can use
+  bwrap until it does. The fix: `After=mosaic-hostcheck.service` in
+  `packages/cli/systemd/mosaic-bus.service.in`, which orders every
+  instance and does nothing where the unit isn't installed. It goes in
+  before the first install whose business id isn't `mosaic-stack`.
+  Filbert N1 on row 240 (29945, #1746). (2026-10-21)
+- **The run sheet writes the apt hook before the first `--check`.**
+  Section 4 installs `80mosaic-hostcheck`, then runs
+  `hostcheck.sh --check`. If that check fails, the next package run
+  closes bwrap before anyone has read the failure. It fails closed, but
+  it surprises an installer. The fix: run `--check` first, or say what a
+  failure at that step means. Doc-only, for the next row that edits
+  `docs/guides/host-run-sheet.md`. Filbert N2 on row 240 (29945, #1746).
+  Filbert's N3, that a closed bwrap appends to `DRIFT` on every later
+  apt run and boot, is by design; ops-01's STATE read should expect the
+  repeats. (2026-10-21)
+- **The sso-config first-step hint has no business.** When the target
+  copy has no `console.sso`, `stack-release.sh` (`:938`) refuses with
+  "activate $TO without --sso first, then ... activate $TO --sso". The
+  usage line is `activate ID BUSINESS` (`:47`), so pasting either command
+  as printed gives a usage error, not the first step. It fails safe,
+  since the usage error changes nothing. The fix: add `$BUSINESS`
+  (set at `:2138`) to both commands, and the business (`acme`)
+  to the three expected strings in `stack-release.test.mjs`
+  (`:1538`, `:1689`, `:1691`). For a later row that edits
+  `stack-release.sh`. Webby N1 on row 238 r1 (REVIEW-r1.md, 433a95292,
+  #1744). (2026-10-21)

 ## Queue

@@ -432,9 +432,11 @@ A Claude Code session logs in with `CLAUDE_CODE_OAUTH_TOKEN`,
 on. The bus unit loads it ("Unit" below). Nothing from the host's
 `~/.claude` reaches a session, whose `HOME` is its own. With none of them
 set, a Claude Code launch refuses `no-session-credential` before anything
-starts. A Pi session gets the same variables through the allowlist. A
-shell the harness opens, Claude Code's `Bash` or Pi's `bash`, can read
-them.
+starts. A Pi session gets the same variables through the allowlist. A Pi
+session on provider `zai` logs in with `ZAI_API_KEY`, which the allowlist
+passes. Like every allowlist variable, it reaches every session the host
+starts, Claude Code ones included. A shell the harness opens, Claude Code's
+`Bash` or Pi's `bash`, can read all of these variables.

 A Pi session logs in only through the variables `ENV_ALLOW` passes. Its
 `HOME` is the run's own, so Pi never reads the operator's `~/.pi/agent`
@@ -706,13 +708,14 @@ instead and sessions run `claude` from the unit's `PATH`, which in the
 sandbox finds only a `claude` under `/usr`. A running host
 keeps the environment it started with until it restarts.

-The session credential comes from
+The session credentials come from
 `EnvironmentFile=-%h/.config/mosaic-dev/secrets/claude-session.env`, the
-one place the path is set. The file holds one line, for example
-`CLAUDE_CODE_OAUTH_TOKEN=<token>`, mode 0600. The operator writes it;
+one place the path is set. The file holds one line per variable, for
+example `CLAUDE_CODE_OAUTH_TOKEN=<token>`, mode 0600. It holds every session
+provider key, not only Claude's. The operator writes it;
 nothing in the repository creates it, and only the Case 2 precheck reads
 it, printing variable names, never values. No session sees the file
-itself, only the variable. The leading `-` lets the unit start
+itself, only the variables. The leading `-` lets the unit start
 without it, so Pi sessions still launch and a Claude Code launch refuses
 `no-session-credential`. To change the credential, edit or swap the file
 (or this line and this paragraph), then restart the unit; a running host
@@ -0,0 +1,16 @@
+# Mosaic Case 1 host check at boot (row 240, #1746; r6 B2). Root installs it as
+# /etc/systemd/system/mosaic-hostcheck.service, root:root 0644, and enables it
+# (docs/guides/host-run-sheet.md). It runs the drift stop before the bus starts, which covers a kernel
+# or parser change that takes effect at boot. --enforce always exits 0; on drift it closes bwrap to
+# root, and every role session then refuses to start.
+[Unit]
+Description=Mosaic Case 1 host check: the bwrap profile, the statoverride and the sysctls
+After=apparmor.service
+Before=[email protected]
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/lib/mosaic-stack/hostcheck.sh --enforce
+
+[Install]
+WantedBy=multi-user.target
@@ -0,0 +1,527 @@
+// Row 195 (#1693): scripts/case1-accept.sh, root's acceptance run on the Case 1 host. Design r7 section 5
+// (agents/darkwing/work/queue-195/DESIGN.md); deviations in agents/darkwing/work/queue-195/BUILD.md.
+// Every case runs the script with --root on a scratch host tree: /etc, /proc, /srv/mosaic, /opt and the
+// host check live under it. Fake systemctl, curl, ss, sudo and stat on PATH record their argv; the fake
+// sudo runs the stack's user's commands from the tree. Nothing here reads or writes the real /etc,
+// /proc or /srv, and the stand-in credential is not a credential.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmp } from "./helpers.mjs";
+
+const REPO = fileURLToPath(new URL("../../../", import.meta.url));
+const SCRIPT = join(REPO, "scripts", "case1-accept.sh");
+const COPY = "0123456789abcdef0123456789abcdef01234567";
+const NODE_PIN = "v24.1.0", CLAUDE_PIN = "2.1.0";
+const NODE = `/opt/mosaic-stack/node-${NODE_PIN}/bin/node`;
+const CLAUDE = `/opt/mosaic-stack/claude-${CLAUDE_PIN}/node_modules/@anthropic-ai/claude-code/bin/claude.exe`;
+const HOME = "/srv/mosaic";
+const CLI = `${HOME}/.local/share/mosaic-stack/copies/${COPY}/scripts/mosaic`;
+const PRECHECK = `${HOME}/.local/share/mosaic-stack/copies/${COPY}/scripts/case2-precheck.sh`;
+const CRED = `${HOME}/.config/mosaic-dev/secrets/claude-session.env`;
+const CRED_VALUE = "stand-in-not-a-credential-7f3e2a";
+const AS_MOSAIC = `-u mosaic -H env PATH=/opt/mosaic-stack/node-${NODE_PIN}/bin:/usr/local/bin:/usr/bin:/bin`;
+const ARGS = ["--profile", "factory", "--user", "mosaic", "--home", HOME, "--business", "mosaic-stack", "--copy", COPY,
+  "--node", NODE, "--claude", CLAUDE, "--pm", "--", "--port", "732", "--business", "mosaic-stack", "--tester-port", "7333"];
+const OUTER = "bwrap (enforce)", CHILD = "bwrap//&unpriv_bwrap (enforce)";
+const MARKS = ["pass", "FAIL", "closed", "accepted Q182+Q183", "accepted Q183", "accepted mos-1096", "accepted mos-1101", "unnamed"];
+const P_PASS = { P1: "closed", P2: "closed", P3: "accepted Q183", P4: "accepted Q182+Q183", P5: "closed", P6: "closed",
+  P7: "closed", P8: "closed", P9: "accepted mos-1096", P10: "accepted mos-1101", P11: "closed" };
+const PASSWD = "root:x:0:0:root:/root:/bin/bash\nmosaic:x:997:997::/srv/mosaic:/usr/sbin/nologin\nlocaladmin:x:1000:1000::/home/localadmin:/bin/bash\njarvis:x:1001:1001::/home/jarvis:/bin/bash\n";
+const GROUP = "root:x:0:\nsudo:x:27:localadmin\nmosaic:x:997:\nlxd:x:998:\ndocker:x:999:\nlocaladmin:x:1000:\njarvis:x:1001:\n";
+const SS = "LISTEN 0 511 127.0.0.1:732 0.0.0.0:* users:((\"node\",pid=200,fd=21))\n"
+  + "LISTEN 0 511 127.0.0.1:7333 0.0.0.0:* users:((\"node\",pid=200,fd=22))\n"
+  + "LISTEN 0 4096 0.0.0.0:22 0.0.0.0:* users:((\"sshd\",pid=900,fd=3))\n";
+const HOSTCHECK_OK = [1, 2, 3, 4, 5, 6, 7].map((n) => `ok ${n} item ${n} holds`).join("\n") + "\nnote bubblewrap 0.9.0 is the install pin\n";
+
+function put(file, text, mode) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, text);
+  if (mode) chmodSync(file, mode);
+}
+const edit = (file, f) => writeFileSync(file, f(readFileSync(file, "utf8")));
+const log = (name) => `printf '%s' ${JSON.stringify(name)} >> "$HC/calls.log"; printf ' %s' "$@" >> "$HC/calls.log"; echo >> "$HC/calls.log"`;
+
+// Fakes on PATH. Each records its argv and answers from a file in the state directory.
+const FAKES = {
+  systemctl: `case "$1" in
+  show) [ -f "$HC/show-$2" ] && cat "$HC/show-$2" ;;
+  is-enabled) cat "$HC/enabled-$2" 2>/dev/null || { echo disabled; exit 1; } ;;
+esac`,
+  curl: `exit "$(cat "$HC/curl-rc")"`,
+  ss: `cat "$HC/ss"`,
+  // The credential and the settings file answer from the state directory, as root would see them, and
+  // only those calls are recorded; everything else is the real stat, which reads the args file.
+  stat: `case "\${@: -1}" in
+  *claude-session.env) ${log("stat")}; cat "$HC/stat-cred" ;;
+  *managed-settings.json) ${log("stat")}; cat "$HC/stat-settings" ;;
+  *) exec /usr/bin/stat "$@" ;;
+esac`,
+  // -l -U USER prints the state file; -u jarvis is the bwrap probe; -u mosaic -H env PATH=... CMD runs
+  // CMD from the tree, with the PATH entries and each absolute argument that exists there moved under it.
+  sudo: `case "$1" in
+  -l) [ -f "$HC/sudo-l-$3" ] && cat "$HC/sudo-l-$3"; exit 0 ;;
+  -u) ;;
+  *) exit 97 ;;
+esac
+user="$2"; shift 2
+if [ "$user" = jarvis ]; then cat "$HC/jarvis-bwrap" >&2; exit "$(cat "$HC/jarvis-bwrap-rc")"; fi
+[ "$user" = mosaic ] && [ "$1" = -H ] && [ "$2" = env ] && [[ "$3" == PATH=* ]] || exit 98
+p="\${3#PATH=}"; shift 3
+np=""; IFS=: read -ra parts <<< "$p"; for x in "\${parts[@]}"; do np+="$ROOT_DIR$x:"; done
+cmd="$1"; shift
+args=(); for a in "$@"; do if [[ "$a" == /* ]] && [ -e "$ROOT_DIR$a" ]; then args+=("$ROOT_DIR$a"); else args+=("$a"); fi; done
+HOME="$ROOT_DIR/srv/mosaic" PATH="$np$PATH" exec "$ROOT_DIR$cmd" "\${args[@]}"`,
+};
+
+// Executables inside the tree, run by the fake sudo or by the script itself. Node marks a run outside
+// the fake sudo, which sets HOME to the stack's home, so a test can tell whether root ran it.
+const NODE_STUB = `[ "$HOME" = "$ROOT_DIR/srv/mosaic" ] || touch "$HC/node-as-root"
+[ "\${1:-}" = --version ] && { cat "$HC/node-version"; exit 0; }
+exec "$REAL_NODE" "$@"`;
+const TREE = {
+  [NODE]: NODE_STUB,
+  [CLAUDE]: `[ "\${1:-}" = --version ] && cat "$HC/claude-version"; exit 0`,
+  [CLI]: `${log("mosaic")}
+case "$1" in
+  talk) case "$(cat "$HC/talk-mode")" in
+      reply) echo "sent ab12cd34 to chief"; echo "[chief -> tester] seen" ;;
+      noreply) echo "sent ab12cd34 to chief"; echo "no reply from chief within 300 s" >&2; exit 1 ;;
+      sentonly) echo "sent ab12cd34 to chief" ;;
+    esac ;;
+  launches) cat "$HC/launches.json" ;;
+  *) exit 2 ;;
+esac`,
+  [PRECHECK]: `${log("precheck")}
+echo "precheck: done"; exit "$(cat "$HC/precheck-rc")"`,
+  "/usr/local/lib/mosaic-stack/hostcheck.sh": `${log("hostcheck")}
+cat "$HC/hostcheck-out"`,
+};
+
+function proc(root, pid, { ppid, uid = 997, exe, argv0 = "x", comm = "x", label }) {
+  const d = join(root, "proc", String(pid));
+  put(join(d, "status"), `Name:\t${comm}\nState:\tS (sleeping)\nPPid:\t${ppid}\nUid:\t${uid}\t${uid}\t${uid}\t${uid}\n`);
+  put(join(d, "cmdline"), `${argv0}\0--x\0`);
+  put(join(d, "comm"), `${comm}\n`);
+  rmSync(join(d, "exe"), { force: true });
+  if (exe) symlinkSync(exe, join(d, "exe"));
+  if (label !== undefined) put(join(d, "attr", "current"), label);
+}
+
+// A scratch Case 1 host where every F check passes and every P check is closed or accepted.
+function host(t) {
+  const dir = tmp(t, "c1accept-");
+  const root = join(dir, "root"), hc = join(dir, "hc"), bin = join(dir, "bin");
+  const args = join(root, "etc", "mosaic-stack", "dev.args");
+  put(args, ARGS.join("\n") + "\n", 0o644);
+  put(join(root, "etc", "passwd"), PASSWD);
+  put(join(root, "etc", "group"), GROUP);
+  put(join(root, "etc", "sudoers.d", "90-localadmin"), "localadmin ALL=(ALL) NOPASSWD: ALL\n");
+  put(join(root, "etc", "claude-code", "managed-settings.json"), JSON.stringify({ env: { DISABLE_AUTOUPDATER: "1" } }));
+  put(join(root, CRED), `CLAUDE_CODE_OAUTH_TOKEN=${CRED_VALUE}\n`, 0o600);
+  put(join(root, HOME, ".config", "mosaic-dev", "businesses", "mosaic-stack.json"), JSON.stringify({ id: "mosaic-stack", launch: { by: "pm" } }));
+  put(join(root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "1024\n");
+  proc(root, 1, { ppid: 0, uid: 0, exe: "/usr/lib/systemd/systemd", comm: "systemd" });
+  proc(root, 100, { ppid: 1, exe: NODE, argv0: NODE, comm: "node" });
+  proc(root, 200, { ppid: 1, exe: NODE, argv0: NODE, comm: "node" });
+  proc(root, 300, { ppid: 100, exe: "/usr/bin/bwrap", argv0: "/usr/bin/bwrap", comm: "bwrap", label: `${OUTER}\n` });
+  proc(root, 301, { ppid: 300, exe: NODE, argv0: NODE, comm: "node", label: `${CHILD}\n` });
+  proc(root, 302, { ppid: 301, exe: CLAUDE, argv0: CLAUDE, comm: "claude.exe", label: `${CHILD}\n` });
+  // A root bwrap with a mislabelled claude child, which F5 must pass over.
+  proc(root, 400, { ppid: 1, uid: 0, exe: "/usr/bin/bwrap", argv0: "/usr/bin/bwrap", comm: "bwrap", label: "unconfined\n" });
+  proc(root, 401, { ppid: 400, uid: 0, argv0: "claude", comm: "claude", label: "unconfined\n" });
+  const state = {
+    "[email protected]": "ActiveState=active\nUser=mosaic\nMainPID=100\n",
+    "show-mosaic-webui.service": "ActiveState=active\nUser=mosaic\nMainPID=200\n",
+    "show-mosaic-hostcheck.service": "[email protected] mosaic-webui.service multi-user.target\n",
+    "enabled-mosaic-hostcheck.service": "enabled\n",
+    "curl-rc": "0", ss: SS,
+    "stat-cred": "mosaic 600 regular file\n", "stat-settings": "root:root 644 regular file\n",
+    "sudo-l-mosaic": "User mosaic is not allowed to run sudo on dev-53.\n",
+    "sudo-l-localadmin": "User localadmin may run the following commands on dev-53:\n    (ALL : ALL) ALL\n    (ALL) NOPASSWD: ALL\n",
+    "jarvis-bwrap": "sudo: unable to execute /usr/bin/bwrap: Permission denied\n", "jarvis-bwrap-rc": "1",
+    "node-version": `${NODE_PIN}\n`, "claude-version": `${CLAUDE_PIN} (Claude Code)\n`,
+    "talk-mode": "reply", "precheck-rc": "0", "hostcheck-out": HOSTCHECK_OK,
+    "launches.json": JSON.stringify([
+      { instance: "pm", live: true, business: "mosaic-stack", run: "r-0002" },
+      { instance: "pm", live: false, business: "mosaic-stack", run: "r-0001" },
+      { instance: "dev-1", live: true, business: "mosaic-stack", run: "r-0003" },
+    ]),
+  };
+  for (const [name, text] of Object.entries(state)) put(join(hc, name), text);
+  for (const [name, body] of Object.entries(FAKES)) put(join(bin, name), `#!/usr/bin/env bash\n${name === "stat" ? "" : log(name)}\n${body}\n`, 0o755);
+  for (const [path, body] of Object.entries(TREE)) put(join(root, path), `#!/usr/bin/env bash\n${body}\n`, 0o755);
+  // F9 runs node only when it and each directory above it have no group or other write, whatever the umask.
+  for (let d = dirname(NODE); d !== "/"; d = dirname(d)) chmodSync(join(root, d), 0o755);
+  chmodSync(root, 0o755);
+  return { dir, root, hc, bin, args };
+}
+
+function run(h, extra = {}, argv = ["--business", "mosaic-stack", "--args", "/etc/mosaic-stack/dev.args", "--claude-pin", CLAUDE_PIN, "--node-pin", NODE_PIN, "--root", h.root]) {
+  const r = spawnSync(SCRIPT, argv, {
+    encoding: "utf8",
+    env: { ...process.env, PATH: `${h.bin}:${process.env.PATH}`, HC: h.hc, ROOT_DIR: h.root, REAL_NODE: process.execPath, TMPDIR: h.dir, ...extra },
+  });
+  const lines = r.stdout.split("\n").filter(Boolean);
+  // Each check line as { id, path, mark, evidence }.
+  const checks = lines.filter((l) => /^[FP][0-9]+ /.test(l)).map((l) => {
+    const [id, path, ...rest] = l.split(" ");
+    const tail = rest.join(" ");
+    const mark = MARKS.find((m) => tail === m || tail.startsWith(`${m} `));
+    return { id, path, mark, evidence: tail.slice(mark?.length ?? 0).trim(), line: l };
+  });
+  return { status: r.status, out: r.stdout, err: r.stderr, lines, checks };
+}
+const calls = (h, name) => (existsSync(join(h.hc, "calls.log")) ? readFileSync(join(h.hc, "calls.log"), "utf8") : "")
+  .split("\n").filter((l) => l === name || l.startsWith(`${name} `)).map((l) => l.slice(name.length + 1));
+const failed = (r) => r.checks.filter((c) => c.mark === "FAIL").map((c) => c.id);
+const marksOf = (r, id) => r.checks.filter((c) => c.id === id).map((c) => c.mark);
+const mustRun = (h, extra) => { const r = run(h, extra); assert.ok(r.status === 0 || r.status === 1, r.out + r.err); return r; };
+
+// One fault per F check; each makes that check, and only that one, fail.
+const F_FAULTS = {
+  F1: (h) => proc(h.root, 100, { ppid: 1, uid: 0, exe: NODE, comm: "node" }),
+  F2: (h) => put(join(h.hc, "ss"), SS.replace("127.0.0.1:732 ", "0.0.0.0:732 ")),
+  F3: (h) => put(join(h.hc, "talk-mode"), "noreply"),
+  F4: (h) => put(join(h.hc, "precheck-rc"), "1"),
+  F5: (h) => put(join(h.root, "proc", "302", "attr", "current"), "unconfined\n"),
+  F6: (h) => put(join(h.hc, "claude-version"), "2.0.9 (Claude Code)\n"),
+  F7: (h) => put(join(h.hc, "launches.json"), JSON.stringify([{ instance: "pm", live: false, business: "mosaic-stack", run: "r-1" }])),
+  F8: (h) => put(join(h.hc, "stat-cred"), "mosaic 640 regular file\n"),
+  F9: (h) => put(join(h.root, "etc", "claude-code", "managed-settings.json"), JSON.stringify({ env: { DISABLE_AUTOUPDATER: "0" } })),
+  F10: (h) => put(join(h.hc, "node-version"), "v24.0.0\n"),
+  F11: (h) => put(join(h.root, HOME, ".mosaic-dev", "discord", "binding.json"), "{}"),
+};
+
+test("row 195 accept: every check passing exits 0, with each P mark and counts that match the lines", (t) => {
+  const h = host(t);
+  const r = run(h);
+  assert.equal(r.status, 0, r.out + r.err);
+  assert.deepEqual(r.checks.map((c) => c.id), ["F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11",
+    "P1", "P2", "P3", "P4", "P5", "P6", "P7", "P8", "P9", "P10", "P11"]);
+  for (const c of r.checks.filter((x) => x.id.startsWith("F"))) assert.equal(c.mark, "pass", c.line);
+  for (const [id, mark] of Object.entries(P_PASS)) assert.deepEqual(marksOf(r, id), [mark], id);
+  const counts = r.lines.filter((l) => l.startsWith("count ")).map((l) => l.slice(6));
+  assert.deepEqual(counts, MARKS.map((m) => `${m} ${r.checks.filter((c) => c.mark === m).length}`));
+  assert.match(r.lines.at(-1), /^case1-accept: every F check passes/);
+  assert.match(r.out, /^F5 bwrap-label pass bwrap 300 reads 'bwrap \(enforce\)' and its claude descendant 302 reads/m);
+  assert.match(r.out, /^F7 pm-live pass one live launch: pm run r-0002$/m);
+  assert.ok(!(r.out + r.err).includes(CRED_VALUE));
+  assert.ok(existsSync(join(h.hc, "node-as-root")), "F9 runs the pinned, root-only node as root");
+});
+
+test("row 195 accept: exits 1 with each F check failing alone, and its line names it", (t) => {
+  for (const [id, fault] of Object.entries(F_FAULTS)) {
+    const h = host(t);
+    fault(h);
+    const r = mustRun(h);
+    assert.equal(r.status, 1, `${id}: ${r.out}`);
+    assert.deepEqual(failed(r), [id], `${id}: ${r.out}`);
+    assert.equal(r.lines.at(-1), "case1-accept: an F check failed, so the row fails");
+  }
+});
+
+test("row 195 accept: F3 fails on exit 0 with no reply line, and its evidence takes talk's error", (t) => {
+  let h = host(t);
+  put(join(h.hc, "talk-mode"), "sentonly");
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F3"]);
+  assert.match(r.out, /^F3 tester-reply FAIL talk exited 0 with 1 lines on stdout; last: sent ab12cd34 to chief$/m);
+  h = host(t);
+  put(join(h.hc, "talk-mode"), "noreply");
+  r = mustRun(h);
+  assert.match(r.out, /^F3 tester-reply FAIL talk exited 1 with 1 lines on stdout; last: no reply from chief within 300 s$/m);
+});
+
+test("row 195 accept: F1 fails on a unit that isn't active or isn't User=mosaic", (t) => {
+  for (const show of ["ActiveState=failed\nUser=mosaic\nMainPID=0\n", "ActiveState=active\nUser=root\nMainPID=100\n"]) {
+    const h = host(t);
+    put(join(h.hc, "show-mosaic-webui.service"), show);
+    const r = mustRun(h);
+    assert.equal(r.status, 1);
+    assert.ok(failed(r).includes("F1"), r.out);
+  }
+});
+
+test("row 195 accept: F2 fails when healthz doesn't answer and when another pid holds the port", (t) => {
+  let h = host(t);
+  put(join(h.hc, "curl-rc"), "7");
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F2"]);
+  assert.match(r.out, /^F2 console-loopback FAIL curl http:\/\/127\.0\.0\.1:732\/healthz exited 7$/m);
+  h = host(t);
+  put(join(h.hc, "ss"), SS.replace("pid=200,fd=21", "pid=555,fd=4"));
+  r = mustRun(h);
+  assert.deepEqual(failed(r), ["F2"]);
+});
+
+test("row 195 accept: F5 fails on unpriv_bwrap (enforce), on complain and on a trailing space", (t) => {
+  for (const label of ["unpriv_bwrap (enforce)\n", "bwrap//&unpriv_bwrap (complain)\n", `${CHILD} \n`]) {
+    const h = host(t);
+    put(join(h.root, "proc", "302", "attr", "current"), label);
+    const r = mustRun(h);
+    assert.deepEqual(failed(r), ["F5"], `${JSON.stringify(label)}: ${r.out}`);
+  }
+  const h = host(t);
+  put(join(h.root, "proc", "300", "attr", "current"), `${OUTER} \n`);
+  assert.deepEqual(failed(mustRun(h)), ["F5"]);
+});
+
+test("row 195 accept: F5 fails with no bwrap of mosaic's, and passes on comm alone", (t) => {
+  let h = host(t);
+  proc(h.root, 300, { ppid: 100, uid: 1001, exe: "/usr/bin/bwrap", comm: "bwrap", label: `${OUTER}\n` });
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F5"]);
+  assert.match(r.out, /^F5 bwrap-label FAIL no \/usr\/bin\/bwrap process of mosaic/m);
+  h = host(t);
+  proc(h.root, 302, { ppid: 301, argv0: "/proc/self/fd/3", comm: "claude", label: `${CHILD}\n` });
+  assert.deepEqual(failed(mustRun(h)), []);
+});
+
+test("row 195 accept: F6 fails on a stub that prints nothing, on a path outside claude-<pin> and on a .. segment", (t) => {
+  let h = host(t);
+  put(join(h.hc, "claude-version"), "");
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F6"]);
+  h = host(t);
+  const other = CLAUDE.replace(`claude-${CLAUDE_PIN}`, "claude-2.0.9");
+  put(h.args, ARGS.map((a) => (a === CLAUDE ? other : a)).join("\n") + "\n", 0o644);
+  put(join(h.root, other), `#!/usr/bin/env bash\necho "${CLAUDE_PIN} (Claude Code)"\n`, 0o755);
+  r = mustRun(h);
+  assert.deepEqual(failed(r), ["F6"]);
+  assert.match(r.out, /^F6 claude-pin FAIL --claude \S+claude-2\.0\.9\S+ is not under \/opt\/mosaic-stack\/claude-2\.1\.0\/$/m);
+  // Under claude-<pin>/ by prefix, but the binary it names is 2.0.9's, which answers with the pin.
+  h = host(t);
+  const dotdot = CLAUDE.replace(`claude-${CLAUDE_PIN}/`, `claude-${CLAUDE_PIN}/../claude-2.0.9/`);
+  put(h.args, ARGS.map((a) => (a === CLAUDE ? dotdot : a)).join("\n") + "\n", 0o644);
+  put(join(h.root, other), `#!/usr/bin/env bash\necho "${CLAUDE_PIN} (Claude Code)"\n`, 0o755);
+  r = mustRun(h);
+  assert.deepEqual(failed(r), ["F6"], r.out);
+  assert.match(r.out, /^F6 claude-pin FAIL --claude \S+\/claude-2\.1\.0\/\.\.\/claude-2\.0\.9\/\S+ has a \.\. segment$/m);
+});
+
+test("row 195 accept: F7 fails on two live PM launches, one for another business, and no launch.by", (t) => {
+  const two = [{ instance: "pm", live: true, business: "mosaic-stack", run: "a" }, { instance: "pm", live: true, business: "mosaic-stack", run: "b" }];
+  for (const [file, text] of [["launches.json", JSON.stringify(two)], ["launches.json", JSON.stringify([{ instance: "pm", live: true, business: "other", run: "a" }])]]) {
+    const h = host(t);
+    put(join(h.hc, file), text);
+    assert.deepEqual(failed(mustRun(h)), ["F7"]);
+  }
+  const h = host(t);
+  put(join(h.root, HOME, ".config", "mosaic-dev", "businesses", "mosaic-stack.json"), JSON.stringify({ id: "mosaic-stack" }));
+  const r = mustRun(h);
+  assert.deepEqual(failed(r), ["F7"]);
+  assert.match(r.out, /^F7 pm-live FAIL the business file has no launch\.by$/m);
+});
+
+test("row 195 accept: F8 fails on 0640, on another owner and on a symlink, and never prints the credential", (t) => {
+  for (const fault of [
+    (h) => put(join(h.hc, "stat-cred"), "mosaic 640 regular file\n"),
+    (h) => put(join(h.hc, "stat-cred"), "root 600 regular file\n"),
+    (h) => { const f = join(h.root, CRED); rmSync(f); put(`${f}.real`, `X=${CRED_VALUE}\n`, 0o600); symlinkSync(`${f}.real`, f); },
+  ]) {
+    const h = host(t);
+    fault(h);
+    const r = mustRun(h);
+    assert.deepEqual(failed(r), ["F8"], r.out);
+    assert.ok(!(r.out + r.err).includes(CRED_VALUE));
+  }
+});
+
+test("row 195 accept: F9 fails on another owner, a group-writable mode and a number for the flag", (t) => {
+  for (const fault of [
+    (h) => put(join(h.hc, "stat-settings"), "root:root 664 regular file\n"),
+    (h) => put(join(h.hc, "stat-settings"), "mosaic:root 644 regular file\n"),
+    (h) => put(join(h.root, "etc", "claude-code", "managed-settings.json"), JSON.stringify({ env: { DISABLE_AUTOUPDATER: 1 } })),
+  ]) {
+    const h = host(t);
+    fault(h);
+    assert.deepEqual(failed(mustRun(h)), ["F9"]);
+  }
+});
+
+test("row 195 accept: F9 won't run --node as root off the pin path or with a writable directory above it", (t) => {
+  // Another node that works for the stack's user: F9 refuses to run it, and F10 fails on the path.
+  let h = host(t);
+  const other = NODE.replace(NODE_PIN, "v24.0.9");
+  put(h.args, ARGS.map((a) => (a === NODE ? other : a)).join("\n") + "\n", 0o644);
+  put(join(h.root, other), `#!/usr/bin/env bash\n${NODE_STUB}\n`, 0o755);
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F9", "F10"], r.out);
+  assert.match(r.out, /^F9 autoupdater-off FAIL root won't run --node \/opt\/mosaic-stack\/node-v24\.0\.9\/bin\/node: it is not the --node-pin path$/m);
+  assert.ok(!existsSync(join(h.hc, "node-as-root")));
+  // The pinned path, under a group-writable directory and then a symlinked node: F9 alone fails, and
+  // root doesn't run it.
+  for (const [fault, bad] of [
+    [(x) => chmodSync(join(x.root, dirname(NODE)), 0o775), "/opt/mosaic-stack/node-v24\\.1\\.0/bin \\(uid \\d+, mode 775\\)"],
+    [(x) => { const f = join(x.root, NODE); renameSync(f, `${f}.real`); symlinkSync(`${f}.real`, f); }, "/opt/mosaic-stack/node-v24\\.1\\.0/bin/node \\(uid \\d+, mode 777\\)"],
+  ]) {
+    h = host(t);
+    fault(h);
+    r = mustRun(h);
+    assert.deepEqual(failed(r), ["F9"], r.out);
+    assert.match(r.out, new RegExp(`^F9 autoupdater-off FAIL root won't run --node \\S+: ${bad} is not root's alone$`, "m"));
+    assert.ok(!existsSync(join(h.hc, "node-as-root")));
+  }
+});
+
+test("row 195 accept: F11 fails on one *.json under discord/ and passes on an empty directory", (t) => {
+  let h = host(t);
+  put(join(h.root, HOME, ".mosaic-dev", "discord", "chief.json"), "{}");
+  let r = mustRun(h);
+  assert.deepEqual(failed(r), ["F11"]);
+  assert.match(r.out, /^F11 no-discord FAIL \/srv\/mosaic\/\.mosaic-dev\/discord holds bindings: chief\.json$/m);
+  h = host(t);
+  mkdirSync(join(h.root, HOME, ".mosaic-dev", "discord"), { recursive: true });
+  assert.deepEqual(failed(mustRun(h)), []);
+});
+
+// Each P check in its unnamed mark, with the line count each fault makes; none changes the exit.
+const P_FAULTS = {
+  P1: [1, (h) => put(join(h.hc, "sudo-l-mosaic"), "User mosaic may run the following commands on dev-53:\n")],
+  P2: [1, (h) => put(join(h.root, HOME, ".ssh", "authorized_keys"), "ssh-ed25519 AAAA test\n")],
+  P5: [1, (h) => edit(join(h.root, "etc", "group"), (s) => s.replace("docker:x:999:", "docker:x:999:jarvis"))],
+  P6: [2, (h) => edit(join(h.root, "etc", "group"), (s) => s.replace("sudo:x:27:localadmin", "sudo:x:27:localadmin,bob").replace("lxd:x:998:", "lxd:x:998:carol"))],
+  P7: [1, (h) => put(join(h.root, "etc", "sudoers.d", "50-mosaic"), "mosaic ALL=(root) NOPASSWD: /usr/bin/systemctl\n")],
+  P8: [1, (h) => put(join(h.hc, "ss"), `${SS}LISTEN 0 511 0.0.0.0:7331 0.0.0.0:* users:(("node",pid=200,fd=23))\n`)],
+  P9: [3, (h) => { put(join(h.hc, "hostcheck-out"), HOSTCHECK_OK.replace("ok 2 ", "FAIL 2 ").replace("ok 5 ", "FAIL 5 ")); put(join(h.hc, "jarvis-bwrap-rc"), "0"); }],
+  P10: [1, (h) => put(join(h.root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "700\n")],
+  P11: [1, (h) => put(join(h.hc, "show-mosaic-hostcheck.service"), "[email protected] multi-user.target\n")],
+};
+
+test("row 195 accept: each P check reports unnamed on its fault, and the exit stays 0", (t) => {
+  for (const [id, [n, fault]] of Object.entries(P_FAULTS)) {
+    const h = host(t);
+    fault(h);
+    const r = run(h);
+    assert.equal(r.status, 0, `${id}: ${r.out}`);
+    assert.deepEqual(marksOf(r, id), Array(n).fill("unnamed"), `${id}: ${r.out}`);
+  }
+});
+
+test("row 195 accept: P2 is unnamed with a supplementary group, and P5 names docker", (t) => {
+  let h = host(t);
+  put(join(h.root, "etc", "group"), GROUP.replace("lxd:x:998:", "lxd:x:998:mosaic"));
+  let r = run(h);
+  assert.equal(r.status, 0);
+  assert.deepEqual(marksOf(r, "P2"), ["unnamed"]);
+  assert.match(r.out, /^P2 mosaic-groups-keys unnamed id -G is '997 998'; authorized_keys is absent$/m);
+  h = host(t);
+  P_FAULTS.P5[1](h);
+  r = run(h);
+  assert.match(r.out, /^P5 jarvis-reach unnamed jarvis is in docker$/m);
+  assert.match(r.out, /^P6 group-docker unnamed jarvis is a member of docker$/m);
+});
+
+test("row 195 accept: P5 is closed with no jarvis account, and P2 with an empty authorized_keys", (t) => {
+  const h = host(t);
+  put(join(h.root, "etc", "passwd"), PASSWD.replace(/^jarvis:.*\n/m, ""));
+  put(join(h.root, HOME, ".ssh", "authorized_keys"), "");
+  const r = run(h);
+  assert.deepEqual(marksOf(r, "P5"), ["closed"]);
+  assert.deepEqual(marksOf(r, "P2"), ["closed"]);
+});
+
+test("row 195 accept: P9 is unnamed once for each item missing", (t) => {
+  const items = {
+    hostcheck: (h) => put(join(h.hc, "hostcheck-out"), HOSTCHECK_OK.replace("ok 3 ", "FAIL 3 ")),
+    jarvis: (h) => { put(join(h.hc, "jarvis-bwrap-rc"), "0"); put(join(h.hc, "jarvis-bwrap"), ""); },
+    member: (h) => put(join(h.root, "etc", "group"), GROUP.replace("mosaic:x:997:", "mosaic:x:997:jarvis")),
+    gid: (h) => put(join(h.root, "etc", "passwd"), `${PASSWD}hermes:x:1002:997::/home/hermes:/bin/bash\n`),
+  };
+  for (const [name, fault] of Object.entries(items)) {
+    const h = host(t);
+    fault(h);
+    const r = run(h);
+    assert.equal(r.status, 0);
+    assert.deepEqual(marksOf(r, "P9"), ["unnamed"], `${name}: ${r.out}`);
+  }
+  const h = host(t);
+  put(join(h.hc, "hostcheck-out"), "");
+  assert.deepEqual(marksOf(run(h), "P9"), Array(6).fill("unnamed"));
+});
+
+test("row 195 accept: P10 is unnamed with 7333 held by another pid; P11 with the unit disabled", (t) => {
+  let h = host(t);
+  put(join(h.hc, "ss"), SS.replace("pid=200,fd=22", "pid=555,fd=4"));
+  let r = run(h);
+  assert.equal(r.status, 0);
+  assert.deepEqual(marksOf(r, "P10"), ["unnamed"]);
+  h = host(t);
+  put(join(h.hc, "enabled-mosaic-hostcheck.service"), "disabled\n");
+  r = run(h);
+  assert.deepEqual(marksOf(r, "P11"), ["unnamed"]);
+});
+
+test("row 195 accept: every P check unnamed together still exits 0", (t) => {
+  const h = host(t);
+  for (const [, fault] of Object.values(P_FAULTS)) fault(h);
+  const r = run(h);
+  assert.equal(r.status, 0, r.out + r.err);
+  assert.deepEqual(failed(r), []);
+  for (const id of ["P1", "P2", "P5", "P6", "P7", "P8", "P9", "P10", "P11"]) assert.ok(marksOf(r, id).every((m) => m === "unnamed"), id);
+  assert.match(r.lines.at(-1), /^case1-accept: every F check passes/);
+});
+
+test("row 195 accept: a bad args file refuses with exit 2 before any check, each for its own reason", (t) => {
+  const bad = {
+    "group write": [(h) => chmodSync(h.args, 0o664), /dev\.args must be \S+'s with no group or other write \(it is uid \d+, mode 664\)$/],
+    symlink: [(h) => { put(`${h.args}.real`, ARGS.join("\n") + "\n", 0o644); rmSync(h.args); symlinkSync(`${h.args}.real`, h.args); }, /no regular file \/etc\/mosaic-stack\/dev\.args$/],
+    "unknown flag": [(h) => put(h.args, ["--send", ...ARGS].join("\n") + "\n", 0o644), /has --send before --, which case2-unit\.sh does not take$/],
+    "two copies": [(h) => put(h.args, ["--copy", COPY, ...ARGS].join("\n") + "\n", 0o644), /needs exactly one --copy before --, not 2$/],
+    "library profile": [(h) => put(h.args, ARGS.map((a) => (a === "factory" ? "library" : a)).join("\n") + "\n", 0o644), /has --profile 'library', not factory$/],
+    "another business": [(h) => put(h.args, ARGS.map((a, i) => (a === "mosaic-stack" && i < 14 ? "acme" : a)).join("\n") + "\n", 0o644), /is for business acme, not mosaic-stack$/],
+    "no tester port": [(h) => put(h.args, ARGS.slice(0, -2).join("\n") + "\n", 0o644), /lacks a numeric --port or --tester-port after --$/],
+    "short copy": [(h) => put(h.args, ARGS.map((a) => (a === COPY ? "abc123" : a)).join("\n") + "\n", 0o644), /lacks a plain --user, --home, --business, --node, --claude or --copy$/],
+    "no file": [(h) => rmSync(h.args), /no regular file \/etc\/mosaic-stack\/dev\.args$/],
+  };
+  for (const [name, [fault, why]] of Object.entries(bad)) {
+    const h = host(t);
+    fault(h);
+    const r = run(h);
+    assert.equal(r.status, 2, `${name}: ${r.out}${r.err}`);
+    assert.match(r.err.trimEnd(), /^case1-accept: refusing: /, name);
+    assert.match(r.err.trimEnd(), why, name);
+    assert.equal(r.out, "", name);
+    assert.ok(!existsSync(join(h.hc, "calls.log")), name);
+  }
+});
+
+test("row 195 accept: usage errors and a run without --root as a user exit 2", (t) => {
+  const h = host(t);
+  let r = run(h, {}, ["--business", "mosaic-stack", "--args", "/etc/mosaic-stack/dev.args", "--node-pin", NODE_PIN, "--root", h.root]);
+  assert.equal(r.status, 2);
+  assert.match(r.err, /^usage: /);
+  r = run(h, {}, ["--business", "mosaic-stack", "--args", "/etc/mosaic-stack/dev.args", "--claude-pin", CLAUDE_PIN, "--node-pin", "24.1.0", "--root", h.root]);
+  assert.equal(r.status, 2);
+  r = run(h, {}, ["--business", "mosaic-stack", "--args", "/etc/mosaic-stack/dev.args", "--claude-pin", CLAUDE_PIN, "--node-pin", NODE_PIN]);
+  assert.equal(r.status, 2);
+  assert.equal(r.err, "case1-accept: refusing: run it as root\n");
+  assert.ok(!existsSync(join(h.hc, "calls.log")));
+});
+
+test("row 195 accept: every in-instance call goes through sudo -u mosaic -H env PATH=<node dir>:...", (t) => {
+  const h = host(t);
+  const r = run(h);
+  assert.equal(r.status, 0, r.out + r.err);
+  const sudo = calls(h, "sudo");
+  const asMosaic = sudo.filter((a) => a.startsWith("-u mosaic"));
+  for (const a of asMosaic) assert.ok(a.startsWith(`${AS_MOSAIC} /`), a);
+  const cmds = asMosaic.map((a) => a.slice(AS_MOSAIC.length + 1).split(" ")[0]);
+  assert.deepEqual([...new Set(cmds)].sort(), [CLI, PRECHECK, CLAUDE, NODE].sort());
+  assert.deepEqual(sudo.filter((a) => !a.startsWith("-u mosaic")).sort(),
+    ["-l -U localadmin", "-l -U mosaic", "-u jarvis /usr/bin/bwrap --version"]);
+  const talk = calls(h, "mosaic").filter((a) => a.startsWith("talk "));
+  assert.equal(talk.length, 1);
+  assert.match(talk[0], /^talk chief case1-accept-[0-9a-f]{12}: .* --business mosaic-stack --tester --wait 300$/);
+  assert.deepEqual(calls(h, "precheck"), ["--business mosaic-stack --profile factory"]);
+});
+
+test("row 195 accept: the host check runs with --check and never --enforce", (t) => {
+  const h = host(t);
+  run(h);
+  assert.deepEqual(calls(h, "hostcheck"), ["--check"]);
+});
@@ -0,0 +1,335 @@
+// Row 240 (I4, #1746): scripts/case1-hostcheck.sh, the Case 1 host's drift stop for bwrap, and its
+// pins and boot unit. Brief: docs/plans/2026-10-20_installer-rows.md "I4 hostcheck"; design r6 B2
+// (agents/darkwing/work/queue-195/DESIGN.md at b7239bb66). Every case copies the script into a scratch
+// lib directory with a fixture case1-pins.sh beside it and runs it with --root on a scratch host tree.
+// Fake aa-status, dpkg, dpkg-statoverride, apparmor_parser, systemd-run, stat, chown, chmod, apt-get
+// and dpkg-deb on PATH record their argv. Nothing here reads or writes the real /etc, /proc or /usr.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmp } from "./helpers.mjs";
+
+const REPO = fileURLToPath(new URL("../../../", import.meta.url));
+const SCRIPT = join(REPO, "scripts", "case1-hostcheck.sh");
+const PINS = join(REPO, "scripts", "case1-pins.sh");
+const UNIT = join(REPO, "packages", "cli", "systemd", "mosaic-hostcheck.service");
+const PROFILE = "/etc/apparmor.d/bwrap-userns-restrict";
+const LABEL = "bwrap//&unpriv_bwrap (enforce)";
+// A made-up profile; the fixture pins carry its sha256.
+const PROFILE_TEXT = "abi <abi/4.0>,\ninclude <tunables/global>\nprofile bwrap /usr/bin/bwrap flags=(attach_disconnected,mediate_deleted) {\n  allow capability,\n  change_profile /** -> &unpriv_bwrap,\n}\nprofile unpriv_bwrap flags=(attach_disconnected,mediate_deleted) {\n  audit deny capability,\n}\n";
+const sha256 = (s) => createHash("sha256").update(s).digest("hex");
+const AA_OK = { version: "2", profiles: { "/usr/bin/man": "enforce", bwrap: "enforce", unpriv_bwrap: "enforce", "lsb_release": "enforce" }, processes: {} };
+const 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"];
+
+function put(file, text, mode) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, text);
+  if (mode) chmodSync(file, mode);
+}
+
+// Each fake appends `name argv...` to calls.log and answers from a file in the state directory.
+const FAKES = {
+  "aa-status": `[ -f "$HC/aa-rc" ] && exit "$(cat "$HC/aa-rc")"; cat "$HC/aa-status.json"`,
+  dpkg: `case "$1" in
+  -S) [ -f "$HC/owner" ] && cat "$HC/owner"; exit "$(cat "$HC/dpkg-S-rc")" ;;
+  -s) [ "$2" = bubblewrap ] && printf 'Package: bubblewrap\\nStatus: install ok installed\\nVersion: %s\\n' "$(cat "$HC/bwrap-version")" ;;
+  *) exit 2 ;;
+esac`,
+  "dpkg-statoverride": `[ "$1" = --list ] && cat "$HC/statoverride"`,
+  apparmor_parser: `exit 0`,
+  "systemd-run": `cat "$HC/label"`,
+  stat: `cat "$HC/stat"`,
+  chown: `exit 0`,
+  chmod: `exit 0`,
+  "apt-get": `[ -f "$HC/apt-rc" ] && exit "$(cat "$HC/apt-rc")"; [ "$1 $2" = "download apparmor-profiles" ] && cp "$HC/deb" "./apparmor-profiles_9.9_all.deb"`,
+  "dpkg-deb": `case "$1" in
+  -f) [ "$3" = Version ] && echo 9.9-upstream ;;
+  -x) mkdir -p "$3/usr/share/apparmor/extra-profiles"; [ ! -f "$HC/upstream-profile" ] || cp "$HC/upstream-profile" "$3/usr/share/apparmor/extra-profiles/bwrap-userns-restrict" ;;
+esac`,
+};
+
+// A scratch host where all seven items hold.
+function host(t) {
+  const dir = tmp(t, "case1-hostcheck-");
+  const root = join(dir, "root"), hc = join(dir, "hc"), bin = join(dir, "bin"), lib = join(dir, "lib");
+  put(join(root, PROFILE), PROFILE_TEXT);
+  put(join(root, "etc", "apparmor.d", "abstractions", "base"), "  /etc/ld.so.cache r,\n");
+  put(join(root, "etc", "apparmor.d", "tunables", "global"), "@{HOME}=/home/*/\n");
+  put(join(root, "proc", "sys", "kernel", "apparmor_restrict_unprivileged_userns"), "1\n");
+  put(join(root, "proc", "sys", "fs", "protected_hardlinks"), "1\n");
+  put(join(root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "1024\n");
+  put(join(root, "etc", "systemd", "system", "mosaic-webui.service"),
+    "[Service]\nExecStart=/opt/mosaic-stack/node/bin/node /srv/mosaic/copies/x/packages/webui/src/cli.mjs serve --port 732 --business mosaic-stack --tester-port 7333\n");
+  put(join(root, "usr", "bin", "bwrap"), "", 0o755);
+  put(join(hc, "aa-status.json"), JSON.stringify(AA_OK));
+  put(join(hc, "dpkg-S-rc"), "1");
+  put(join(hc, "bwrap-version"), "0.9.0-1ubuntu0.3");
+  put(join(hc, "statoverride"), "root mosaic 0750 /usr/bin/bwrap\n");
+  put(join(hc, "label"), `${LABEL}\n`);
+  put(join(hc, "stat"), "root mosaic 750\n");
+  put(join(hc, "deb"), "fake deb\n");
+  put(join(hc, "upstream-profile"), PROFILE_TEXT);
+  for (const [name, body] of Object.entries(FAKES)) {
+    put(join(bin, name), `#!/usr/bin/env bash\nprintf '%s' ${JSON.stringify(name)} >> "$HC/calls.log"; printf ' %s' "$@" >> "$HC/calls.log"; echo >> "$HC/calls.log"\n${body}\n`, 0o755);
+  }
+  mkdirSync(lib);
+  copyFileSync(SCRIPT, join(lib, "hostcheck.sh"));
+  chmodSync(join(lib, "hostcheck.sh"), 0o755);
+  put(join(lib, "case1-pins.sh"), `PIN_PROFILES_VERSION=4.0.1-fixture\nPIN_PROFILE_SHA256=${sha256(PROFILE_TEXT)}\nPIN_BUBBLEWRAP_VERSION=0.9.0-1ubuntu0.3\n`);
+  return { dir, root, hc, bin, lib, script: join(lib, "hostcheck.sh") };
+}
+
+function run(h, ...args) {
+  const r = spawnSync(h.script, [...args, "--root", h.root], {
+    encoding: "utf8",
+    env: { ...process.env, PATH: `${h.bin}:${process.env.PATH}`, HC: h.hc, TMPDIR: h.dir },
+  });
+  return { status: r.status, out: r.stdout, err: r.stderr, lines: r.stdout.split("\n").filter(Boolean) };
+}
+const calls = (h, name) => (existsSync(join(h.hc, "calls.log")) ? readFileSync(join(h.hc, "calls.log"), "utf8") : "")
+  .split("\n").filter((l) => l === name || l.startsWith(`${name} `)).map((l) => l.slice(name.length + 1));
+const fails = (r) => r.lines.filter((l) => l.startsWith("FAIL "));
+const drift = (h) => join(h.root, "etc", "mosaic-stack", "DRIFT");
+const hlog = (h) => join(h.root, "var", "log", "mosaic-stack", "hostcheck.log");
+const aa = (h, profiles) => put(join(h.hc, "aa-status.json"), JSON.stringify({ version: "2", profiles, processes: {} }));
+
+// One fault per item; each makes that item, and only that one, fail.
+const FAULTS = {
+  1: (h) => put(join(h.root, PROFILE), `${PROFILE_TEXT}# drift\n`),
+  2: (h) => aa(h, { ...AA_OK.profiles, bwrap: "complain" }),
+  3: (h) => put(join(h.root, "etc", "apparmor.d", "usr.bin.other"), "profile other /usr/bin/other {\n  /usr/bin/bwrap ix,\n}\n"),
+  4: (h) => put(join(h.hc, "label"), "unconfined\n"),
+  5: (h) => put(join(h.hc, "statoverride"), "root root 0755 /usr/bin/bwrap\n"),
+  6: (h) => put(join(h.root, "proc", "sys", "kernel", "apparmor_restrict_unprivileged_userns"), "0\n"),
+  7: (h) => put(join(h.root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "700\n"),
+};
+
+test("row 240 check: exits 0 with all seven items and a note that bubblewrap is the install pin", (t) => {
+  const h = host(t);
+  const r = run(h, "--check");
+  assert.equal(r.status, 0, r.out + r.err);
+  assert.deepEqual(r.lines.map((l) => l.split(" ").slice(0, 2).join(" ")), ["ok 1", "ok 2", "ok 3", "ok 4", "ok 5", "ok 6", "ok 7", "note bubblewrap"]);
+  assert.match(r.lines[6], /is 1024, above the Console's --port 732$/);
+  assert.equal(r.lines[7], "note bubblewrap 0.9.0-1ubuntu0.3 is the install pin");
+});
+
+test("row 240 check: exits 1 with each item failing alone, and its line names it", (t) => {
+  for (const [n, fault] of Object.entries(FAULTS)) {
+    const h = host(t);
+    fault(h);
+    const r = run(h, "--check");
+    assert.equal(r.status, 1, `item ${n}: ${r.out}`);
+    assert.deepEqual(fails(r).map((l) => l.split(" ")[1]), [n], `item ${n}: ${r.out}`);
+  }
+});
+
+test("row 240 check: item 1 fails when a package owns the profile, when dpkg -S errs, or with no pin", (t) => {
+  let h = host(t);
+  put(join(h.hc, "dpkg-S-rc"), "0");
+  put(join(h.hc, "owner"), `apparmor-profiles: ${PROFILE}\n`);
+  let r = run(h, "--check");
+  assert.equal(r.status, 1);
+  assert.deepEqual(fails(r), [`FAIL 1 ${PROFILE} is owned by a package: apparmor-profiles: ${PROFILE}`]);
+  assert.deepEqual(calls(h, "dpkg").filter((a) => a.startsWith("-S")), [`-S ${PROFILE}`]);
+  h = host(t);
+  put(join(h.hc, "dpkg-S-rc"), "2");
+  r = run(h, "--check");
+  assert.deepEqual(fails(r), [`FAIL 1 dpkg -S ${PROFILE} exited 2`]);
+  h = host(t);
+  rmSync(join(h.lib, "case1-pins.sh"));
+  r = run(h, "--check");
+  assert.equal(r.status, 1);
+  assert.deepEqual(fails(r), [`FAIL 1 no profile pin in ${h.lib}/case1-pins.sh`]);
+});
+
+test("row 240 check: item 2 fails on a loaded mosaic-bwrap, a missing unpriv_bwrap or a failed aa-status", (t) => {
+  for (const [fault, text] of [
+    [(h) => aa(h, { ...AA_OK.profiles, "mosaic-bwrap": "enforce" }), "a mosaic-bwrap profile"],
+    [(h) => aa(h, { bwrap: "enforce" }), "no unpriv_bwrap profile in enforce mode"],
+    [(h) => put(join(h.hc, "aa-rc"), "1"), "aa-status --json failed"],
+  ]) {
+    const h = host(t);
+    fault(h);
+    const r = run(h, "--check");
+    assert.equal(r.status, 1);
+    assert.equal(fails(r).length, 1, r.out);
+    assert.ok(fails(r)[0].startsWith("FAIL 2 ") && fails(r)[0].includes(text), r.out);
+  }
+});
+
+test("row 240 check: item 3 fails on a second file naming bwrap as a word, /{usr/,}bin/bwrap included", (t) => {
+  for (const text of ["profile x /{usr/,}bin/bwrap {\n}\n", "# runs bwrap\n", "/usr/bin/bwrap ix,\n"]) {
+    const h = host(t);
+    put(join(h.root, "etc", "apparmor.d", "local", "extra"), text);
+    const r = run(h, "--check");
+    assert.equal(r.status, 1, text);
+    assert.deepEqual(fails(r).map((l) => l.split(" ")[1]), ["3"], text);
+    assert.ok(fails(r)[0].includes(join(h.root, "etc", "apparmor.d", "local", "extra")), r.out);
+  }
+  const h = host(t);
+  put(join(h.root, "etc", "apparmor.d", "local", "extra"), "# bwrapper and unpriv-bwrapx are other words\n");
+  assert.equal(run(h, "--check").status, 0);
+});
+
+test("row 240 check: item 4 reads the label under the units' no-new-privs and matches it exactly", (t) => {
+  let h = host(t);
+  assert.equal(run(h, "--check").status, 0);
+  assert.deepEqual(calls(h, "systemd-run"), [SYSTEMD_RUN.join(" ")]);
+  for (const label of ["unpriv_bwrap (enforce)", `${LABEL} `, `x${LABEL}`]) {
+    h = host(t);
+    put(join(h.hc, "label"), `${label}\n`);
+    const r = run(h, "--check");
+    assert.equal(r.status, 1, JSON.stringify(label));
+    assert.deepEqual(fails(r), [`FAIL 4 a bwrap child under no-new-privs has the label '${label}', not '${LABEL}'`]);
+  }
+});
+
+test("row 240 check: item 5 needs the statoverride and stat to agree", (t) => {
+  const h = host(t);
+  put(join(h.hc, "stat"), "root root 700\n");
+  const r = run(h, "--check");
+  assert.deepEqual(fails(r), ["FAIL 5 /usr/bin/bwrap is 'root root 700', not 'root mosaic 750'"]);
+  assert.deepEqual(calls(h, "dpkg-statoverride"), ["--list /usr/bin/bwrap"]);
+  assert.deepEqual(calls(h, "stat"), [`-c %U %G %a ${h.root}/usr/bin/bwrap`]);
+});
+
+test("row 240 check: item 6 fails on protected_hardlinks 0; item 7 fails with the floor at 732 and reads 1023 with no unit", (t) => {
+  let h = host(t);
+  put(join(h.root, "proc", "sys", "fs", "protected_hardlinks"), "0\n");
+  assert.deepEqual(fails(run(h, "--check")).map((l) => l.split(" ")[1]), ["6"]);
+  h = host(t);
+  put(join(h.root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "732\n");
+  assert.deepEqual(fails(run(h, "--check")), ["FAIL 7 net.ipv4.ip_unprivileged_port_start is 732, not above the Console's --port 732"]);
+  put(join(h.root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "733\n");
+  assert.equal(run(h, "--check").status, 0);
+  rmSync(join(h.root, "etc", "systemd", "system", "mosaic-webui.service"));
+  assert.deepEqual(fails(run(h, "--check")), ["FAIL 7 net.ipv4.ip_unprivileged_port_start is 733, not above 1023, because no Console unit is installed"]);
+  put(join(h.root, "proc", "sys", "net", "ipv4", "ip_unprivileged_port_start"), "1024\n");
+  assert.equal(run(h, "--check").status, 0);
+  put(join(h.root, "etc", "systemd", "system", "mosaic-webui.service"), "[Service]\nExecStart=/x serve --business mosaic-stack --tester-port 7333\n");
+  assert.deepEqual(fails(run(h, "--check")), ["FAIL 7 /etc/systemd/system/mosaic-webui.service has no --port"]);
+});
+
+test("row 240 check: a bubblewrap version other than the install pin is a note, not a failure", (t) => {
+  const h = host(t);
+  put(join(h.hc, "bwrap-version"), "0.9.0-1ubuntu0.4");
+  const r = run(h, "--check");
+  assert.equal(r.status, 0);
+  assert.equal(r.lines.at(-1), "note bubblewrap 0.9.0-1ubuntu0.4 is not the install pin 0.9.0-1ubuntu0.3, which is not a drift item");
+});
+
+test("row 240 enforce: a pass with no DRIFT changes nothing and exits 0", (t) => {
+  const h = host(t);
+  const r = run(h, "--enforce");
+  assert.equal(r.status, 0);
+  assert.equal(r.lines.at(-1), "hostcheck: all seven hold");
+  assert.deepEqual([calls(h, "apparmor_parser"), calls(h, "chown"), calls(h, "chmod")], [[], [], []]);
+  assert.equal(existsSync(drift(h)) || existsSync(hlog(h)), false);
+});
+
+test("row 240 enforce: each failure exits 0, unloads the profile, closes bwrap, writes DRIFT and one log line", (t) => {
+  for (const [n, fault] of Object.entries(FAULTS)) {
+    const h = host(t);
+    fault(h);
+    const r = run(h, "--enforce");
+    assert.equal(r.status, 0, `item ${n}: ${r.out}${r.err}`);
+    assert.deepEqual(calls(h, "apparmor_parser"), [`-R ${h.root}${PROFILE}`], `item ${n}`);
+    assert.deepEqual(calls(h, "chown"), [`root:root ${h.root}/usr/bin/bwrap`], `item ${n}`);
+    assert.deepEqual(calls(h, "chmod"), [`0700 ${h.root}/usr/bin/bwrap`], `item ${n}`);
+    const d = readFileSync(drift(h), "utf8").split("\n").filter(Boolean);
+    assert.equal(d.length, 1, `item ${n}`);
+    assert.match(d[0], new RegExp(`^\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\dZ ${n} `), `item ${n}`);
+    const l = readFileSync(hlog(h), "utf8").split("\n").filter(Boolean);
+    assert.equal(l.length, 1, `item ${n}`);
+    assert.match(l[0], new RegExp(`^\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\dZ enforce stop items=${n} drift-before=0 unload=rc=0 chown=0 chmod=0$`), `item ${n}`);
+  }
+});
+
+test("row 240 enforce: with DRIFT present and every item passing, it still closes bwrap", (t) => {
+  const h = host(t);
+  put(drift(h), "2026-10-20T00:00:00Z 1 an earlier drift\n");
+  const r = run(h, "--enforce");
+  assert.equal(r.status, 0);
+  assert.equal(fails(r).length, 0);
+  assert.deepEqual(calls(h, "chown"), [`root:root ${h.root}/usr/bin/bwrap`]);
+  assert.deepEqual(calls(h, "chmod"), [`0700 ${h.root}/usr/bin/bwrap`]);
+  assert.equal(readFileSync(drift(h), "utf8"), "2026-10-20T00:00:00Z 1 an earlier drift\n");
+  assert.match(readFileSync(hlog(h), "utf8"), /Z enforce stop items=none drift-before=1 unload=rc=0 chown=0 chmod=0\n$/);
+});
+
+test("row 240 enforce: no unload when aa-status lists neither bwrap profile; never writes the statoverride", (t) => {
+  const h = host(t);
+  aa(h, { "/usr/bin/man": "enforce" });
+  const r = run(h, "--enforce");
+  assert.equal(r.status, 0);
+  assert.deepEqual(calls(h, "apparmor_parser"), []);
+  assert.deepEqual(calls(h, "chmod"), [`0700 ${h.root}/usr/bin/bwrap`]);
+  assert.match(readFileSync(hlog(h), "utf8"), /Z enforce stop items=2 drift-before=0 unload=skipped chown=0 chmod=0\n$/);
+  for (const [n, fault] of Object.entries(FAULTS)) {
+    const g = host(t);
+    fault(g);
+    run(g, "--enforce");
+    for (const a of calls(g, "dpkg-statoverride")) assert.doesNotMatch(a, /--(update|add|remove)/, `item ${n}`);
+    assert.deepEqual(calls(g, "dpkg-statoverride"), ["--list /usr/bin/bwrap"], `item ${n}`);
+  }
+});
+
+test("row 240 upstream: a candidate whose profile differs prints the difference and exits 0", (t) => {
+  let h = host(t);
+  put(join(h.hc, "upstream-profile"), `${PROFILE_TEXT}  # upstream change\n`);
+  let r = run(h, "--upstream");
+  assert.equal(r.status, 0, r.err);
+  assert.match(r.out, new RegExp(`^upstream: DIFFERS: apparmor-profiles 9.9-upstream's bwrap-userns-restrict has sha256 ${sha256(`${PROFILE_TEXT}  # upstream change\n`)}; the pin is ${sha256(PROFILE_TEXT)} from 4.0.1-fixture\\.`));
+  assert.match(r.out, /^\+ {2}# upstream change$/m);
+  assert.deepEqual(calls(h, "apt-get"), ["download apparmor-profiles"]);
+  assert.deepEqual([calls(h, "chown"), calls(h, "chmod"), existsSync(drift(h))], [[], [], false]);
+  h = host(t);
+  r = run(h, "--upstream");
+  assert.equal(r.status, 0);
+  assert.equal(r.out, "upstream: apparmor-profiles 9.9-upstream's bwrap-userns-restrict matches the pin from 4.0.1-fixture\n");
+  h = host(t);
+  rmSync(join(h.hc, "upstream-profile"));
+  r = run(h, "--upstream");
+  assert.equal(r.status, 0);
+  assert.match(r.out, /^upstream: DIFFERS: apparmor-profiles 9.9-upstream has no bwrap-userns-restrict;/);
+  h = host(t);
+  put(join(h.hc, "apt-rc"), "100");
+  r = run(h, "--upstream");
+  assert.equal(r.status, 1);
+  assert.equal(r.err, "hostcheck: upstream: apt-get download apparmor-profiles failed\n");
+});
+
+test("row 240 boot unit: a oneshot after apparmor and before the bus that runs --enforce", () => {
+  const text = readFileSync(UNIT, "utf8");
+  const lines = text.split("\n").filter((l) => l && !l.startsWith("#"));
+  assert.deepEqual(lines.filter((l) => /^(Type|After|Before|ExecStart|WantedBy)=/.test(l)), [
+    "After=apparmor.service",
+    "[email protected]",
+    "Type=oneshot",
+    "ExecStart=/usr/local/lib/mosaic-stack/hostcheck.sh --enforce",
+    "WantedBy=multi-user.target",
+  ]);
+});
+
+test("row 240 pins and usage: the shipped pins are r6's, the script reads the pins beside it, and bad usage exits 2", (t) => {
+  assert.equal(readFileSync(PINS, "utf8").split("\n").filter((l) => /^PIN_/.test(l)).join("\n"),
+    "PIN_PROFILES_VERSION=4.0.1really4.0.1-0ubuntu0.24.04.9\nPIN_PROFILE_SHA256=11d39094f044f0cda0febb3ad517b830301da6b2ce929664af09ee9e4dd264f9\nPIN_BUBBLEWRAP_VERSION=0.9.0-1ubuntu0.3");
+  const h = host(t);
+  const r = run({ ...h, script: SCRIPT }, "--check");
+  assert.equal(r.status, 1);
+  assert.deepEqual(fails(r), [`FAIL 1 ${PROFILE} sha256 is ${sha256(PROFILE_TEXT)}, not the pin 11d39094f044f0cda0febb3ad517b830301da6b2ce929664af09ee9e4dd264f9`]);
+  for (const args of [[], ["--check", "--enforce"], ["--check", "--root", "relative"], ["--status"]]) {
+    const u = spawnSync(h.script, args, { encoding: "utf8", env: { ...process.env, PATH: `${h.bin}:${process.env.PATH}`, HC: h.hc } });
+    assert.equal(u.status, 2, args.join(" "));
+  }
+  if (process.getuid() !== 0) {
+    const u = spawnSync(h.script, ["--check"], { encoding: "utf8", env: { ...process.env, PATH: `${h.bin}:${process.env.PATH}`, HC: h.hc } });
+    assert.deepEqual([u.status, u.stderr], [2, "hostcheck: refusing: run it as root\n"]);
+  }
+});
@@ -1683,6 +1683,14 @@ test('T57 row 200: activate --sso, its refusals before any stop, and the rollbac
  assert.ok(stepText(a).includes(`Z drop --sso; ${B}'s Console does not support it, so the Console flags come from ${set}/${show}\n`));
  await noLeak(a);
 });
+ await t.test('row 238 (#1744): on a named instance the sso-config first step names --instance NAME in both commands',async(t)=>{
+  const e=await mk(t),a=await named(e,'alpha');await seed(a);
+  assert.equal(JSON.parse(readFileSync(a.cfg,'utf8')).console,undefined);
+  await refused(a,['activate',C1,'acme','--sso'],'sso-config',`${C1}'s Console would refuse its --sso start: there is no console.sso in the system config; activate ${C1} --instance alpha without --sso first, then write console.sso, then run activate ${C1} --instance alpha --sso`);
+  const out=await planOnly(a,3,'activate',C1,'acme','--sso');
+  assert.ok(out.includes(`refuses sso-config: ${C1}'s Console would refuse its --sso start: there is no console.sso in the system config; activate ${C1} --instance alpha without --sso first, then write console.sso, then run activate ${C1} --instance alpha --sso`),out.join('\n'));
+  await noLeak(a);
+ });
 });

 // --- rehearse (D2, row 163; the brief's "Stack rehearsal on a scratch root") ---
@@ -140,7 +140,7 @@ const arm=(e,key,text)=>writeFileSync(join(e.sd,'arm',key),text);

 // The step log: every line `<time> <step> rc=N ...` or the result line, root:root 0640 (here the
 // test user's), and nothing the stack's user printed. Returns the lines without the time.
-const STEP=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ (start|fetch|ff|copy|hostcheck|units|plan|rehearse|rehearse-store|rehearsal-skipped|stop-console|stop-bus|wait-down|stage|render|confirm|args|revert|render-old|confirm-rollback|gate|start-bus|start-console|stop-units) rc=\d+ |^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ result exit=[0-3] [a-z-]+ /;
+const STEP=/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ (start|fetch|ff|copy|hostcheck|units|plan|rehearse|rehearse-store|rehearsal-skipped|stop-console|stop-bus|wait-down|stage|render|confirm|args|revert|render-old|confirm-rollback|gate|start-bus|start-console|stop-units) rc=\d+ |^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ result exit=[0-35] [a-z-]+ /;
 function slog(e){
 const l=lines(e.slog);
 for(const x of l){assert.match(x,STEP);assert.ok(!/stack-release:|fixture rehearse|PASS |FAIL |REHEARSAL/.test(x),x)}
@@ -292,6 +292,21 @@ test('row 233: sequence 7: two upgrades and a rollback --to the previous copy wi
 assert.equal(lines(join(e.sd,'root-systemctl.log')).length,sc);assert.equal(argsCopy(e),C1);
 });

+test('row 240: I3 N1: a failed args move after A5 exits 5 args-failed, the new copy live and confirmed and both args files kept',async(t)=>{
+ const e=await useed(t);
+ // A read-only /etc/mosaic-stack at confirm: the stage and the render are done, and the move fails.
+ // The fixture's cleanup runs chmod -R u+w before it removes the root, so the 0555 dir needs no hook here.
+ arm(e,'confirm.sh',`chmod 0555 ${e.etc}\n`);
+ const l=await upgrade(e,C1);assert.equal(l.code,5,l.all);
+ assert.deepEqual(names(e),[...PRE,...A2,'stage','render','confirm','args','result']);
+ assert.ok(slog(e).includes(`args rc=1 copy: ${C1}`));
+ assert.match(result(e),new RegExp(`^result exit=5 args-failed ${C1} is live and confirmed, but ${e.args} still names ${B}; put ${e.etc}/\\.dev\\.args\\.\\w{6} in its place$`));
+ assert.deepEqual(open(e),[]);assert.deepEqual(live(e),['active','active',C1,C1]);
+ assert.equal(readFileSync(e.args,'utf8'),e.argsText);
+ const left=readdirSync(e.etc).filter((n)=>n!=='dev.args');assert.equal(left.length,1);
+ assert.equal(readFileSync(join(e.etc,left[0]),'utf8'),e.argsText.replace(`--copy\n${B}\n`,`--copy\n${C1}\n`));
+});
+
 test('row 233: sequence 8: a migration that writes and fails: the driver reverts to the backup byte for byte, --cause A3: exit 1',async(t)=>{
 const e=await useed(t);
 const s0=sha(e.store);
@@ -83,7 +83,7 @@ export function threadStore(dataRoot, business, thread) {
 export const ENV_ALLOW = Object.freeze([
  "HOME", "USER", "LOGNAME", "LANG", "LC_ALL", "TZ", "TERM",
  "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "CLAUDE_CODE_OAUTH_TOKEN",
-  "OPENAI_API_KEY", "OPENROUTER_API_KEY",
+  "OPENAI_API_KEY", "OPENROUTER_API_KEY", "ZAI_API_KEY",
  "MOSAIC_CLAUDE_BIN",
 ]);

@@ -58,6 +58,13 @@ test("sessionEnv passes only the allowlist, the repo's bin on PATH, and the run
  assert.equal(sessionEnv({ MOSAIC_CLAUDE_BIN: "/opt/claude" }, "r0123456789ab").MOSAIC_CLAUDE_BIN, "/opt/claude");
 });

+test("ZAI_API_KEY passes the session allowlist, and ZAI_TOKEN does not", () => {
+  assert.ok(ENV_ALLOW.includes("ZAI_API_KEY"));
+  const env = sessionEnv({ ZAI_API_KEY: "fixture-zai", ZAI_TOKEN: "t" }, "r0123456789ab");
+  assert.equal(env.ZAI_API_KEY, "fixture-zai");
+  assert.equal(Object.hasOwn(env, "ZAI_TOKEN"), false);
+});
+
 test("sessionExit gives a runner's signal death back as the signal; a session credential is one whole set of nonempty variables", () => {
  assert.deepEqual(sessionExit(0, null), { code: 0, signal: null });
  assert.deepEqual(sessionExit(23, null), { code: 23, signal: null });
@@ -0,0 +1,465 @@
+#!/usr/bin/env bash
+# Row 195 (#1693): the Case 1 acceptance on 10.1.1.53, design r7 section 5
+# (agents/darkwing/work/queue-195/DESIGN.md). Deviations and decisions: agents/darkwing/work/queue-195/BUILD.md.
+#
+#   case1-accept.sh --business ID --args FILE --claude-pin PIN --node-pin vN.N.N
+#
+# Root runs it on the Case 1 host after the install window, from a root-owned checkout. It reads the
+# user, home, copy, node, claude and both ports from the args file, which must pass stack-upgrade.sh's
+# rules and be a factory file for --business. Every command that runs the stack's code runs as
+# `sudo -u USER -H env PATH=<node dir>:/usr/local/bin:/usr/bin:/bin` from /. Root itself reads ss,
+# /proc, the account database and file metadata, and runs these: systemctl show and is-enabled (F1,
+# P11), curl on the Console's loopback healthz (F2), sudo -l (P1, P3), sudo -u jarvis bwrap --version
+# and hostcheck.sh --check (P9), and node to parse managed-settings.json (F9). F9 runs node only when
+# --node is the pinned path and it and every directory above it are root's with no group or other
+# write. The script changes nothing on the host but the message F3 sends and its reply, and it never
+# opens claude-session.env.
+#
+# One line per check, `<id> <path> <mark> <evidence>`, then `count <mark> N` for each mark and a
+# result line. F checks are `pass` or `FAIL`. P checks are `closed`, `accepted <ruling>` or
+# `unnamed`, which means no Q182, Q183 or Mos ruling names the path; each unnamed line goes to Mos.
+#
+# Exit 0 when every F check passes, 1 when one fails, 2 on usage or a refusal (a bad args file, or
+# --root misused). A P check never changes the exit.
+#
+# Test seam, for packages/cli/tests/case1-accept.test.mjs only. Root takes none:
+#   --root DIR   prefixes the args file, /etc, /proc, the stack's home, the host check and node, and
+#                reads the account database from DIR/etc/passwd and DIR/etc/group instead of getent
+set -uo pipefail
+
+usage() { echo "usage: case1-accept.sh --business ID --args FILE --claude-pin PIN --node-pin vN.N.N" >&2; exit 2; }
+refuse() { echo "case1-accept: refusing: $*" >&2; exit 2; }
+BUSINESS="" ARGS_FILE="" CLAUDE_PIN="" NODE_PIN="" ROOT=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --business) [ $# -ge 2 ] && [[ "$2" =~ ^[a-z0-9][a-z0-9-]*$ ]] || usage; BUSINESS="$2"; shift 2 ;;
+        --args) [ $# -ge 2 ] && [[ "$2" =~ ^/[A-Za-z0-9/._+-]+$ ]] || usage; ARGS_FILE="$2"; shift 2 ;;
+        --claude-pin) [ $# -ge 2 ] && [[ "$2" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || usage; CLAUDE_PIN="$2"; shift 2 ;;
+        --node-pin) [ $# -ge 2 ] && [[ "$2" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]] || usage; NODE_PIN="$2"; shift 2 ;;
+        --root) [ $# -ge 2 ] && [[ "$2" =~ ^/[A-Za-z0-9/._+-]+$ ]] && [ -d "$2" ] || usage; ROOT="${2%/}"; shift 2 ;;
+        *) usage ;;
+    esac
+done
+[ -n "$BUSINESS" ] && [ -n "$ARGS_FILE" ] && [ -n "$CLAUDE_PIN" ] && [ -n "$NODE_PIN" ] || usage
+if [ "$(id -u)" = 0 ]; then
+    [ -z "$ROOT" ] || refuse "--root is a test seam, and root takes none"
+    PATH=/usr/sbin:/usr/bin:/sbin:/bin
+else
+    [ -n "$ROOT" ] || refuse "run it as root"
+fi
+cd / || refuse "cannot cd to /"
+
+# --- The args file, by stack-upgrade.sh's read_args rules, plus the serve ports ---
+
+f="$ROOT$ARGS_FILE"
+[ -f "$f" ] && [ ! -L "$f" ] || refuse "no regular file $ARGS_FILE"
+st="$(stat -c '%u %a' -- "$f")" || refuse "cannot stat $ARGS_FILE"
+[ "${st% *}" = "$(id -u)" ] && (( (8#${st#* } & 8#022) == 0 )) ||
+    refuse "$ARGS_FILE must be $(id -un)'s with no group or other write (it is uid ${st% *}, mode ${st#* })"
+mapfile -t ARGS < "$f" || refuse "cannot read $ARGS_FILE"
+S_USER="" S_HOME="" A_BUSINESS="" NODE="" COPY_ID="" CLAUDE="" PROFILE="" PORT="" TESTER_PORT=""
+copies=0 past=""
+for ((i = 0; i < ${#ARGS[@]}; i++)); do
+    a="${ARGS[i]}" v="${ARGS[i + 1]:-}"
+    if [ -n "$past" ]; then
+        case "$a" in --port) PORT="$v"; i=$((i + 1)) ;; --tester-port) TESTER_PORT="$v"; i=$((i + 1)) ;; esac
+        continue
+    fi
+    case "$a" in
+        --) past=1 ;;
+        --pm) ;;
+        --user) S_USER="$v"; i=$((i + 1)) ;;
+        --home) S_HOME="$v"; i=$((i + 1)) ;;
+        --business) A_BUSINESS="$v"; i=$((i + 1)) ;;
+        --node) NODE="$v"; i=$((i + 1)) ;;
+        --claude) CLAUDE="$v"; i=$((i + 1)) ;;
+        --profile) PROFILE="$v"; i=$((i + 1)) ;;
+        --copy) COPY_ID="$v"; copies=$((copies + 1)); i=$((i + 1)) ;;
+        *) refuse "$ARGS_FILE has $a before --, which case2-unit.sh does not take" ;;
+    esac
+done
+[ "$copies" = 1 ] || refuse "$ARGS_FILE needs exactly one --copy before --, not $copies"
+[[ "$S_USER" =~ ^[a-z_][a-z0-9_-]*$ ]] && [[ "$S_HOME" =~ ^/[A-Za-z0-9/._+-]+$ ]] && [[ "$A_BUSINESS" =~ ^[a-z0-9][a-z0-9-]*$ ]] &&
+    [[ "$NODE" =~ ^/[A-Za-z0-9/._+-]+$ ]] && [[ "$COPY_ID" =~ ^[0-9a-f]{40}$ ]] && [[ "$CLAUDE" =~ ^/[A-Za-z0-9/._+@-]+$ ]] ||
+    refuse "$ARGS_FILE lacks a plain --user, --home, --business, --node, --claude or --copy"
+[ "$PROFILE" = factory ] || refuse "$ARGS_FILE has --profile '${PROFILE}', not factory"
+[ "$A_BUSINESS" = "$BUSINESS" ] || refuse "$ARGS_FILE is for business $A_BUSINESS, not $BUSINESS"
+[[ "$PORT" =~ ^[1-9][0-9]{0,4}$ ]] && [[ "$TESTER_PORT" =~ ^[1-9][0-9]{0,4}$ ]] ||
+    refuse "$ARGS_FILE lacks a numeric --port or --tester-port after --"
+
+COPY="$S_HOME/.local/share/mosaic-stack/copies/$COPY_ID"
+DATA_ROOT="$S_HOME/.mosaic-dev"
+CRED="$S_HOME/.config/mosaic-dev/secrets/claude-session.env"
+BUSINESS_FILE="$S_HOME/.config/mosaic-dev/businesses/$BUSINESS.json"
+BUS_UNIT="mosaic-bus@$BUSINESS.service" CON_UNIT=mosaic-webui.service
+HOSTCHECK=/usr/local/lib/mosaic-stack/hostcheck.sh
+SETTINGS=/etc/claude-code/managed-settings.json
+LABEL_OUTER='bwrap (enforce)' LABEL_CHILD='bwrap//&unpriv_bwrap (enforce)'
+AS_USER=(sudo -u "$S_USER" -H env "PATH=$(dirname "$NODE"):/usr/local/bin:/usr/bin:/bin")
+WORK="$(mktemp -d)" || refuse "cannot make a temp dir"
+trap 'rm -rf -- "$WORK"' EXIT
+
+# --- Output ---
+
+MARKS=(pass FAIL closed "accepted Q182+Q183" "accepted Q183" "accepted mos-1096" "accepted mos-1101" unnamed)
+declare -A COUNT=()
+F_FAILED=0
+# Text the stack's user wrote, made safe to print: printable ASCII, one line, at most 200 bytes.
+clean() { tr -c '[:print:]' ' ' <<< "$1" | cut -c1-200 | sed 's/ *$//'; }
+line() { local id="$1" path="$2" mark="$3"; shift 3; echo "$id $path $mark $*"; COUNT[$mark]=$(( ${COUNT[$mark]:-0} + 1 )); }
+fpass() { line "$1" "$2" pass "${@:3}"; }
+ffail() { line "$1" "$2" FAIL "${@:3}"; F_FAILED=1; }
+
+# --- The account database: getent on the host, the seam's files under --root ---
+
+db() {
+    if [ -n "$ROOT" ]; then
+        if [ $# -gt 1 ]; then awk -F: -v k="$2" '$1 == k' "$ROOT/etc/$1"; else cat "$ROOT/etc/$1"; fi
+    else
+        getent "$@"
+    fi
+}
+uid_of() { db passwd "$1" | cut -d: -f3; }
+gid_of() { db passwd "$1" | cut -d: -f4; }
+# The group ids USER belongs to, as `id -G USER` prints them: the primary gid, then each group
+# whose member list names USER.
+groups_of() {
+    local g; g="$(gid_of "$1")"
+    [ -n "$g" ] || return 0
+    { echo "$g"; db group | awk -F: -v u="$1" '{ n = split($4, m, ","); for (i = 1; i <= n; i++) if (m[i] == u) print $3 }'; } | awk '!seen[$0]++'
+}
+names_of_groups() { local g; for g in "$@"; do db group | awk -F: -v g="$g" '$3 == g { print $1 }'; done; }
+MOSAIC_UID="$(uid_of "$S_USER")"
+
+# --- systemd, /proc and listeners ---
+
+# KEY=VALUE lines for UNIT's properties.
+unit_show() { local u="$1"; shift; systemctl show "$u" "${@/#/-p}" 2>/dev/null; }
+prop() { sed -n "s/^$2=//p" <<< "$1" | tail -n 1; }
+# The real, effective, saved and filesystem uids of PID, space-separated.
+proc_uids() { awk '$1 == "Uid:" { print $2, $3, $4, $5 }' "$ROOT/proc/$1/status" 2>/dev/null; }
+proc_label() { local l; l="$(cat "$ROOT/proc/$1/attr/current" 2>/dev/null)" || return 1; printf '%s' "${l%$'\n'}"; }
+# One `ADDRESS PIDS` line per TCP listener on port $1, PIDS comma-separated.
+listeners() {
+    ss -Hltnp 2>/dev/null | awk -v p="$1" '{
+        n = split($4, a, ":"); if (a[n] != p) next
+        addr = substr($4, 1, length($4) - length(p) - 1); pids = ""; s = $0
+        while (match(s, /pid=[0-9]+/)) { pids = pids (pids == "" ? "" : ",") substr(s, RSTART + 4, RLENGTH - 4); s = substr(s, RSTART + RLENGTH) }
+        print addr, pids
+    }'
+}
+# 0 when port $1 has a listener and every one is on 127.0.0.1, held by pid $2 alone.
+loopback_by() {
+    local addr pids p any=0
+    [ -n "$2" ] && [ "$2" != 0 ] || return 1
+    while read -r addr pids; do
+        [ -n "$addr" ] || continue
+        any=1
+        [ "$addr" = 127.0.0.1 ] || return 1
+        for p in ${pids//,/ }; do [ "$p" = "$2" ] || return 1; done
+        [ -n "$pids" ] || return 1
+    done <<< "$(listeners "$1")"
+    [ "$any" = 1 ]
+}
+listener_text() { local t; t="$(listeners "$1" | tr '\n' ';')"; echo "${t:-none}"; }
+
+BUS_SHOW="$(unit_show "$BUS_UNIT" ActiveState User MainPID)"
+CON_SHOW="$(unit_show "$CON_UNIT" ActiveState User MainPID)"
+CON_PID="$(prop "$CON_SHOW" MainPID)"
+
+# --- F checks ---
+
+check_f1() {
+    local u show state user pid uids why=""
+    for u in "$BUS_UNIT" "$CON_UNIT"; do
+        if [ "$u" = "$BUS_UNIT" ]; then show="$BUS_SHOW"; else show="$CON_SHOW"; fi
+        state="$(prop "$show" ActiveState)" user="$(prop "$show" User)" pid="$(prop "$show" MainPID)"
+        uids="$(proc_uids "${pid:-0}")"
+        [ "$state" = active ] || { why+="$u is ${state:-unknown}; "; continue; }
+        [ "$user" = "$S_USER" ] || { why+="$u has User=${user:-unset}; "; continue; }
+        [ -n "$MOSAIC_UID" ] && [ "$uids" = "$MOSAIC_UID $MOSAIC_UID $MOSAIC_UID $MOSAIC_UID" ] ||
+            why+="$u MainPID ${pid:-none} has uids '${uids:-unreadable}', not $S_USER's ${MOSAIC_UID:-unknown}; "
+    done
+    if [ -z "$why" ]; then fpass F1 units-user "$BUS_UNIT and $CON_UNIT are active as $S_USER (uid $MOSAIC_UID)"
+    else ffail F1 units-user "${why%; }"; fi
+}
+
+check_f2() {
+    local rc=0
+    curl -fsS --max-time 10 -o /dev/null "http://127.0.0.1:$PORT/healthz" 2>/dev/null || rc=$?
+    if [ "$rc" != 0 ]; then ffail F2 console-loopback "curl http://127.0.0.1:$PORT/healthz exited $rc"
+    elif ! loopback_by "$PORT" "$CON_PID"; then ffail F2 console-loopback "port $PORT listeners are '$(listener_text "$PORT")', not 127.0.0.1 by the Console's MainPID ${CON_PID:-none}"
+    else fpass F2 console-loopback "healthz answers, and $PORT is bound to 127.0.0.1 only, by MainPID $CON_PID"; fi
+}
+
+# F5's scan: an outer /usr/bin/bwrap owned by the stack's user with a claude descendant. Sets F5_OK
+# when one pair has both labels exactly, F5_WHY to the last mismatch otherwise.
+F5_OK="" F5_WHY="no /usr/bin/bwrap process of $S_USER with a claude descendant was seen while the reply was pending"
+scan_f5() {
+    local pid ppid uids kids q c argv0 comm lo lc
+    local -A parent=() children=() bw=()
+    # One read of every PPid line and one of every exe link, so a scan stays short on a busy host.
+    while read -r pid ppid; do
+        parent[$pid]="$ppid" children[$ppid]+=" $pid"
+    done < <(grep -H '^PPid:' "$ROOT"/proc/[0-9]*/status 2>/dev/null | sed -n 's#^.*/proc/\([0-9]*\)/status:PPid:[[:space:]]*\([0-9]*\)$#\1 \2#p')
+    while read -r pid; do
+        [[ "$pid" =~ ^[0-9]+$ ]] && [ -n "${parent[$pid]:-}" ] && bw[$pid]=1
+    done < <(find "$ROOT/proc" -mindepth 2 -maxdepth 2 -name exe -lname /usr/bin/bwrap -printf '%h\n' 2>/dev/null | sed 's#.*/##')
+    for pid in "${!bw[@]}"; do
+        [ -z "${bw[${parent[$pid]}]:-}" ] || continue
+        uids="$(proc_uids "$pid")"
+        [ -n "$MOSAIC_UID" ] && [ "${uids%% *}" = "$MOSAIC_UID" ] || continue
+        # Every descendant, breadth first.
+        kids=() q=("$pid")
+        while [ ${#q[@]} -gt 0 ]; do
+            for c in ${children[${q[0]}]:-}; do kids+=("$c") q+=("$c"); done
+            q=("${q[@]:1}")
+        done
+        for c in "${kids[@]}"; do
+            argv0="$(tr '\0' '\n' < "$ROOT/proc/$c/cmdline" 2>/dev/null | sed -n 1p)"
+            comm="$(cat "$ROOT/proc/$c/comm" 2>/dev/null)"
+            [[ "${argv0##*/}" == claude* ]] || [[ "$comm" == claude* ]] || continue
+            lo="$(proc_label "$pid")" lc="$(proc_label "$c")"
+            if [ "$lo" = "$LABEL_OUTER" ] && [ "$lc" = "$LABEL_CHILD" ]; then
+                F5_OK="bwrap $pid reads '$lo' and its claude descendant $c reads '$lc'"; return 0
+            fi
+            F5_WHY="bwrap $pid reads '$lo' and its claude descendant $c reads '$lc', not '$LABEL_OUTER' and '$LABEL_CHILD'"
+        done
+    done
+    return 1
+}
+
+# F3 and F5 together: the message goes out in the background and the scan runs until it is answered.
+check_f3_f5() {
+    local marker text rc=0 out err n tpid
+    marker="case1-accept-$(od -An -N6 -tx1 /dev/urandom | tr -d ' \n')"
+    text="$marker: this is the Case 1 acceptance; reply with one short line."
+    timeout 330 "${AS_USER[@]}" "$COPY/scripts/mosaic" talk chief "$text" --business "$BUSINESS" --tester --wait 300 > "$WORK/talk.out" 2> "$WORK/talk.err" &
+    tpid=$!
+    while :; do
+        scan_f5 && break
+        kill -0 "$tpid" 2>/dev/null || break
+        sleep 0.5
+    done
+    wait "$tpid" || rc=$?
+    # Both the sent line and the reply are on stdout; an error is on stderr.
+    out="$(cat "$WORK/talk.out")" err="$(cat "$WORK/talk.err")"
+    n="$(grep -c . <<< "$out")"
+    if [ "$rc" = 0 ] && grep -q "^sent [^ ]* to chief" <<< "$out" && [ "$n" -ge 2 ]; then
+        fpass F3 tester-reply "chief replied to $marker"
+    else
+        ffail F3 tester-reply "talk exited $rc with $n lines on stdout; last: $(clean "$(tail -n 1 <<< "${err:-$out}")")"
+    fi
+    if [ -n "$F5_OK" ]; then F5_LINE=(fpass "$F5_OK"); else F5_LINE=(ffail "$F5_WHY"); fi
+}
+
+check_f4() {
+    local rc=0 out
+    out="$("${AS_USER[@]}" "$COPY/scripts/case2-precheck.sh" --business "$BUSINESS" --profile factory 2>&1)" || rc=$?
+    if [ "$rc" = 0 ]; then fpass F4 precheck "case2-precheck.sh --profile factory exits 0"
+    else ffail F4 precheck "case2-precheck.sh --profile factory exited $rc; last: $(clean "$(tail -n 1 <<< "$out")")"; fi
+}
+
+check_f6() {
+    local want="/opt/mosaic-stack/claude-$CLAUDE_PIN/" v
+    [[ "$CLAUDE" == "$want"* ]] || { ffail F6 claude-pin "--claude $CLAUDE is not under $want"; return; }
+    [[ "$CLAUDE/" != */../* ]] || { ffail F6 claude-pin "--claude $CLAUDE has a .. segment"; return; }
+    v="$("${AS_USER[@]}" "$CLAUDE" --version 2>/dev/null | sed -n 1p)"
+    if [ "$v" = "$CLAUDE_PIN (Claude Code)" ]; then fpass F6 claude-pin "$CLAUDE prints '$v'"
+    else ffail F6 claude-pin "$CLAUDE --version prints '$(clean "$v")', not '$CLAUDE_PIN (Claude Code)'"; fi
+}
+
+# The PM check confirm runs (stack-release.sh pm_external): exactly one live launches list entry for
+# launch.by, for this business. The stack's user runs the whole check and prints one result line.
+F7_JS='
+const {readFileSync}=require("node:fs");const {spawnSync}=require("node:child_process");
+const [file,cli,b]=process.argv.slice(1);
+let by;
+try{by=JSON.parse(readFileSync(file,"utf8")).launch?.by}catch(e){console.log(`fail cannot read ${file}: ${e.code??"not JSON"}`);process.exit(0)}
+if(typeof by!=="string"||!by){console.log("fail the business file has no launch.by");process.exit(0)}
+const r=spawnSync(cli,["launches","list","--json"],{encoding:"utf8"});
+if(r.status!==0){console.log(`fail launches list exited ${r.status}`);process.exit(0)}
+let l;try{l=JSON.parse(r.stdout)}catch{console.log("fail launches list printed no JSON");process.exit(0)}
+const live=Array.isArray(l)?l.filter((x)=>x&&x.instance===by&&x.live===true):[];
+console.log(live.length!==1?`fail ${live.length} live launches of ${by}`:live[0].business!==b?`fail the live launch of ${by} is for ${live[0].business}`:`ok ${by} run ${live[0].run}`);'
+check_f7() {
+    local out
+    out="$("${AS_USER[@]}" "$NODE" -e "$F7_JS" -- "$BUSINESS_FILE" "$COPY/scripts/mosaic" "$BUSINESS" 2>/dev/null | sed -n 1p)"
+    if [[ "$out" =~ ^ok\ [a-z0-9][a-z0-9-]*\ run\ [A-Za-z0-9._-]+$ ]]; then fpass F7 pm-live "one live launch: ${out#ok }"
+    else ffail F7 pm-live "$(clean "${out#fail }")"; fi
+}
+
+check_f8() {
+    local s
+    s="$(stat -c '%U %a %F' -- "$ROOT$CRED" 2>/dev/null)" || s="missing"
+    if [ ! -L "$ROOT$CRED" ] && [ "$s" = "$S_USER 600 regular file" ]; then fpass F8 credential-file "$CRED is '$s'"
+    else ffail F8 credential-file "$CRED is '$s', not '$S_USER 600 regular file'"; fi
+}
+
+# Empty when $1 and every directory above it, up to /, are the running user's (root's on the host) with
+# no group or other write: case2-unit.sh's root_only rule for --node, checked again before root runs it.
+# Otherwise the first path that breaks the rule. A symlink breaks it, because its mode is 777.
+not_root_only() {
+    local p="$1" st
+    while :; do
+        st="$(stat -c '%u %a' -- "$ROOT$p" 2>/dev/null)" || { echo "$p (cannot stat)"; return; }
+        [ "${st% *}" = "$(id -u)" ] && (( (8#${st#* } & 8#022) == 0 )) || { echo "$p (uid ${st% *}, mode ${st#* })"; return; }
+        [ "$p" = / ] && return
+        p="$(dirname -- "$p")"
+    done
+}
+
+check_f9() {
+    local s v bad
+    s="$(stat -c '%U:%G %a %F' -- "$ROOT$SETTINGS" 2>/dev/null)" || s="missing"
+    [ ! -L "$ROOT$SETTINGS" ] && [ "$s" = "root:root 644 regular file" ] || { ffail F9 autoupdater-off "$SETTINGS is '$s', not 'root:root 644 regular file'"; return; }
+    # Root runs node here, so it runs only the pinned path, and only when nothing but root can replace it.
+    [ "$NODE" = "/opt/mosaic-stack/node-$NODE_PIN/bin/node" ] || { ffail F9 autoupdater-off "root won't run --node $NODE: it is not the --node-pin path"; return; }
+    bad="$(not_root_only "$NODE")"
+    [ -z "$bad" ] || { ffail F9 autoupdater-off "root won't run --node $NODE: $bad is not root's alone"; return; }
+    v="$("$ROOT$NODE" -e 'const s=JSON.parse(require("node:fs").readFileSync(process.argv[1],"utf8"));process.stdout.write(JSON.stringify(s?.env?.DISABLE_AUTOUPDATER??null))' -- "$ROOT$SETTINGS" 2>/dev/null)" || v="unreadable"
+    if [ "$v" = '"1"' ]; then fpass F9 autoupdater-off "$SETTINGS is root:root 0644 with env.DISABLE_AUTOUPDATER \"1\""
+    else ffail F9 autoupdater-off "$SETTINGS env.DISABLE_AUTOUPDATER is $v, not \"1\""; fi
+}
+
+check_f10() {
+    local want="/opt/mosaic-stack/node-$NODE_PIN/bin/node" v
+    [ "$NODE" = "$want" ] || { ffail F10 node-pin "--node $NODE is not $want"; return; }
+    v="$("${AS_USER[@]}" "$NODE" --version 2>/dev/null | sed -n 1p)"
+    if [ "$v" = "$NODE_PIN" ]; then fpass F10 node-pin "$NODE prints $v"
+    else ffail F10 node-pin "$NODE --version prints '$(clean "$v")', not $NODE_PIN"; fi
+}
+
+check_f11() {
+    local d="$ROOT$DATA_ROOT/discord" found
+    if [ -L "$d" ]; then ffail F11 no-discord "$DATA_ROOT/discord is a symlink"; return; fi
+    [ -d "$d" ] || { fpass F11 no-discord "$DATA_ROOT/discord is absent"; return; }
+    found="$(find "$d" -maxdepth 1 -name '*.json' -printf '%f ' 2>/dev/null)"
+    if [ -z "$found" ]; then fpass F11 no-discord "$DATA_ROOT/discord holds no binding"
+    else ffail F11 no-discord "$DATA_ROOT/discord holds bindings: ${found% }"; fi
+}
+
+# --- P checks ---
+
+check_p1() {
+    local out
+    out="$(sudo -l -U "$S_USER" 2>&1)"
+    if grep -q "is not allowed to run sudo" <<< "$out"; then line P1 "$S_USER-sudo" closed "sudo -l: $(clean "$(sed -n 1p <<< "$out")")"
+    else line P1 "$S_USER-sudo" unnamed "sudo -l: $(clean "$(tr '\n' ' ' <<< "$out")")"; fi
+}
+
+check_p2() {
+    local gs keys="$ROOT$S_HOME/.ssh/authorized_keys" kstate n
+    gs="$(groups_of "$S_USER" | tr '\n' ' ')"; gs="${gs% }"
+    n="$(wc -w <<< "$gs")"
+    if [ ! -e "$keys" ] && [ ! -L "$keys" ]; then kstate=absent
+    elif [ -f "$keys" ] && [ ! -L "$keys" ] && [ ! -s "$keys" ]; then kstate=empty
+    else kstate=present; fi
+    if [ "$n" = 1 ] && [ "$kstate" != present ]; then line P2 "$S_USER-groups-keys" closed "id -G is '$gs'; authorized_keys is $kstate"
+    else line P2 "$S_USER-groups-keys" unnamed "id -G is '$gs'; authorized_keys is $kstate"; fi
+}
+
+check_p3() {
+    local n
+    n="$(sudo -l -U localadmin 2>&1 | grep -c NOPASSWD)"
+    line P3 localadmin-sudo "accepted Q183" "sudo -l -U localadmin lists $n NOPASSWD lines"
+}
+
+check_p4() { line P4 pve-root-pbs "accepted Q182+Q183" "root on pve over VM 1008, and PBS backups that hold $S_HOME with the credential; this script can't see pve"; }
+
+check_p5() {
+    local gs reach
+    if [ -z "$(uid_of jarvis)" ]; then line P5 jarvis-reach closed "no jarvis account"; return; fi
+    gs="$(names_of_groups $(groups_of jarvis) | tr '\n' ' ')"
+    reach="$(tr ' ' '\n' <<< "$gs" | grep -xE 'sudo|docker|lxd' | tr '\n' ' ')"
+    if [ -z "$reach" ]; then line P5 jarvis-reach closed "jarvis is in none of sudo, docker and lxd (groups: ${gs% })"
+    else line P5 jarvis-reach unnamed "jarvis is in ${reach% }"; fi
+}
+
+check_p6() {
+    local g m members bad=0
+    for g in sudo docker lxd; do
+        members="$(db group "$g" | cut -d: -f4)"
+        for m in ${members//,/ }; do
+            [ "$g" = sudo ] && [ "$m" = localadmin ] && continue
+            line P6 "group-$g" unnamed "$m is a member of $g"; bad=1
+        done
+    done
+    [ "$bad" = 1 ] || line P6 group-members closed "sudo holds only localadmin, and docker and lxd have no members"
+}
+
+check_p7() {
+    local found
+    found="$(grep -rlw -- "$S_USER" "$ROOT/etc/sudoers.d" 2>/dev/null | sed "s#^$ROOT##" | tr '\n' ' ')"
+    if [ -z "$found" ]; then line P7 sudoers-d closed "no file under /etc/sudoers.d names $S_USER"
+    else line P7 sudoers-d unnamed "files naming $S_USER: ${found% }"; fi
+}
+
+check_p8() {
+    local other
+    other="$(listeners 7331)"
+    if loopback_by "$PORT" "$CON_PID" && loopback_by "$TESTER_PORT" "$CON_PID" && [ -z "$other" ]; then
+        line P8 lan-listeners closed "$PORT and $TESTER_PORT are on 127.0.0.1 only, by MainPID $CON_PID; nothing on 7331"
+    else
+        line P8 lan-listeners unnamed "$PORT: $(listener_text "$PORT"); $TESTER_PORT: $(listener_text "$TESTER_PORT"); 7331: $(listener_text 7331); Console MainPID ${CON_PID:-none}"
+    fi
+}
+
+check_p9() {
+    local out n missing=() rc=0 err mg others
+    out="$("$ROOT$HOSTCHECK" --check 2>/dev/null)"
+    for n in 1 2 3 4 5 6; do grep -q "^ok $n " <<< "$out" || missing+=("hostcheck item $n has no ok line")
+    done
+    err="$(sudo -u jarvis /usr/bin/bwrap --version 2>&1 >/dev/null)" || rc=$?
+    [ "$rc" != 0 ] && grep -q "Permission denied" <<< "$err" || missing+=("sudo -u jarvis /usr/bin/bwrap --version exited $rc without Permission denied")
+    mg="$(gid_of "$S_USER")"
+    [ -n "$mg" ] && [ -z "$(db group "$S_USER" | cut -d: -f4)" ] || missing+=("group $S_USER lists members, or $S_USER has no group")
+    others="$(db passwd | awk -F: -v g="$mg" -v u="$S_USER" '$4 == g && $1 != u { print $1 }' | tr '\n' ' ')"
+    [ -z "$others" ] || missing+=("other accounts have $S_USER's gid $mg: ${others% }")
+    if [ ${#missing[@]} = 0 ]; then
+        line P9 bwrap-userns "accepted mos-1096" "hostcheck items 1-6 ok, jarvis is denied bwrap, and group $S_USER has no other member"
+    else
+        for n in "${missing[@]}"; do line P9 bwrap-userns unnamed "$n"; done
+    fi
+}
+
+check_p10() {
+    local floor
+    floor="$(cat "$ROOT/proc/sys/net/ipv4/ip_unprivileged_port_start" 2>/dev/null)"
+    if [[ "$floor" =~ ^[0-9]+$ ]] && [ "$floor" -gt "$PORT" ] && loopback_by "$TESTER_PORT" "$CON_PID"; then
+        line P10 tester-port-squat "accepted mos-1101" "the port floor $floor is above $PORT, and MainPID $CON_PID holds $TESTER_PORT"
+    else
+        line P10 tester-port-squat unnamed "the port floor is '${floor:-unreadable}' against $PORT; $TESTER_PORT: $(listener_text "$TESTER_PORT"); Console MainPID ${CON_PID:-none}"
+    fi
+}
+
+check_p11() {
+    local en before
+    en="$(systemctl is-enabled mosaic-hostcheck.service 2>/dev/null)"
+    before="$(prop "$(unit_show mosaic-hostcheck.service Before)" Before)"
+    if [ "$en" = enabled ] && grep -qxF -- "$BUS_UNIT" <<< "${before// /$'\n'}"; then
+        line P11 hostcheck-before-bus closed "mosaic-hostcheck.service is enabled, and its Before= names $BUS_UNIT"
+    else
+        line P11 hostcheck-before-bus unnamed "mosaic-hostcheck.service is '${en:-unknown}', Before='$before'; it needs enabled and $BUS_UNIT"
+    fi
+}
+
+check_f1
+check_f2
+F5_LINE=()
+check_f3_f5
+check_f4
+"${F5_LINE[0]}" F5 bwrap-label "${F5_LINE[@]:1}"
+check_f6
+check_f7
+check_f8
+check_f9
+check_f10
+check_f11
+check_p1; check_p2; check_p3; check_p4; check_p5; check_p6
+check_p7; check_p8; check_p9; check_p10; check_p11
+
+for m in "${MARKS[@]}"; do echo "count $m ${COUNT[$m]:-0}"; done
+if [ "$F_FAILED" = 0 ]; then echo "case1-accept: every F check passes; send the whole output to Duckworth, and each unnamed line to Mos"; exit 0; fi
+echo "case1-accept: an F check failed, so the row fails"
+exit 1
@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+# Row 240 (I4, #1746): the Case 1 host's drift stop for bwrap, r6 B2
+# (agents/darkwing/work/queue-195/DESIGN.md at b7239bb66, as docs/plans/2026-10-20_installer-rows.md
+# "I4 hostcheck" ships it). Deviations and decisions: agents/darkwing/work/queue-240/BUILD.md.
+#
+#   case1-hostcheck.sh --check | --enforce | --upstream
+#
+# Installed as /usr/local/lib/mosaic-stack/hostcheck.sh, root:root 0755, with case1-pins.sh beside it,
+# root:root 0644. Three callers: stack-upgrade.sh A1 runs --check and refuses profile-drift on any
+# exit but 0; the apt hook /etc/apt/apt.conf.d/80mosaic-hostcheck runs --enforce after every dpkg run;
+# mosaic-hostcheck.service runs --enforce at boot, before the bus.
+#
+# Seven items, one line each, `ok N ...` or `FAIL N ...`:
+#   1. /etc/apparmor.d/bwrap-userns-restrict has the pinned sha256, and `dpkg -S` finds no owner.
+#   2. `aa-status --json` lists bwrap and unpriv_bwrap in enforce mode, and no mosaic-bwrap.
+#   3. `grep -rlw bwrap /etc/apparmor.d` lists that one file and nothing else.
+#   4. A bwrap child started as mosaic under the units' no-new-privs reads the label
+#      `bwrap//&unpriv_bwrap (enforce)`, exactly.
+#   5. The statoverride on /usr/bin/bwrap reads `root mosaic 0750`, and stat agrees.
+#   6. kernel.apparmor_restrict_unprivileged_userns and fs.protected_hardlinks are 1.
+#   7. net.ipv4.ip_unprivileged_port_start is above the Console's --port in the installed unit, or
+#      above 1023, the highest --port case2-unit.sh takes, while no unit is installed.
+# A `note` line says whether bubblewrap is the install pin; it is never a failure.
+#
+# --check exits 0 when all seven hold and 1 otherwise. --enforce runs the same items and exits 0. On
+# a failure, or while /etc/mosaic-stack/DRIFT exists, it stops bwrap: `apparmor_parser -R` on the
+# profile if it is loaded, then root:root 0700 on /usr/bin/bwrap. It appends the failed items to DRIFT
+# and one line to /var/log/mosaic-stack/hostcheck.log. Only root removes DRIFT, in a reviewed step.
+# It never writes the statoverride, because dpkg's lock may be held under apt's (r6).
+# --upstream downloads the apparmor-profiles candidate into a temp dir and compares its
+# bwrap-userns-restrict to the pin. A difference is printed and exits 0, because it refuses nothing;
+# it exits 1 when the download or the unpack fails.
+#
+# Exit 2 on usage or a refusal. Root takes no --root; without root it runs only with --root.
+#
+# Test seam, for packages/cli/tests/case1-hostcheck.test.mjs only:
+#   --root DIR   prefixes /etc, /proc/sys, /var/log and /usr/bin/bwrap
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() { echo "usage: case1-hostcheck.sh --check | --enforce | --upstream" >&2; exit 2; }
+MODE="" ROOT=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --check|--enforce|--upstream) [ -z "$MODE" ] || usage; MODE="${1#--}"; shift ;;
+        --root) [ $# -ge 2 ] && [[ "$2" =~ ^/[A-Za-z0-9/._+-]+$ ]] && [ -d "$2" ] || usage; ROOT="${2%/}"; shift 2 ;;
+        *) usage ;;
+    esac
+done
+[ -n "$MODE" ] || usage
+if [ "$(id -u)" = 0 ]; then
+    [ -z "$ROOT" ] || { echo "hostcheck: refusing: --root is a test seam, and root takes none" >&2; exit 2; }
+    PATH=/usr/sbin:/usr/bin:/sbin:/bin
+else
+    [ -n "$ROOT" ] || { echo "hostcheck: refusing: run it as root" >&2; exit 2; }
+fi
+
+PIN_PROFILES_VERSION="" PIN_PROFILE_SHA256="" PIN_BUBBLEWRAP_VERSION=""
+# shellcheck source=case1-pins.sh
+[ -f "$HERE/case1-pins.sh" ] && . "$HERE/case1-pins.sh"
+PROFILE=/etc/apparmor.d/bwrap-userns-restrict
+BWRAP=/usr/bin/bwrap
+DRIFT="$ROOT/etc/mosaic-stack/DRIFT"
+LOGF="$ROOT/var/log/mosaic-stack/hostcheck.log"
+LABEL='bwrap//&unpriv_bwrap (enforce)'
+stamp() { date -u +%Y-%m-%dT%H:%M:%SZ; }
+
+FAILED=() LOADED=1
+pass() { echo "ok $*"; }
+fail() { echo "FAIL $*"; FAILED+=("$*"); }
+
+item1() {
+    local sum owner rc
+    [[ "$PIN_PROFILE_SHA256" =~ ^[0-9a-f]{64}$ ]] || { fail "1 no profile pin in $HERE/case1-pins.sh"; return; }
+    sum="$(sha256sum < "$ROOT$PROFILE" 2>/dev/null | cut -d' ' -f1)"
+    [ "$sum" = "$PIN_PROFILE_SHA256" ] || { fail "1 $PROFILE sha256 is ${sum:-unreadable}, not the pin $PIN_PROFILE_SHA256"; return; }
+    owner="$(dpkg -S "$PROFILE" 2>/dev/null)"; rc=$?
+    case "$rc" in
+        1) pass "1 $PROFILE matches the pin from apparmor-profiles $PIN_PROFILES_VERSION, and no package owns it" ;;
+        0) fail "1 $PROFILE is owned by a package: $owner" ;;
+        *) fail "1 dpkg -S $PROFILE exited $rc" ;;
+    esac
+}
+
+item2() {
+    local json list
+    if ! json="$(aa-status --json 2>/dev/null)"; then fail "2 aa-status --json failed"; return; fi
+    # The profiles object holds name-to-mode pairs and nothing nested; one pair per line.
+    list="$(sed -n 's/.*"profiles": *{\([^}]*\)}.*/\1/p' <<< "$json" | tr ',' '\n' | sed 's/^ *//; s/ *$//')"
+    grep -Eq '^"(bwrap|unpriv_bwrap)":' <<< "$list" || LOADED=0
+    grep -qxE '"bwrap": *"enforce"' <<< "$list" || { fail "2 aa-status lists no bwrap profile in enforce mode"; return; }
+    grep -qxE '"unpriv_bwrap": *"enforce"' <<< "$list" || { fail "2 aa-status lists no unpriv_bwrap profile in enforce mode"; return; }
+    ! grep -qE '^"mosaic-bwrap":' <<< "$list" || { fail "2 aa-status lists a mosaic-bwrap profile"; return; }
+    pass "2 bwrap and unpriv_bwrap are in enforce mode, and no mosaic-bwrap is loaded"
+}
+
+item3() {
+    local found
+    found="$(grep -rlw bwrap "$ROOT/etc/apparmor.d" 2>/dev/null | sort)"
+    [ "$found" = "$ROOT$PROFILE" ] || { fail "3 the files under /etc/apparmor.d that name bwrap are not $PROFILE alone: $(tr '\n' ' ' <<< "$found")"; return; }
+    pass "3 $PROFILE is the only file under /etc/apparmor.d that names bwrap"
+}
+
+item4() {
+    local label
+    label="$(timeout 60 systemd-run --wait --pipe --uid=mosaic --gid=mosaic -p NoNewPrivileges=yes \
+        -p ProtectSystem=strict -p ProtectHome=yes -p PrivateTmp=yes \
+        "$BWRAP" --unshare-user --unshare-pid --ro-bind / / cat /proc/self/attr/current 2>/dev/null)"
+    [ "$label" = "$LABEL" ] || { fail "4 a bwrap child under no-new-privs has the label '$label', not '$LABEL'"; return; }
+    pass "4 a bwrap child under no-new-privs has the label '$LABEL'"
+}
+
+item5() {
+    local so st
+    so="$(dpkg-statoverride --list "$BWRAP" 2>/dev/null)"
+    st="$(stat -c '%U %G %a' "$ROOT$BWRAP" 2>/dev/null)"
+    [ "$so" = "root mosaic 0750 $BWRAP" ] || { fail "5 the statoverride on $BWRAP reads '$so', not 'root mosaic 0750'"; return; }
+    [ "$st" = "root mosaic 750" ] || { fail "5 $BWRAP is '$st', not 'root mosaic 750'"; return; }
+    pass "5 $BWRAP is root mosaic 0750, by the statoverride and by stat"
+}
+
+item6() {
+    local userns links
+    userns="$(cat "$ROOT/proc/sys/kernel/apparmor_restrict_unprivileged_userns" 2>/dev/null)"
+    links="$(cat "$ROOT/proc/sys/fs/protected_hardlinks" 2>/dev/null)"
+    [ "$userns" = 1 ] && [ "$links" = 1 ] ||
+        { fail "6 kernel.apparmor_restrict_unprivileged_userns is '$userns' and fs.protected_hardlinks is '$links', not 1 and 1"; return; }
+    pass "6 kernel.apparmor_restrict_unprivileged_userns and fs.protected_hardlinks are 1"
+}
+
+item7() {
+    local floor unit="$ROOT/etc/systemd/system/mosaic-webui.service" ports port=0 p from
+    floor="$(cat "$ROOT/proc/sys/net/ipv4/ip_unprivileged_port_start" 2>/dev/null)"
+    [[ "$floor" =~ ^[0-9]{1,5}$ ]] || { fail "7 net.ipv4.ip_unprivileged_port_start is '$floor', not a number"; return; }
+    if [ -e "$unit" ]; then
+        ports="$(sed -n 's/^ExecStart=//p' "$unit" 2>/dev/null | grep -oE ' --port [0-9]{1,5}( |$)' | tr -dc '0-9\n')"
+        [ -n "$ports" ] || { fail "7 /etc/systemd/system/mosaic-webui.service has no --port"; return; }
+        for p in $ports; do [ "$((10#$p))" -le "$port" ] || port="$((10#$p))"; done
+        from="the Console's --port $port"
+    else
+        port=1023 from="1023, because no Console unit is installed"
+    fi
+    [ "$((10#$floor))" -gt "$port" ] || { fail "7 net.ipv4.ip_unprivileged_port_start is $floor, not above $from"; return; }
+    pass "7 net.ipv4.ip_unprivileged_port_start is $floor, above $from"
+}
+
+items() {
+    local v
+    item1; item2; item3; item4; item5; item6; item7
+    v="$(dpkg -s bubblewrap 2>/dev/null | sed -n 's/^Version: //p')"
+    if [ "$v" = "$PIN_BUBBLEWRAP_VERSION" ]; then
+        echo "note bubblewrap $v is the install pin"
+    else
+        echo "note bubblewrap ${v:-unknown} is not the install pin ${PIN_BUBBLEWRAP_VERSION:-unknown}, which is not a drift item"
+    fi
+}
+
+# The stop: unload the profile if it is loaded, then close bwrap to root. Prints the results.
+stop_bwrap() {
+    local unload=skipped chown_rc=0 chmod_rc=0
+    if [ "$LOADED" = 1 ]; then
+        if [ -f "$ROOT$PROFILE" ]; then apparmor_parser -R "$ROOT$PROFILE" >/dev/null 2>&1; unload="rc=$?"; else unload=no-file; fi
+    fi
+    chown root:root "$ROOT$BWRAP" || chown_rc=$?
+    chmod 0700 "$ROOT$BWRAP" || chmod_rc=$?
+    echo "unload=$unload chown=$chown_rc chmod=$chmod_rc"
+}
+
+enforce() {
+    local had=0 now result f ids=""
+    [ ! -e "$DRIFT" ] || had=1
+    items
+    [ ${#FAILED[@]} -gt 0 ] || [ "$had" = 1 ] || { echo "hostcheck: all seven hold"; exit 0; }
+    umask 027
+    now="$(stamp)"
+    if [ ${#FAILED[@]} -gt 0 ]; then
+        mkdir -p "$(dirname "$DRIFT")" && for f in "${FAILED[@]}"; do echo "$now $f"; done >> "$DRIFT" ||
+            echo "hostcheck: cannot write $DRIFT" >&2
+    fi
+    for f in "${FAILED[@]}"; do ids+="${ids:+,}${f%% *}"; done
+    result="$(stop_bwrap)"
+    mkdir -p "$(dirname "$LOGF")" && echo "$now enforce stop items=${ids:-none} drift-before=$had $result" >> "$LOGF" ||
+        echo "hostcheck: cannot write $LOGF" >&2
+    echo "hostcheck: bwrap stopped ($result); only root removes $DRIFT"
+    exit 0
+}
+
+upstream() {
+    local tmp deb ver f sum
+    tmp="$(mktemp -d)" || exit 1
+    trap 'rm -rf "$tmp"' EXIT
+    (cd "$tmp" && apt-get download apparmor-profiles) >/dev/null 2>&1 || { echo "hostcheck: upstream: apt-get download apparmor-profiles failed" >&2; exit 1; }
+    deb=("$tmp"/apparmor-profiles_*.deb)
+    [ ${#deb[@]} = 1 ] && [ -f "${deb[0]}" ] || { echo "hostcheck: upstream: no single apparmor-profiles deb in the download" >&2; exit 1; }
+    ver="$(dpkg-deb -f "${deb[0]}" Version 2>/dev/null)" && dpkg-deb -x "${deb[0]}" "$tmp/x" >/dev/null 2>&1 ||
+        { echo "hostcheck: upstream: cannot unpack ${deb[0]##*/}" >&2; exit 1; }
+    f="$tmp/x/usr/share/apparmor/extra-profiles/bwrap-userns-restrict"
+    if [ ! -f "$f" ]; then
+        echo "upstream: DIFFERS: apparmor-profiles $ver has no bwrap-userns-restrict; the pin is $PIN_PROFILE_SHA256 from $PIN_PROFILES_VERSION. Send it to Mos as a new-pin request."
+        exit 0
+    fi
+    sum="$(sha256sum < "$f" | cut -d' ' -f1)"
+    if [ "$sum" = "$PIN_PROFILE_SHA256" ]; then
+        echo "upstream: apparmor-profiles $ver's bwrap-userns-restrict matches the pin from $PIN_PROFILES_VERSION"
+    else
+        echo "upstream: DIFFERS: apparmor-profiles $ver's bwrap-userns-restrict has sha256 $sum; the pin is $PIN_PROFILE_SHA256 from $PIN_PROFILES_VERSION. Send it to Mos as a new-pin request."
+        diff -u --label "installed $PROFILE" --label "apparmor-profiles $ver" "$ROOT$PROFILE" "$f" || true
+    fi
+    exit 0
+}
+
+case "$MODE" in
+    check) items; [ ${#FAILED[@]} -eq 0 ] || exit 1; exit 0 ;;
+    enforce) enforce ;;
+    upstream) upstream ;;
+esac
@@ -0,0 +1,12 @@
+# Row 240 (I4, #1746): the Case 1 host pins, sourced by case1-hostcheck.sh, which is installed as
+# /usr/local/lib/mosaic-stack/hostcheck.sh with this file beside it. r6 B2
+# (agents/darkwing/work/queue-195/DESIGN.md at b7239bb66). Changing a pin is a reviewed commit and
+# its own round.
+#
+# The AppArmor profile 2a' installs as /etc/apparmor.d/bwrap-userns-restrict, taken from
+# /usr/share/apparmor/extra-profiles/bwrap-userns-restrict in this apparmor-profiles version.
+PIN_PROFILES_VERSION=4.0.1really4.0.1-0ubuntu0.24.04.9
+PIN_PROFILE_SHA256=11d39094f044f0cda0febb3ad517b830301da6b2ce929664af09ee9e4dd264f9
+# The bubblewrap version 2a' installs. An install pin, not a drift item: a security update keeps the
+# statoverride, and the profile attaches by path. hostcheck prints a line when they differ.
+PIN_BUBBLEWRAP_VERSION=0.9.0-1ubuntu0.3
@@ -929,12 +929,13 @@ sso_checks() {
    sso_supported || { check_refuse sso-target "$TO's Console does not support --sso"; return 0; }
    local cfg="${MOSAIC_CONFIG:-$HOME/.config/mosaic-dev/config.json}" out id slot path why
    # N4 (webby-0019, sage-1403): a pre-phase-1 loader refuses a console key, so with the key not yet
-    # written and the stack on another copy, the first step is the re-pin without --sso.
-    local first=""
+    # written and the stack on another copy, the first step is the re-pin without --sso. On a named
+    # instance both commands carry --instance NAME (row 238).
+    local first="" inst="${INSTANCE_FLAGS[*]:+ ${INSTANCE_FLAGS[*]}}"
    if ! out="$(node -e "$SSO_JS" -- "$COPIES/$TO" "$cfg" 2>&1)"; then
        out="${out%%$'\n'*}"
        [ "$out" != "there is no console.sso in the system config" ] || [ "$P_COPY" = "$TO" ] ||
-            first="; activate $TO without --sso first, then write console.sso, then run activate $TO --sso"
+            first="; activate $TO$inst without --sso first, then write console.sso, then run activate $TO$inst --sso"
        check_refuse sso-config "$TO's Console would refuse its --sso start: $out$first"
        return 0
    fi
@@ -27,7 +27,8 @@
 # <argv>`, and a last `<time> result exit=N <code> <text>` line.
 #
 # Exit 0 ok, 1 failed with the old stack running, 2 rollback-failed with the units stopped,
-# 3 refused with nothing stopped, 4 usage.
+# 3 refused with nothing stopped, 4 usage, 5 args-failed: the new stack is live and confirmed, but
+# the args file still names the old copy.
 #
 # Test seams, for packages/cli/tests/stack-upgrade.test.mjs only. Run as root, it refuses any:
 #   STACK_UPGRADE_ETC        default /etc/mosaic-stack
@@ -278,7 +279,7 @@ run_steps() {
    step confirm "${AS_USER[@]}" "$SR" confirm "$id" "$BUSINESS" --units external --copies "$COPIES_DIR" --timeout "$TIMEOUT" ||
        rollback_to_old "$id" A5
    if mv -f "$NEW_ARGS" "$ETC/$INSTANCE.args"; then logl "args rc=0 copy: $id"
-    else logl "args rc=1 copy: $id"; finish 1 args-failed "$id is live and confirmed, but $ETC/$INSTANCE.args still names $OLD; put $NEW_ARGS in its place"
+    else logl "args rc=1 copy: $id"; finish 5 args-failed "$id is live and confirmed, but $ETC/$INSTANCE.args still names $OLD; put $NEW_ARGS in its place"
    fi
 }
Author	SHA1	Message	Date
jason.woltje	1e3c4767c8	row 195 follow-up: F9 runs node as root only at the pinned, root-only path; header lists root's commands; F6 refuses .. (Duckworth N1-N3, #1693 )	2026-10-21 04:01:34 -05:00
jason.woltje	37171f65ba	row 195: BUILD.md slot results, 22/22 single, 12/12 mutants killed, gate green on `ddf7dce6c` (cli 662/0, scripts 429/0) (#1693 )	2026-10-21 03:48:17 -05:00
jason.woltje	ddf7dce6c6	row 195: case1-accept.sh, root's Case 1 acceptance (F1-F11, P1-P11), its test and TOOLS.md entry; DESIGN r7 doc fixes (#1693 ) Built to DESIGN r7 section 5, approved by Duckworth (duckworth-0087, `58d930f89`), go sage-1817. BUILD.md holds the deviations and the twelve mutants. No test has run yet: singles, mutants and the gate wait for Sage's slot. DESIGN.md, doc-only per sage-1817: Duckworth's N1 (the human-id check is broker.mjs:321, not :245), and row 226's state at :21, :326 and :340 (assigned to Gosalyn, briefed, not started; the section 6 items were sent and acknowledged as gosalyn-0085).	2026-10-21 02:37:27 -05:00
jason.woltje	08578991c7	agents: row 195 DESIGN r7, the factory profile's values and the Case 1 acceptance after the installer split (#1693 ) r6's re-pin, external verbs, drift stop and host steps now ship in rows 232, 233, 240 and 230 and the host run sheet. r7 keeps the factory inputs and dev.args, the Case 2 differences, model access (Q185), upgrade and rollback through stack-upgrade.sh, the .53 window order with every root step left to ops-01 (sage-1809), the business id mosaic-stack with the DEFERRED 240 N1 reasoning (sage-1813), what the window needs from row 226, and case1-accept.sh F1-F11 and P1-P11 with its tests and twelve mutants.	2026-10-21 02:37:27 -05:00
jason.woltje	ca500082af	agents: row 195 DESIGN r6 (`b7239bb66`, approved duckworth-0055) carried onto `c515273db` unchanged, the base for r7 (#1693 )	2026-10-21 02:37:27 -05:00
jason.woltje	4ced5e63d4	sessions: Sage, rows 240, 228 and 238 landed (`c515273db`, `86249ac55`, `d49b1f2bd`), 197 r5 rebuild, Gosalyn 212 slot (sage-1788..1826)	2026-10-21 02:29:11 -05:00
jason.woltje	e7078e6a85	deferred: Webby's row 238 N1, the sso-config first-step hint has no business (#1744 )	2026-10-21 02:27:43 -05:00
jason.woltje	d49b1f2bd3	row 238: stack-release's sso-config first step carries --instance NAME on a named instance (#1744 ) Lands Launchpad's round 3 candidate, manifest 1bf831f3 (`4c90099ea` on launchpad/row238-r4, base `c515273db`), approved by Webby (29956, rev 2717). Three paths: scripts/stack-release.sh, packages/cli/tests/ stack-release.test.mjs and docs/TOOLS.md. It is row 200's follow-up N1. Round 3 only merges docs/TOOLS.md onto the row 240 landing: the landed blob plus the one hunk at :599. The 3-path patch-id, b9d0bb0ee3c7, is the same in all three rounds, and stack-release.sh stays 100755. Evidence: Launchpad's slot run on round 2, 2afbfbb01: stack-release.test.mjs 196/0 (sage-1794). Sage's combined gate with row 228 on `c515273db` plus both rows' paths (07:11:30Z to 07:23:34Z): packages/seat 165 pass, 0 fail; packages/cli 640 pass, 0 fail; all ten scripts/test-*.sh 585 pass, 0 fail (out/, run.log). Row 238's mutant, the sso-config first step dropping --instance NAME, was killed (2 fails), survived: none, and stack-release.sh was restored to its blob. `queue review verify-commit 238` matches the manifest on all 3 paths. Round 1's N1 stays on the #1744 carry list.	2026-10-21 02:24:25 -05:00
jason.woltje	86249ac552	row 228: ZAI_API_KEY in the session env allowlist (#1729 ) Lands Researcher's round 3 candidate, manifest 82cf98c6 (`cf18c42b9` on researcher/row228-r3, base `c771a36f4`), approved by Webby (29949, rev 2708). Three paths: packages/seat/src/session.mjs (ZAI_API_KEY in ENV_ALLOW), packages/seat/tests/session.test.mjs (the pass-through test) and packages/cli/README.md (the line, with the round 1 and round 2 N1 trims at :711 and :718). Round 3 is the round 2 rebase onto the row 234 landing; the two seat files carry the blobs approved in rounds 1 and 2. Evidence: Researcher's slot run on `cf18c42b9`: session.test.mjs 13/0, host.test.mjs 42/0 (sage-1796). Round 2's seat and cli runs, 94/0, and its killed mutant stand, since the seat blobs are unchanged. Sage's combined gate with row 238 on `c515273db` plus both rows' paths (07:11:30Z to 07:23:34Z): packages/seat 165 pass, 0 fail; packages/cli 640 pass, 0 fail; all ten scripts/test-*.sh 585 pass, 0 fail (out/, run.log). bus runtime.mjs and webui reads.mjs import only readSessions from session.mjs, which this change doesn't touch. `queue review verify-commit 228` matches the manifest on all 3 paths.	2026-10-21 02:24:25 -05:00
jason.woltje	59f817c321	sessions: Darkwing, row 195 DESIGN r7 pushed (`5425ea2f3`), Duckworth review requested (Gitea 29960), row 226 items to Gosalyn	2026-10-21 02:15:49 -05:00
jason.woltje	c515273db7	row 240: installer I4, root's host check, its pins and the boot unit; I3's N1, N4 and N5 (#1746 , Vikunja #432 ) Lands Darkwing's round 1 candidate, manifest 573ece95a4a9 (`ad1b23ab2` on darkwing/row240-r3, base `c771a36f4`), approved by Filbert (29945, rev 2696). Nine paths: scripts/case1-hostcheck.sh (new), scripts/case1-pins.sh (new), packages/cli/systemd/mosaic-hostcheck.service (new), packages/cli/tests/case1-hostcheck.test.mjs (new), scripts/stack-upgrade.sh, packages/cli/tests/stack-upgrade.test.mjs, docs/guides/host-run-sheet.md, docs/TOOLS.md and agents/darkwing/work/queue-240/BUILD.md. File modes match the candidate. case1-hostcheck.sh and stack-upgrade.sh are 100755. case1-pins.sh is 100644, because the host check sources it. Evidence: Darkwing's first slot run failed one test, the N1 test's after hook (ENOENT once the fixture had removed its root). The fix `b45852daa` is test-only. The second run on `b45852daa` was green: singles 37/0, mutants M1-M8 8 of 8 killed, cli 639/0, scripts 585/0. Since `c771a36f4` no commit touches the nine paths. Sage's gate on `060a17b54` plus the nine paths (06:45:05Z to 06:56:21Z): packages/cli 639 pass, 0 fail, and all ten scripts/test-*.sh 585 pass, 0 fail (out/, run.log). `queue review verify-commit 240` matches the manifest on all 9 paths. Filbert's notes: N1 (the boot unit orders only mosaic-bus@mosaic-stack) and N2 (the run sheet writes the apt hook before the first --check) are in docs/plans/DEFERRED.md. N3, repeated DRIFT lines after bwrap is closed, is by design and is noted with N2.	2026-10-21 01:56:47 -05:00
jason.woltje	da3051ccc6	deferred: Filbert's row 240 N1 and N2 (29945, #1746 ); 10-24 window draft Q1 takes the mos-1161 ruling	2026-10-21 01:50:34 -05:00
jason.woltje	060a17b549	sessions: Filbert, row 240 round 1 approve (29945, rev 2696)	2026-10-21 01:41:13 -05:00
jason.woltje	ffd90e7fc4	sessions: Darkwing, row 240 in review round 1 (`ad1b23ab2`, manifest 573ece95, revs 2694 and 2695), with its BUILD-LOG entry	2026-10-21 01:37:57 -05:00
jason.woltje	02709125a6	sessions: Sage, row 234 landing `c771a36f4`, 235 briefed, rebuilt-row slot order, 10-24 draft NEW (sage-1766..1787) Doc only. The 10-24 window draft 0 now names NEW `c771a36f4` and adds row 233 and the T46 untimed tables.	2026-10-21 01:20:30 -05:00