From a913bfc2495f9b9ffeaa3352297498a9b9b24a7c Mon Sep 17 00:00:00 2001
From: Daniel Ochoa <daniel.ochoa@closedloop.ai>
Date: Wed, 21 Oct 2026 23:26:25 -0500
Subject: [PATCH 1/5] fix(vibe): encode the open 2026-10-22 fleet lessons

- liveness.mjs awaited main() above the constants that classify turn
  errors, so the watcher printed READFAIL for every failed turn; the
  entry point is last and a contract test refuses the shape anywhere.
- NEEDS-REPLY catches a question or a permission, authorization or
  approval request on any line of an idle writer's final message.
- A notLoaded thread whose turn finished reads IDLE with its message,
  proven with a test against the same App Server reads.
- The watcher flags MODEL(...) drift from CODEX_MODEL and CODEX_EFFORT;
  a new Codex session needs a model as well as an effort.
- watch.sh refuses a second copy per work dir.
- board.mjs: standing duties with owners (UNOWNED-DUTY; helpers.mjs
  refuses to stop an owner) and SLOW Codex writers with unresolved
  human threads and no push for 30 minutes.
- executed-check.mjs --kind prd refuses open PRODUCES children;
  review-page-check.mjs needs code evidence on decisions;
  session-questions.mjs refuses permission for in-scope work;
  lessons-pr.mjs finds the open lessons PR.
- Short prose for the usage reset rule, grouped bug fixes and work
  outside the program; vibe 1.0.75 and its changelog.

Testing: node --test on each changed suite; each new check shown
failing with its fix removed; full suites run on a second machine.
Risks: a new Codex session without CODEX_MODEL now refuses to start.
---
 CHANGELOG.md                                  |  18 +++
 plugins/vibe/.claude-plugin/plugin.json       |   2 +-
 plugins/vibe/.codex-plugin/plugin.json        |   2 +-
 plugins/vibe/agents/vibe-change-worker.md     |   6 +-
 plugins/vibe/agents/vibe-ticket-worker.md     |   2 +-
 .../vibe/skills/codex-fleet-monitor/SKILL.md  |   9 +-
 .../codex-fleet-monitor/scripts/classify.sh   |   6 +-
 .../codex-fleet-monitor/scripts/liveness.mjs  |  47 +++++--
 .../scripts/liveness.test.mjs                 | 109 +++++++++++++++-
 .../codex-fleet-monitor/scripts/snapshot.sh   |   3 +-
 .../codex-fleet-monitor/scripts/watch.sh      |  14 ++
 .../scripts/watcher.test.mjs                  |  41 ++++++
 .../vibe/skills/fleet-orchestrator/SKILL.md   |  19 ++-
 .../references/templates.md                   |   5 +-
 .../fleet-orchestrator/scripts/board.mjs      | 120 ++++++++++++++++--
 .../fleet-orchestrator/scripts/board.test.mjs |  59 +++++++++
 .../scripts/codex-session.mjs                 |   4 +-
 .../scripts/codex-session.test.mjs            |   9 +-
 .../fleet-orchestrator/scripts/helpers.mjs    |  18 +++
 .../fleet-orchestrator/scripts/lessons-pr.mjs |  46 +++++++
 .../scripts/lessons-pr.test.mjs               |  37 ++++++
 .../scripts/review-page-check.mjs             |  10 +-
 .../scripts/review-page-check.test.mjs        |  12 +-
 .../skills/handoff/scripts/executed-check.mjs |  33 ++++-
 .../handoff/scripts/executed-check.test.mjs   |  29 ++++-
 plugins/vibe/skills/vibe/SKILL.md             |   4 +-
 .../skills/vibe/scripts/session-questions.mjs |  17 +++
 .../vibe/scripts/session-questions.test.mjs   |  24 +++-
 .../python/test_vibe_1075_lessons_contract.py |  89 +++++++++++++
 29 files changed, 733 insertions(+), 61 deletions(-)
 create mode 100644 plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.mjs
 create mode 100644 plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.test.mjs
 create mode 100644 plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 256d7bd7..7fe710bd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,24 @@ All notable changes to the claude-plugins project will be documented in this fil
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Entries are listed newest-first; each plugin section is treated as released when merged to `main`.
 
+### vibe v1.0.75
+
+The open fleet lessons from the 2026-10-21 and 2026-10-22 orchestration runs, each with a mechanical check where one fits, and a watcher bug found while checking them.
+
+#### Fixed
+- `liveness.mjs` run as a command (as the watcher runs it) printed `READFAIL` for every failed turn: its entry point awaited `main()` above the constants that classify turn errors, so classifying one threw. The entry point is last, a command-level test reads a usage-limit turn as `LIMIT`, and a contract test refuses a top-level `const`, `let` or `class` below a top-level `await main()` in any plugin script.
+- A watcher `IDLE` line says `NEEDS-REPLY` when any line of the final message asks a question or asks for permission, authorization or approval, not only when the message ends in one. A writer that asked "May I ...?" and ended on a status sentence waited unread.
+
+#### Added
+- A thread the App Server unloaded (`notLoaded`) after its turn finished reads `IDLE` with its final message, the same as a loaded one; a test proves it, so no code change was needed.
+- `liveness.mjs` adds `MODEL(<model>/<effort>!=<want>)` to a session whose thread runs on another model or effort than `CODEX_MODEL` and `CODEX_EFFORT`, and `fleet.sh` refuses a new Codex session without a model as well as an effort.
+- `watch.sh` holds a lock per work dir; a second copy (one started with `&`) exits 3 and says to start it with the harness's background option, and a lock whose pid died is taken over.
+- fleet-orchestrator: `board.mjs duty` gives each standing duty (main's post-merge health, a PR shepherd, the watcher) an owner, `status` prints `UNOWNED-DUTY`, and `helpers.mjs stopped` refuses a helper that owns one. `status` also prints `SLOW` for a Codex writer 30 minutes without a push while its PR has unresolved human threads, the cue to hand it to a Claude writer.
+- `executed-check.mjs` takes `--kind plan|prd`; a PRD also needs `--children` and is refused while any PRODUCES child is not DONE or CANCELED.
+- `review-page-check.mjs` refuses a decision row without `checked in code: <file>:<line>`, and vibe's `session-questions.mjs ask` refuses a request for permission to do in-scope work (a test repair, a main merge, a push, a fix); the change worker does that work and reports it.
+- `lessons-pr.mjs` names an open lessons PR to push onto before another is opened.
+- fleet-orchestrator prose: near a Codex usage limit, tell the operator with the available resets and, when they are away, move the busiest writers to Claude writers; group bug fixes into one umbrella ticket with PRs split by code area; work outside the program goes to its owner as a ticket.
+
 ### vibe v1.0.74
 
 Signal safety after a plugin test ended every process on an operator's machine, the open 2026-10-21 fleet lessons, and Storybook guard rules found by the 2026-10-21 audit (#8953, #8959, #8960, #8962, #8963, #8980). Each lesson has a mechanical check where one fits.
diff --git a/plugins/vibe/.claude-plugin/plugin.json b/plugins/vibe/.claude-plugin/plugin.json
index b3cd03a0..01fa9fa3 100644
--- a/plugins/vibe/.claude-plugin/plugin.json
+++ b/plugins/vibe/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "vibe",
   "description": "Vibe sessions, handoff, seed refresh, and ClosedLoop ticket workflows",
-  "version": "1.0.74",
+  "version": "1.0.75",
   "dependencies": ["closedloop-core"],
   "author": {"name": "ClosedLoop", "email": "support@closedloop.ai"}
 }
diff --git a/plugins/vibe/.codex-plugin/plugin.json b/plugins/vibe/.codex-plugin/plugin.json
index 6e13cb31..a0162987 100644
--- a/plugins/vibe/.codex-plugin/plugin.json
+++ b/plugins/vibe/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "vibe",
-  "version": "1.0.74",
+  "version": "1.0.75",
   "description": "Vibe sessions, handoff, seed refresh, and ClosedLoop ticket workflows",
   "author": {"name": "ClosedLoop", "email": "support@closedloop.ai"},
   "homepage": "https://github.com/closedloop-ai/claude-plugins",
diff --git a/plugins/vibe/agents/vibe-change-worker.md b/plugins/vibe/agents/vibe-change-worker.md
index 085eb2ee..ed6c8705 100644
--- a/plugins/vibe/agents/vibe-change-worker.md
+++ b/plugins/vibe/agents/vibe-change-worker.md
@@ -564,7 +564,11 @@ handoff the missing tests list: `STORIES_READY` names the new Storybook
 components' story IDs and continues the same request; `NEEDS_STORYBOOK`
 asks for placement advice and continues the same request; `NEEDS_REVIEW` waits for handoff's implementation/coverage review;
 `NEEDS_PERSON` is only a researched necessary product question or legitimate
-human-only action, never a test or engineering choice; `NEEDS_COMMIT` waits
+human-only action, never a test or engineering choice. Never stop for
+authorization on in-scope work (repairing tests your change broke, a main
+merge, a push, an in-scope fix): do it and report it afterwards; only a flag
+key, a product question, a destructive action or a credential waits, and
+`session-questions.mjs ask` refuses any other permission question. `NEEDS_COMMIT` waits
 for the orchestrator; `DONE` means the whole requested feature passed its
 quick checks in the loop, or its checks and reviews at handoff, and always
 carries the Acceptance criteria block: each touched criterion's ID, quoted
diff --git a/plugins/vibe/agents/vibe-ticket-worker.md b/plugins/vibe/agents/vibe-ticket-worker.md
index 8d0658b6..5461e0af 100644
--- a/plugins/vibe/agents/vibe-ticket-worker.md
+++ b/plugins/vibe/agents/vibe-ticket-worker.md
@@ -216,7 +216,7 @@ With `mergeCheck: true`, change nothing else: run
 `gh pr list --repo closedloop-ai/symphony-alpha --head <session branch> --state merged --json number,url,mergedAt`
 from the worktree. When it lists a merged pull request and the PLN is not
 `EXECUTED`, run
-`node ../skills/handoff/scripts/executed-check.mjs --file <its saved latest text> --last-merge <mergedAt>`;
+`node ../skills/handoff/scripts/executed-check.mjs --kind plan --file <its saved latest text> --last-merge <mergedAt>`;
 when it fails, append a version adding the section it names (the session's
 flag keys, each read now from the flag service), and rerun it. Only once it
 passes, set `EXECUTED` through step F (with `expectedStatus` the status you
diff --git a/plugins/vibe/skills/codex-fleet-monitor/SKILL.md b/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
index 2b8a51ef..dc2e5da3 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
+++ b/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
@@ -36,6 +36,8 @@ WATCH_NEW_PR_REPOS="owner/repo"  # optional: list open PRs here to spot new ones
 PR_SEARCH="head:feature/"        # optional: search filter for that list
 BOT_LOGIN_REGEX="vercel|codex|github-actions|copilot|bot"  # authors not counted as human feedback
 # USAGE_HIGH_PERCENT=80         # usage below this prints one band (default MOVE_AT_PERCENT, else 80)
+# CODEX_MODEL=<model>            # with CODEX_EFFORT, a thread on another model or effort gets a MODEL(...) word
+# CODEX_EFFORT=high
 RECOVERY_BACKOFF_SECONDS="120 300 600"  # wait before each resume of a transient failure; one retry per value
 # CONTINUE_PROMPT_FILE=/path/to/continue.md  # replaces the built-in continue prompt (REMOTE_CONTINUE_PROMPT_FILE on REMOTE_HOST)
 # AUTO_RESTART_DAEMON=1          # allow restarting the App Server daemon for threads stuck in systemError; off by default
@@ -63,7 +65,7 @@ The label is what appears in the output lines.
 scripts/watch.sh <workDir> [intervalSeconds]
 ```
 
-Start it with `run_in_background`. You are notified when it exits. Read its output, handle every line, then start it again; it only watches while running. An `IDLE` line includes the writer's final message tail and says `NEEDS-REPLY` when it ends in a question or permission request; classify that message before re-arming. `watch.sh` records its pid, each tick and its exit in `<workDir>/watcher.json`, and `node scripts/watcher.mjs <workDir>` prints `watcher ok` or `watcher MISSING(<why>)` (exit 1): check it before ending any turn that handled an event, and re-arm on `MISSING`. Editing `sessions.txt` or `prs.txt` takes effect on the next re-arm. `scripts/snapshot.sh <workDir>` prints the current state once.
+Start it with `run_in_background`, never with `&`; a second copy for the same work dir exits 3 and says how to re-arm. You are notified when it exits. Read its output, handle every line, then start it again; it only watches while running. An `IDLE` line includes the writer's final message tail, the same once the App Server unloads the thread (`notLoaded`), and says `NEEDS-REPLY` when any of its lines asks a question or asks for permission, authorization or approval; classify that message before re-arming. `watch.sh` records its pid, each tick and its exit in `<workDir>/watcher.json`, and `node scripts/watcher.mjs <workDir>` prints `watcher ok` or `watcher MISSING(<why>)` (exit 1): check it before ending any turn that handled an event, and re-arm on `MISSING`. Editing `sessions.txt` or `prs.txt` takes effect on the next re-arm. `scripts/snapshot.sh <workDir>` prints the current state once.
 
 ## Reading the output
 
@@ -71,6 +73,7 @@ Start it with `run_in_background`. You are notified when it exits. Read its outp
 |---|---|---|
 | `session <where> <name> RUN` | turn in progress and producing items | none |
 | `session ... IDLE` | turn completed; the session is waiting for you | read its last message, give it the next turn |
+| `session ... MODEL(<model>/<effort>!=<want>)` | the thread runs on another model or effort than `CODEX_MODEL` and `CODEX_EFFORT` | restart it on the configured one; other models were far slower |
 | `session ... STALLED(...)` | turn open but silent | check for a usage limit or a hung command; tell the user if it needs them |
 | `session ... FAILED(LIMIT)` | turn errored on a usage limit | tell the user right away; a reset or second account is theirs to do |
 | `session ... FAILED(TRANSIENT)` | turn errored on a transient provider failure: model at capacity, rate limit, 5xx or a dropped connection | none; recovery resumes it after the backoff (watch the `recovery` line) |
@@ -81,7 +84,7 @@ Start it with `run_in_background`. You are notified when it exits. Read its outp
 | `supervisor ... STALE(>Ns)` / `MISSING` / `UNREADABLE` | no heartbeat for 3 intervals (a hung or dead supervisor), the lock exists with no heartbeat, or the heartbeat cannot be parsed | read `supervisor.log` there; restart the supervisor |
 | `supervisor ... RSS-HIGH(>NMB)` | the supervisor's RSS is over `SUPERVISOR_RSS_CAP_MB` | read its hourly summary lines; restart it and report the leak |
 | `session remote <host> UNREACHABLE` | ssh failed | check the host |
-| `codex-usage <local\|remote> under80% ok resets=<n>` / `HIGH(<band>%)` | Codex account usage on that machine: one band below `USAGE_HIGH_PERCENT` (80 here) used, so ordinary use is not an event, then the used percent floored to 10; `resets` is the count of available limit resets | none below it; on `HIGH`, warn the user with the rate |
+| `codex-usage <local\|remote> under80% ok resets=<n>` / `HIGH(<band>%)` | Codex account usage on that machine: one band below `USAGE_HIGH_PERCENT` (80 here) used, so ordinary use is not an event, then the used percent floored to 10; `resets` is the count of available limit resets | none below it; on `HIGH`, warn the user at once with the band and `resets`, since applying a reset is theirs; if they are away, move the busiest writers to Claude writers |
 | `codex-usage ... LIMIT` / `LIMIT-STOPPED` | usage limit reached; `LIMIT` means ordinary usage is still allowed, `LIMIT-STOPPED` means sessions cannot run | tell the user right away; a reset or second account is theirs to do |
 | `codex-usage ... LIMIT-SPENDING-CREDITS` | limit reached and turns are now consuming paid credits | tell the user at once and stop sending turns unless they approve paid credits |
 | `codex-usage ... unknown` / `unreadable READFAIL` | the App Server answered without rate limits, or it or the remote host could not be read | check `codex` on that machine |
@@ -130,4 +133,4 @@ Every action is an `EVENT recovery ...` line in the events log, which the `recov
 - Item history lives in `<workDir>/item-history.txt`; delete it to reset stall timers. Settled check counts live in `<workDir>/checks-*.txt`. The `keep-*`, `merge-*` and `checks-*` files of a PR are removed once it leaves `prs.txt`.
 - On the remote host the scripts are copied to `<REMOTE_STATE_DIR>/.fleet-monitor/` on every snapshot.
 - A failed or empty `gh` read repeats that field's last value, so an API blip is not an event.
-- Don't run two copies on the same work dir.
+- `watch.sh` holds `<workDir>/watch.lock`; a second copy exits 3, and a lock whose pid died is taken over.
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/classify.sh b/plugins/vibe/skills/codex-fleet-monitor/scripts/classify.sh
index 17eae1eb..f7e75d07 100755
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/classify.sh
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/classify.sh
@@ -1,16 +1,18 @@
 #!/bin/zsh
 # stdin: "<where> <stateName> <turnStatus> <progress> <flag>". $1: item history file. $2: stall seconds.
 # A running turn whose progress (its newest item) has not changed for $2 seconds is STALLED (a Codex usage
-# limit leaves the turn open and silent, so "turn is open" alone is not liveness).
+# limit leaves the turn open and silent, so "turn is open" alone is not liveness). A MODEL(...) word that
+# liveness.mjs put first in the tail (a thread on another model or effort) is kept for every state.
 H=$1; STALL=${2:-720}; touch $H; now=$(date +%s)
 while read where n st items flag tail; do
   prev=$(grep "^$where:$n " $H | awk '{print $2, $3}'); pi=${prev% *}; pt=${prev#* }
   if [ -z "$prev" ] || [ "$pi" != "$items" ]; then pt=$now; fi
   grep -v "^$where:$n " $H > $H.tmp; echo "$where:$n $items $pt" >> $H.tmp; mv $H.tmp $H
+  drift=; if [[ $tail == MODEL\(* ]]; then drift=${tail%% *}; tail=${tail#$drift}; tail=${tail# }; fi
   if [ "$flag" != "-" ]; then s="FAILED($flag)"
   elif [ "$st" = inProgress ] && [ $((now - pt)) -ge $STALL ]; then s="STALLED(no progress $((STALL / 60))m+)"
   elif [ "$st" = inProgress ]; then s=RUN
   elif [ "$st" = completed ]; then s="IDLE${tail:+ $tail}"
   else s="STOPPED($st)"; fi
-  echo "session $where $n $s"
+  echo "session $where $n $s${drift:+ $drift}"
 done
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.mjs b/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.mjs
index 8b6b000f..429b7f72 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.mjs
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.mjs
@@ -2,6 +2,7 @@
 // A session is "<name>" (reads <stateDir>/<name>.json, which holds a threadId) or "<label>=<threadId>".
 // Prints "<label> <lastTurnStatus> <progress> <flag>"; progress is the id of the last turn's newest item (it
 // changes while the turn works), flag is LIMIT, TRANSIENT, SYSTEM-ERROR, ERROR, READFAIL or -.
+// With CODEX_MODEL or CODEX_EFFORT set, a thread on another model or effort adds MODEL(<model>/<effort>!=<want>).
 // It never loads a thread's history: a long thread's full read is tens of MB of JSON.
 // Self-contained: speaks the Codex App Server protocol to the managed daemon through
 // `codex app-server proxy`, so a single file is all a remote host needs.
@@ -260,27 +261,52 @@ export function parseSession(spec, dir) {
   return { label: spec, threadId: JSON.parse(readFileSync(`${dir}/${spec}.json`, 'utf8')).threadId };
 }
 
-/** The default turn and progress read a full thread (`includeTurns`), as fleet-orchestrator's `last` does. */
-export function summarize(label, thread, turn = (thread?.turns ?? []).at(-1), progress = String((turn?.items ?? []).length), lastItem = (turn?.items ?? []).at(-1)) {
+/**
+ * The default turn and progress read a full thread (`includeTurns`), as fleet-orchestrator's `last` does.
+ * A completed turn reads the same whether the App Server still holds the thread (`idle`) or has unloaded
+ * it (`notLoaded`), so a finished writer is IDLE with its final message either way.
+ */
+export function summarize(label, thread, turn = (thread?.turns ?? []).at(-1), progress = String((turn?.items ?? []).length), lastItem = (turn?.items ?? []).at(-1), want = {}) {
   let flag = '-';
   if (thread?.status?.type === 'systemError') flag = Failure.SystemError;
   else if (turn?.error) flag = classifyTurnError(turn.error);
-  const base = `${label} ${turn?.status ?? 'none'} ${progress} ${flag}`;
+  const drift = modelDrift(thread, want);
+  const base = `${label} ${turn?.status ?? 'none'} ${progress} ${flag}${drift ? ` ${drift}` : ''}`;
   if (turn?.status !== 'completed') return base;
   const tail = assistantTail(lastItem);
   return tail ? `${base} ${needsReply(tail) ? 'NEEDS-REPLY' : 'LAST'} ${JSON.stringify(tail)}` : base;
 }
 
+/**
+ * `MODEL(<model>/<effort>!=<want model>/<want effort>)` when the thread runs on another model or effort than
+ * `want` (CODEX_MODEL, CODEX_EFFORT), else ''. Sessions started without an explicit model once came up on a
+ * slower model and on the default effort. A value the App Server does not report is not judged.
+ */
+export function modelDrift(thread, { model, effort } = {}) {
+  const actual = { model: thread?.model, effort: thread?.reasoningEffort };
+  const off = (wanted, value) => Boolean(wanted) && typeof value === 'string' && value !== wanted;
+  if (!off(model, actual.model) && !off(effort, actual.effort)) return '';
+  const pair = (m, e) => `${m || '?'}/${e || '?'}`.replace(/\s+/g, '_');
+  return `MODEL(${pair(actual.model, actual.effort)}!=${pair(model || actual.model, effort || actual.effort)})`;
+}
+
 /** Final three non-empty lines of the newest assistant message. */
 export function assistantTail(item) {
   if (item?.type !== 'agentMessage' || typeof item.text !== 'string') return '';
   return item.text.split('\n').map((line) => line.trim()).filter(Boolean).slice(-3).join(' / ').slice(-500);
 }
 
+/**
+ * A final message that asks something: a question mark ending any of its lines or sentences, or a request
+ * for permission, authorization or approval anywhere in it. A writer that asked "May I ...?" and then
+ * ended on a status sentence once waited unread while the operator was away.
+ */
 export function needsReply(text) {
-  return /(?:\?|\bpermission\b)\s*$/i.test(text.trim());
+  return /\?(?=\s|$)/.test(text) || ASKING.test(text);
 }
 
+const ASKING = /\b(?:permission|authori[sz](?:e|ation)|approval|approve|may i|shall i|should i|do you want)\b/i;
+
 const UNKNOWN_METHOD = /unknown variant|method not found/i;
 
 /**
@@ -306,7 +332,7 @@ export async function readThreadState(client, threadId, { progress = false } = {
   return { thread, turn, progress: loaded[0]?.id ?? '-', lastItem: loaded.find((item) => item?.type === 'agentMessage') };
 }
 
-export async function readSessions(client, dir, specs) {
+export async function readSessions(client, dir, specs, want = {}) {
   const lines = [];
   for (const spec of specs) {
     let label = spec.split('=')[0];
@@ -314,7 +340,7 @@ export async function readSessions(client, dir, specs) {
       const session = parseSession(spec, dir);
       label = session.label;
       const { thread, turn, progress, lastItem } = await readThreadState(client, session.threadId, { progress: true });
-      lines.push(summarize(label, thread, turn, progress, lastItem));
+      lines.push(summarize(label, thread, turn, progress, lastItem, want));
     } catch {
       lines.push(`${label} unreadable 0 READFAIL`);
     }
@@ -332,13 +358,12 @@ async function main() {
     for (const spec of specs) console.log(`${spec.split('=')[0]} unreadable 0 READFAIL`);
     process.exit(0);
   }
-  for (const line of await readSessions(client, dir, specs)) console.log(line);
+  const want = { model: process.env.CODEX_MODEL || undefined, effort: process.env.CODEX_EFFORT || undefined };
+  for (const line of await readSessions(client, dir, specs, want)) console.log(line);
   client.close();
   process.exit(0);
 }
 
-if (isEntryPoint(import.meta.url)) await main();
-
 /** Bounds the whole run from inside node; macOS has no `timeout` or `gtimeout` command. */
 export function exitAfterTotalTimeout() {
   setTimeout(() => process.exit(1), TOTAL_TIMEOUT_MS).unref();
@@ -383,3 +408,7 @@ export function classifyTurnError(error) {
   if (LIMIT_MESSAGE.test(text)) return Failure.Limit;
   return Failure.Error;
 }
+
+// Last, after every declaration: a top-level await pauses this module, so a const declared below it would
+// still be uninitialized while main runs, and classifying a failed turn would throw.
+if (isEntryPoint(import.meta.url)) await main();
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.test.mjs b/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.test.mjs
index d40c20b6..01dfbe52 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.test.mjs
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/liveness.test.mjs
@@ -1,12 +1,14 @@
 import assert from 'node:assert/strict';
+import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { mkdtempSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdtempSync, writeFileSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
 import {
-  assistantTail, classifyTurnError, connectDirect, decodeFrames, encodeFrame, Failure, needsReply, parseSession, readSessions, readThreadState, summarize,
+  assistantTail, classifyTurnError, connectDirect, decodeFrames, encodeFrame, Failure, modelDrift, needsReply, parseSession, readSessions, readThreadState, summarize,
 } from './liveness.mjs';
 import { answerThreadRead } from './test-support.mjs';
 
@@ -197,3 +199,106 @@ test('a request times out while the connection never opens', async () => {
     silent.close();
   }
 });
+
+const LIVENESS = fileURLToPath(new URL('./liveness.mjs', import.meta.url));
+const CLASSIFY = fileURLToPath(new URL('./classify.sh', import.meta.url));
+
+async function withFakeServer(threads, body) {
+  const dir = mkdtempSync(join(tmpdir(), 'fleet-'));
+  const { server, calls } = fakeServer(threads);
+  const sock = join(dir, 's.sock');
+  await new Promise((resolve) => server.listen(sock, resolve));
+  try {
+    return await body({ dir, sock, calls });
+  } finally {
+    server.close();
+  }
+}
+
+test('a finished writer whose thread the App Server unloaded (notLoaded) still reads IDLE with its final message', async () => {
+  const done = item('i-9', 'Pushed the fix.\nPR is mergeable; waiting for the merge.');
+  const turns = [{ id: 't-1', status: 'completed', items: [item('i-8'), done] }];
+  await withFakeServer({ LOADED: { status: { type: 'idle' }, turns }, UNLOADED: { status: { type: 'notLoaded' }, turns } }, async ({ dir, sock }) => {
+    const client = connectDirect(sock);
+    try {
+      await client.initialize();
+      const [loaded, unloaded] = await readSessions(client, dir, ['w=LOADED', 'w=UNLOADED']);
+      assert.equal(unloaded, 'w completed i-9 - LAST "Pushed the fix. / PR is mergeable; waiting for the merge."');
+      assert.equal(unloaded, loaded, 'unloading a finished thread is neither an event nor a lost message');
+      const classified = spawnSync('zsh', [CLASSIFY, join(dir, 'history.txt'), '720'], { input: `remote ${unloaded}\n`, encoding: 'utf8' });
+      assert.equal(classified.stdout, 'session remote w IDLE LAST "Pushed the fix. / PR is mergeable; waiting for the merge."\n');
+    } finally {
+      client.close();
+    }
+  });
+});
+
+test('NEEDS-REPLY catches a question or permission request anywhere in the final lines, not only at the end', () => {
+  const asks = [
+    '1. Should the depth limit apply within one project only? / 2. May I use the plain-push fallback here? Publication was refused. / The PR has not been opened yet.',
+    'Draft PR open. Repairing the five stale tests is pending authorization.',
+    'Everything else is done; approval needed before I merge main.',
+    'Which option do you want?',
+  ];
+  for (const text of asks) assert.equal(needsReply(text), true, text);
+  const reports = [
+    'Auto-merge armed. / QA is document review; no UI applies.',
+    'Opened https://example.test/pull/7?tab=checks and all checks passed.',
+    'Approved stories were left unchanged.',
+  ];
+  for (const text of reports) assert.equal(needsReply(text), false, text);
+});
+
+test('a thread on another model or effort than the configured one is flagged on every state', () => {
+  const want = { model: 'fast-model', effort: 'high' };
+  assert.equal(modelDrift({ model: 'fast-model', reasoningEffort: 'high' }, want), '');
+  assert.equal(modelDrift({ model: 'slow-model', reasoningEffort: 'high' }, want), 'MODEL(slow-model/high!=fast-model/high)');
+  assert.equal(modelDrift({ model: 'fast-model', reasoningEffort: 'medium' }, want), 'MODEL(fast-model/medium!=fast-model/high)');
+  assert.equal(modelDrift({ model: 'slow-model', reasoningEffort: 'medium' }, {}), '', 'nothing configured, nothing judged');
+  assert.equal(modelDrift({}, want), '', 'a value the App Server does not report is not judged');
+  const running = { status: 'inProgress', items: [item('i-1')] };
+  assert.equal(summarize('w', { model: 'slow-model', reasoningEffort: 'medium' }, running, 'i-1', null, want), 'w inProgress i-1 - MODEL(slow-model/medium!=fast-model/high)');
+  const dir = mkdtempSync(join(tmpdir(), 'fleet-'));
+  const lines = [
+    'local a inProgress i-1 - MODEL(slow-model/medium!=fast-model/high)',
+    'local b completed i-2 - MODEL(slow-model/high!=fast-model/high) LAST "done"',
+    'local c completed i-3 - LAST "done"',
+  ];
+  const classified = spawnSync('zsh', [CLASSIFY, join(dir, 'history.txt'), '720'], { input: `${lines.join('\n')}\n`, encoding: 'utf8' });
+  assert.deepEqual(classified.stdout.trim().split('\n'), [
+    'session local a RUN MODEL(slow-model/medium!=fast-model/high)',
+    'session local b IDLE LAST "done" MODEL(slow-model/high!=fast-model/high)',
+    'session local c IDLE LAST "done"',
+  ]);
+});
+
+test('run as a command, it classifies a failed turn and flags model drift from CODEX_MODEL and CODEX_EFFORT', { timeout: 30_000 }, async () => {
+  const threads = {
+    T1: { status: { type: 'notLoaded' }, model: 'slow-model', reasoningEffort: 'medium', turns: [{ id: 't-1', status: 'completed', items: [item('i-1', 'May I repair the tests?')] }] },
+    T2: { status: { type: 'idle' }, model: 'fast-model', reasoningEffort: 'high', turns: [{ id: 't-2', status: 'failed', items: [item('i-2')], error: { message: 'You hit your usage limit', codexErrorInfo: 'usageLimitExceeded' } }] },
+  };
+  await withFakeServer(threads, async ({ dir, sock }) => {
+    // A fake codex: `app-server daemon start` names the fake server's socket, `app-server proxy` pipes stdio to it.
+    const codex = join(dir, 'codex');
+    writeFileSync(codex, `#!/usr/bin/env node
+const net = require('node:net');
+const args = process.argv.slice(2).join(' ');
+if (args.startsWith('app-server daemon start')) { process.stdout.write(JSON.stringify({ socketPath: ${JSON.stringify(sock)} })); process.exit(0); }
+if (args.startsWith('app-server proxy')) { const s = net.connect(process.argv.at(-1)); process.stdin.pipe(s); s.pipe(process.stdout); s.on('close', () => process.exit(0)); }
+else process.exit(1);
+`);
+    chmodSync(codex, 0o755);
+    const child = spawn(process.execPath, [LIVENESS, dir, 'one=T1', 'two=T2'], {
+      env: { ...process.env, PATH: `${dir}:${process.env.PATH}`, CODEX_MODEL: 'fast-model', CODEX_EFFORT: 'high' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    const status = await new Promise((resolve) => child.on('exit', resolve));
+    assert.equal(status, 0);
+    assert.deepEqual(stdout.trim().split('\n'), [
+      'one completed i-1 - MODEL(slow-model/medium!=fast-model/high) NEEDS-REPLY "May I repair the tests?"',
+      'two failed i-2 LIMIT',
+    ]);
+  });
+});
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
index 8efe253f..1218994a 100755
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
@@ -13,6 +13,7 @@ remote_node() {
   local e="USAGE_HIGH_PERCENT=$HIGH AUTO_RESTART_DAEMON=${AUTO_RESTART_DAEMON:-} RECOVERY_BACKOFF_SECONDS=${${RECOVERY_BACKOFF_SECONDS:-}// /,}"
   e+=" RESTART_COOLDOWN_SECONDS=${RESTART_COOLDOWN_SECONDS:-} CONTINUE_PROMPT_FILE=${REMOTE_CONTINUE_PROMPT_FILE:-}"
   e+=" PASS_TIMEOUT_SECONDS=${PASS_TIMEOUT_SECONDS:-} LOG_MAX_BYTES=${LOG_MAX_BYTES:-} SUPERVISOR_RSS_CAP_MB=${SUPERVISOR_RSS_CAP_MB:-}"
+  e+=" CODEX_MODEL=${CODEX_MODEL:-} CODEX_EFFORT=${CODEX_EFFORT:-}"
   COPYFILE_DISABLE=1 tar -C $K -cf - liveness.mjs ratelimit.mjs recover.mjs 2>/dev/null | ssh -o ConnectTimeout=10 -o ServerAliveInterval=15 \
     ${REMOTE_HOST:?set REMOTE_HOST} "mkdir -p $d && tar -C $d -xf - && $REMOTE_SHELL 'env $e node $d/$*'" 2>/dev/null
 }
@@ -36,7 +37,7 @@ if [ "${RECOVER:-}" = 1 ]; then
 fi
 if [ -n "${L// }" ]; then
   SUPERVISOR_RSS_CAP_MB=${SUPERVISOR_RSS_CAP_MB:-} node $K/recover.mjs --report $LOCAL_STATE_DIR local
-  node $K/liveness.mjs ${LOCAL_STATE_DIR:?set LOCAL_STATE_DIR} ${=L} | sed 's/^/local /' >> $W/live.txt
+  CODEX_MODEL=${CODEX_MODEL:-} CODEX_EFFORT=${CODEX_EFFORT:-} node $K/liveness.mjs ${LOCAL_STATE_DIR:?set LOCAL_STATE_DIR} ${=L} | sed 's/^/local /' >> $W/live.txt
 fi
 if [ -n "${R// }" ]; then
   out=$(remote_node recover.mjs --report $REMOTE_STATE_DIR remote); echo "${out:-recovery remote unreadable}"
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/watch.sh b/plugins/vibe/skills/codex-fleet-monitor/scripts/watch.sh
index 70391a93..d81471d8 100755
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/watch.sh
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/watch.sh
@@ -1,6 +1,20 @@
 #!/bin/zsh
 # Usage: watch.sh <workDir> [intervalSeconds]. Exits with the diff on the first change.
 K=${0:A:h}; W=${1:?workDir}; I=${2:-120}
+# One watcher per work dir. A second copy (one started with `&` in a foreground shell, then started again)
+# double-reports every event and outlives the turn that started it, so it is refused, not run.
+lock=$W/watch.lock
+if ! mkdir $lock 2>/dev/null; then
+  other=$(cat $lock/pid 2>/dev/null)
+  if [ -n "$other" ] && [ "$other" -gt 1 ] && kill -0 $other 2>/dev/null; then
+    print -u2 "watch.sh: watcher pid $other already runs for $W; read its events when it exits, then start it again with your harness's background option (run_in_background), never with &"
+    exit 3
+  fi
+  rm -rf $lock; mkdir $lock || exit 3
+fi
+print $$ > $lock/pid
+trap 'rm -rf $lock' EXIT
+trap 'exit 143' TERM HUP INT
 # watcher.json records this watcher's pid and last tick, and its exit, so watcher.mjs can tell a lapsed watcher.
 started=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 beat() {
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs b/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
index 48815fde..91a72cf8 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
@@ -80,3 +80,44 @@ test('watch.sh records its pid at start, and a killed watcher reads as dead', {
   await exited;
   assert.equal(watcherState(dir).line, `watcher MISSING(pid ${child.pid} dead)`);
 });
+
+test('a second watch.sh on the same work dir is refused while the first runs, and starts once it is gone', { timeout: 30_000 }, async (t) => {
+  const dir = workDir(t);
+  writeFileSync(join(dir, 'last-snapshot.txt'), 'session local a RUN\n');
+  const child = spawn('zsh', [WATCH, dir, '600'], { stdio: 'ignore', detached: true });
+  const killGroup = () => {
+    if (!(child.pid > 1)) return;
+    try {
+      process.kill(-child.pid, 'SIGKILL');
+    } catch {
+      // Already gone.
+    }
+  };
+  t.after(killGroup);
+  for (let i = 0; i < 100 && !existsSync(join(dir, 'watcher.json')); i += 1) await new Promise((resolve) => setTimeout(resolve, 100));
+  const second = spawnSync('zsh', [WATCH, dir, '600'], { encoding: 'utf8', timeout: 10_000 });
+  assert.equal(second.status, 3);
+  assert.match(second.stderr, new RegExp(`watcher pid ${child.pid} already runs`));
+  assert.match(second.stderr, /run_in_background\), never with &/);
+  assert.equal(JSON.parse(readFileSync(join(dir, 'watcher.json'), 'utf8')).pid, child.pid, 'the refused copy leaves the live watcher record alone');
+  const exited = new Promise((resolve) => child.on('exit', resolve));
+  killGroup();
+  await exited;
+  // SIGKILL skips the EXIT trap, so the lock is left behind with a dead pid; the next start takes it over.
+  const third = spawn('zsh', [WATCH, dir, '600'], { stdio: 'ignore', detached: true });
+  t.after(() => {
+    if (third.pid > 1) {
+      try {
+        process.kill(-third.pid, 'SIGKILL');
+      } catch {
+        // Already gone.
+      }
+    }
+  });
+  let state = null;
+  for (let i = 0; i < 100 && state?.pid !== third.pid; i += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try { state = JSON.parse(readFileSync(join(dir, 'watcher.json'), 'utf8')); } catch { state = null; }
+  }
+  assert.equal(state?.pid, third.pid);
+});
diff --git a/plugins/vibe/skills/fleet-orchestrator/SKILL.md b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
index 70189691..b1c3f91c 100644
--- a/plugins/vibe/skills/fleet-orchestrator/SKILL.md
+++ b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
@@ -12,6 +12,7 @@ You run a program of several PRs at once: you plan, route, review, push back and
 1. **The operator's attention is the scarcest resource.** Decide everything you can yourself (precedent, sibling consistency, repo rules, measurements), act on it, and tell the operator the ruling in one line so they can override. Escalate only what needs them (product trade-offs, irreversible actions, approvals the repo reserves for humans), one question at a time with a recommendation. Never forward a worker's question or result without first trying to settle or verify it.
    Before any ruling on behavior, follow the single ordered product-question
    research list in [vibe's quality loop](../vibe/references/quality-loop.md#communication-and-product-questions); do not copy or reorder it here. Under fleet orchestration, a writer's `NEEDS_PERSON` comes to you, and you finish that list before asking the operator.
+   Every question to the operator names where you checked the code first (`checked in code: <file>:<line>`); drop one the code already answers. `scripts/review-page-check.mjs` refuses a decision row without it.
 
    A human-sourced line that conflicts with the ruling goes to the operator as a question with a recommendation. Record every ruling with its source in the resume log as `- Ruling (<who>): <decision>`, and have the writer add it to the ticket with the criteria it amends (`../handoff/scripts/rulings-check.mjs` fails until it is there) and cite it on the relevant thread.
 
@@ -71,7 +72,7 @@ The closedloop-graph MCP server is required; decide from it, not from guesses. T
 Run [codex-fleet-monitor](../codex-fleet-monitor/SKILL.md) (`vibe:codex-fleet-monitor`) on the same `<orchDir>` in the background for the whole program and act on its lines as its table says, including usage bands, paid-credit spending and request files. It reads the session state files `fleet.sh` writes, listed as `local|remote <name>` in `sessions.txt`.
 
 - The watcher resumes a session after a transient provider failure on its own; read its `recovery` lines when you wake. Run its supervisor on every machine that hosts Codex writers, so recovery also happens while you are not running. Set `AUTO_RESTART_DAEMON=1` in `config.env` only when the operator agrees that a stuck daemon may be restarted unattended.
-- Re-arm the watcher in the same step you read each event. It only watches while running, and it costs nothing while waiting. Before ending any turn that handled an event, `node ../codex-fleet-monitor/scripts/watcher.mjs <orchDir>` must print `watcher ok`; on `MISSING`, re-arm it. A lost re-arm once left pushes unhandled for two hours.
+- Re-arm the watcher in the same step you read each event. It only watches while running, and it costs nothing while waiting. Before ending any turn that handled an event, `node ../codex-fleet-monitor/scripts/watcher.mjs <orchDir>` must print `watcher ok`; on `MISSING`, re-arm it. A lost re-arm once left pushes unhandled for two hours. Start it with the harness's background option (`run_in_background`), never with `&`, which left a stray copy twice; `watch.sh` refuses a second copy for the same work dir.
 - Before you or a reviewer inspect a head, check it equals the pushed PR head (`gh pr view <n> --json headRefOid`). Sessions sometimes report local, unpushed commits.
 
 ## Codex sessions
@@ -86,7 +87,8 @@ scripts/fleet.sh <orchDir> local|remote session last  <name> [--count <n>]
 
 - `turn` starts a thread bound to `--cwd` the first time (refusing a different cwd later) and resumes it afterwards, then starts a turn.
   - `--model` and `--effort` default to `CODEX_MODEL` and `CODEX_EFFORT`.
-  - A new session refuses to start without an effort or with a prompt that does not start with `$vibe`.
+  - A new session refuses to start without a model or an effort, or with a prompt that does not start with `$vibe`.
+  - Start every Codex writer this way, never through a bare thread start without both: one came up on a model that ran about 17 tokens per second and another on the default effort. The watcher marks a thread on another model or effort `MODEL(...)`; restart it on the configured one.
   - Model, effort, sandbox and each prompt file sent persist in the session's state file.
 - `steer` adds to the active turn and fails when none is running.
 - `last` prints the monitor's status line and the last agent messages.
@@ -100,6 +102,7 @@ scripts/fleet.sh <orchDir> local|remote session last  <name> [--count <n>]
 - Launch each Claude writer with the [worker preamble](./references/templates.md#worker-preamble) saved to `prompts/`. It starts with invoking vibe and carries the worktree, PR, reading, test, git, thread-reply and report rules so no writer improvises them.
 - A message to a busy worker arrives only when it goes idle; if it idles without acting on one, resend it once, then interrupt after the second unanswered delivery instead of sending a third.
 - A pane teammate sees your messages only when its current turn ends. For an urgent redirect, ask the operator to press Esc in the named pane, which ends the turn and delivers them; otherwise expect delivery at the next turn boundary. Keep long briefs in a file and send its path.
+- A standing duty (main's post-merge health, a PR shepherd, the watcher) always has a live owner: `board.mjs <orchDir> duty <duty> --owner <writer or helper>`. Name the replacement in the same step you stop or move its owner; `helpers.mjs stopped` refuses an owner, and `board.mjs status` prints `UNOWNED-DUTY`. Main's health once went unwatched for an hour after its watcher was stopped to save budget.
 - Stop a helper (reviewer, verifier, QA prep, poller) as soon as you accept its result; its brief and findings are on disk, so the next trigger launches a fresh one. Idle helper panes hide the active ones from the operator. Record each with `scripts/helpers.mjs <orchDir> start|accepted|stopped <name>`, and run `scripts/helpers.mjs <orchDir> status` with every monitor event: each `STOP` line is a helper to stop now, each `ORPHAN` line a stopped helper whose processes still run. A helper records every process it starts (dev servers, app stacks) with `helpers.mjs <orchDir> pid <name> <pid...>`, adding `--group` only for one it spawned detached; `stopped` ends them and refuses while any lives. Stopped QA agents once left dev servers running for 13 to 16 hours.
 
 ## Fleet board and direct messages
@@ -107,15 +110,15 @@ scripts/fleet.sh <orchDir> local|remote session last  <name> [--count <n>]
 Writers that could not see each other's work collided, a QA guide never heard its checkpoint was ready, and a UX ruling reached one writer while another PR rendered the same behavior. `scripts/board.mjs` keeps `<orchDir>/board.md`, the page every writer reads:
 
 - At every writer assignment and every merge, gather each in-scope PRD's children (status, assigned writer, linked pull requests and their state) into a snapshot and run `node scripts/status-audit.mjs --snapshot <file>`. It fails until each `MISMATCH` (a merged PR means DONE; an open PR or a writer means IN_PROGRESS or IN_REVIEW) and `UNOWNED` child (not done, no writer) is fixed, or listed under `outOfScope` with who ruled it out. Statuses once drifted until the operator noticed.
-- When you launch a writer, add its row (`board.mjs <orchDir> writer <name> --pr <n> --repo <owner/repo> --head <sha> --status <text> --deps <a,b>`) and give it the board path and the messaging recipe ([worker preamble](./references/templates.md#worker-preamble)). Update the row on every push report.
+- When you launch a writer, add its row (`board.mjs <orchDir> writer <name> --runtime codex|claude --pr <n> --repo <owner/repo> --head <sha> --status <text> --deps <a,b>`) and give it the board path and the messaging recipe ([worker preamble](./references/templates.md#worker-preamble)). Update the row on every push report.
 - Writers message each other directly: Codex writers through the `app-server-orchestrator` skill's send, Claude workers and QA guides through SendMessage.
 - A settled UX ruling is saved once as a reference file with its screenshots in a shared evidence location. Find every renderer of the behavior with `code_grep` across each open PR's diff and main, then `board.mjs <orchDir> deliver <ruling> --kind ruling --reference <file> --to <every owning writer and QA guide>`. Every QA plan for that behavior cites the reference, and one shared component beats each PR building its own.
 - When QA prep marks a human checkpoint ready, or rebinds results, `deliver <checkpoint> --kind checkpoint --head <sha> --to <guide>` and message the guide yourself with the checkpoint, its launch steps and the head.
-- After each message, `board.mjs <orchDir> told <item> <recipient>`. Run `board.mjs <orchDir> status` with every monitor event: each `STALE` row is a writer whose pushed head the board does not show, each `UNTOLD` line someone still to tell.
+- After each message, `board.mjs <orchDir> told <item> <recipient>`. Run `board.mjs <orchDir> status` with every monitor event: each `STALE` row is a writer whose pushed head the board does not show, each `UNTOLD` line someone still to tell, each `UNOWNED-DUTY` a duty to give an owner now. A `SLOW` row is a Codex writer 30 minutes without a push on a PR with unresolved human threads: have it push and hand the branch to a Claude writer (Codex to Claude, below), as for a dead writer.
 
 ## Moving work between runtimes and accounts
 
-- Move a machine's busiest writers when its `codex-usage` band reaches `MOVE_AT_PERCENT`, or its trend says it will before the work is done, and on any `LIMIT` or `LIMIT-SPENDING-CREDITS` line. Move a Claude writer when it hits its usage or rate limit; the monitor cannot read Claude usage, so you learn it from the worker's errors or from the operator.
+- When a machine's `codex-usage` band reaches `MOVE_AT_PERCENT`, or its trend says it will before the work is done, tell the operator at once with the band and `resets=<n>`: applying a limit reset is theirs. When they are away, move its busiest writers to Claude writers now instead of waiting for an answer. Move them on any `LIMIT` or `LIMIT-SPENDING-CREDITS` line too. Move a Claude writer when it hits its usage or rate limit; the monitor cannot read Claude usage, so you learn it from the worker's errors or from the operator.
 - When the operator reports high Claude usage, stop idle and polling Claude workers first, ask active ones to push a checkpoint and end, move their remaining work to Codex writers, and widen the Claude polling interval.
 - Before any move the old writer stops, or is confirmed dead, after committing and pushing or reporting its uncommitted state. One writer per branch holds through every move.
 - Codex to another Codex machine or account: a fresh thread through `fleet.sh` in the branch's worktree there, with a [resume prompt](./references/templates.md#resume-prompt).
@@ -160,6 +163,7 @@ Writers that could not see each other's work collided, a QA guide never heard it
 
   Send QA findings to a writer only through `node scripts/finding-brief.mjs <orchDir> --findings <findings.json> --prompt <prompt> [--where remote]`: it refuses a finding with no story id or route, viewport, selector or screenshot, or explicit `touchedSurface`, and puts the screenshots where the writer's machine can open them (`fleet.sh` ships them with the prompt).
   You alone file a ticket for a QA finding (the QA guide never does), and only after searching open tickets created in the last day for the same subject. Two actors once filed the same follow-up a minute apart.
+  Group audit and bug fixes into as few tickets and PRs as speed allows (operator ruling): one umbrella ticket, with PRs split by code area so writers work in parallel, never one ticket and PR per finding or per PRD.
   Before filing a ticket or moving one to in review, run `node ../vibe/scripts/ticket-write-check.mjs` with its project, parents and status; it refuses a past sprint, a parent that is executed, obsolete, done or canceled, and in review without the delivering pull request. Set the project explicitly rather than taking the default.
 - Check the test selection in each push report (the PR evidence file's selected tests and their runs) and have QA compare it with the specs the PR edits; selection covers the whole branch diff, not the latest push.
 - Every PR gets an independent review, then a verification pass of the fixes, before it is QA-ready. Resolve a thread only after the fix is verified in code, with a reply naming the fixing SHA.
@@ -178,13 +182,14 @@ Pushback applies principle 2; more judgment patterns from past programs: [refere
 - An instruction to match a prototype or design never removes what main ships: diff main's shipped controls and items against the target before you brief a writer, and keep any the target leaves out unless a human source retires it.
 - Never invent product behavior or user-facing copy; cite the human source. Never write a row the repo reserves for human attestation; read the owning check's header and ask the operator.
 - Respect operator boundaries on other teams' work, such as "don't fix main" while another owner is fixing it.
+- Work outside the program goes to its owner (operator ruling): a security or infrastructure finding outside its scope, such as a runtime advisory, becomes a ticket assigned to that owner, and the worker investigating it stops. The program does not take the fix.
 
 ## Lessons loop
 
 - Log every finding you route to a writer in the lessons ledger at the same moment, tagged new or repeat, with owner and fix. Batched later, they get lost. Format: [references/state.md](./references/state.md#lessons-ledger).
 - A repeat after a shipped fix means the earlier encoding did not bite: make it a gate, not more prose.
 - A plugin PR that encodes lessons replaces the prose its gate enforces and reports the net change in instruction length. The plugin must not get heavier.
-- Batch lesson and tooling fixes into one open PR per repo and add to it until it merges, never one PR per lesson: each PR costs a full CI run.
+- Batch lesson and tooling fixes into one open PR per repo and add to it until it merges, never one PR per lesson: each PR costs a full CI run. Before opening one, `node scripts/lessons-pr.mjs --repo <owner/repo>` must print `no open lessons PR`; otherwise push the batch onto the branch it names. Four stacked lessons PRs once had to be restacked onto main.
 - A lesson's primary fix lives in vibe itself, its writer instructions plus a mechanical check, because many people run vibe without an orchestrator; a rule here is only a second layer.
 - A lessons PR encodes general rules only. One repo's product rules, paths and component names go in that repo's own instruction files, gates or knowledge base, never in this plugin.
 
@@ -203,4 +208,4 @@ Hard rule. A ticket, PR body, PR comment, review reply or any other artifact wri
 - When the operator steps away, keep `<orchDir>/attention.md` current (decision needed, recommendation, what is blocked), keep reading idle writers' last messages, and lead with that list on return.
 - Put every finding the operator reviews on one page using the stable `D`, `X`, `N`, `S` and `R` IDs in the [operator review template](./references/templates.md#operator-review-page); never restart numbering across audits.
 - The final report lists, per PRD, which flags must be on to see each change.
-- Before a PRD is marked executed, its first section is `## Production visual QA`: each feature flag its shipped changes rely on, where to see it in production and its current production state (or `No flags: <why>`), then `Checked: <ISO time>` taken after the last merge, so someone else can visual-QA it in production. `node ../handoff/scripts/executed-check.mjs --file <PRD text> --last-merge <time>` must pass first.
+- Before a PRD is marked executed, its first section is `## Production visual QA`: each feature flag its shipped changes rely on, where to see it in production and its current production state (or `No flags: <why>`), then `Checked: <ISO time>` taken after the last merge, so someone else can visual-QA it in production. `node ../handoff/scripts/executed-check.mjs --kind prd --file <PRD text> --last-merge <time> --children <its PRODUCES children read now>` must pass first; it also refuses while any child is not DONE or CANCELED, so report the open ones instead. A PRD was once marked executed with four children open.
diff --git a/plugins/vibe/skills/fleet-orchestrator/references/templates.md b/plugins/vibe/skills/fleet-orchestrator/references/templates.md
index ae6cb631..e3fe5bb8 100644
--- a/plugins/vibe/skills/fleet-orchestrator/references/templates.md
+++ b/plugins/vibe/skills/fleet-orchestrator/references/templates.md
@@ -81,10 +81,11 @@ Record each result in the plan. Append each failure (checkpoint, what the operat
 Keep all findings the operator reviews on one page. Assign each a stable,
 never-reused ID: `D###` decision needed, `X###` fixing, `N###` stands,
 `S###` superseded or `R###` ruling. Preserve the ID when its status changes.
-Run `node scripts/review-page-check.mjs <orchDir>/review.md` before showing it.
+Run `node scripts/review-page-check.mjs <orchDir>/review.md` before showing it;
+a `D###` row also says `checked in code: <file>:<line>`.
 
 ```
-<ID> | <status> | <PR or surface> | <finding and evidence> | <recommendation or resolution>
+<ID> | <status> | <PR or surface> | <finding and evidence; for a decision, checked in code: <file>:<line>> | <recommendation or resolution>
 ```
 
 ## Flag approval
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/board.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/board.mjs
index f496f034..d8fd16ca 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/board.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/board.mjs
@@ -4,10 +4,11 @@
 // a QA guide never heard that its checkpoint was ready, and a UX ruling
 // reached one writer as text while another PR rendered the same behavior.
 //
-// Usage: board.mjs <orchDir> writer <name> [--pr <n>] [--repo <owner/repo>] [--head <sha>] [--status <text>] [--deps <a,b>]
+// Usage: board.mjs <orchDir> writer <name> [--pr <n>] [--repo <owner/repo>] [--head <sha>] [--status <text>] [--deps <a,b>] [--runtime codex|claude]
 //        board.mjs <orchDir> deliver <item> --to <a,b> [--kind ruling|checkpoint|note] [--reference <file>] [--head <sha>]
 //        board.mjs <orchDir> told <item> <recipient>
-//        board.mjs <orchDir> status [--pushed <name>=<sha>]...
+//        board.mjs <orchDir> duty <duty> --owner <writer or helper>
+//        board.mjs <orchDir> status [--pushed <name>=<sha>]... [--threads <name>=<n>]...
 //
 // `writer` adds or updates a writer's row (owner, PR, head, status,
 // dependencies). `deliver` records something each recipient must be told
@@ -20,6 +21,17 @@
 // with a PR and repo; `BOARD_GH` overrides the gh binary), and
 // `UNTOLD <item> <recipient>` for each recipient not yet told, then
 // `board: <writers> writers, <stale> stale, <untold> untold`; exits 1 when any.
+//
+// A standing duty (main's post-merge health, a PR shepherd, the watcher) has a
+// named owner (`duty`). Main's health once went unwatched for an hour after its
+// owner was stopped with no replacement. `status` prints `UNOWNED-DUTY <duty>
+// owner <who> <why>` when the owner is neither a board writer nor a running
+// helper in helpers.json, and helpers.mjs refuses to stop an owner.
+// A Codex writer (`--runtime codex`) whose head has not moved for 30 minutes
+// while its PR has unresolved human review threads (`--threads`, or read with
+// `gh api graphql` for rows with a PR and repo) prints `SLOW <writer> ...`:
+// hand it to a Claude writer. One spent 35 minutes on nine threads without a push.
+// Both count toward the exit status.
 
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -31,6 +43,9 @@ const STATE = "board.json";
 const PAGE = "board.md";
 const KINDS = new Set(["ruling", "checkpoint", "note"]);
 const LOG_LINES = 50;
+const RUNTIMES = new Set(["codex", "claude"]);
+const SLOW_MINUTES = 30;
+const BOTS = new RegExp(process.env.BOT_LOGIN_REGEX || "vercel|codex|github-actions|copilot|bot", "i");
 
 /** Rows whose recorded head differs from the pushed head; a row with no known pushed head is not judged. */
 export function staleRows(board, pushed) {
@@ -39,6 +54,23 @@ export function staleRows(board, pushed) {
     .map(([name, row]) => ({ name, head: row.head ?? "none", pushed: pushed[name] }));
 }
 
+/** Codex writers whose head has not moved for SLOW_MINUTES while their PR has unresolved human threads. */
+export function slowRows(board, threads, now) {
+  return Object.entries(board.writers)
+    .filter(([name, row]) => row.runtime === "codex" && threads[name] > 0 && row.headAt && now - Date.parse(row.headAt) >= SLOW_MINUTES * 60_000)
+    .map(([name, row]) => ({ name, minutes: Math.floor((now - Date.parse(row.headAt)) / 60_000), threads: threads[name] }));
+}
+
+/** Duties whose owner is not a board writer and not a started, unstopped helper. */
+export function unownedDuties(board, helpers) {
+  return Object.entries(board.duties).flatMap(([duty, { owner }]) => {
+    if (board.writers[owner]) return [];
+    const helper = helpers[owner];
+    if (helper?.startedAt && !helper.stoppedAt) return [];
+    return [{ duty, owner, why: helper?.stoppedAt ? `stopped ${helper.stoppedAt}` : "is not a writer or a running helper" }];
+  });
+}
+
 /** Every recipient of every delivery not yet told. */
 export function untold(board) {
   return Object.entries(board.deliveries).flatMap(([item, delivery]) =>
@@ -51,6 +83,7 @@ export function render(board) {
     `| ${name} | ${row.pr ? `${row.repo ?? ""}#${row.pr}` : ""} | ${row.head ?? ""} | ${row.status ?? ""} | ${(row.deps ?? []).join(", ")} | ${row.updatedAt} |`);
   const open = untold(board).map(({ item, recipient, delivery }) =>
     `- ${item} (${delivery.kind}) for ${recipient}${delivery.reference ? `: ${delivery.reference}` : ""}${delivery.head ? ` at ${delivery.head}` : ""}`);
+  const duties = Object.entries(board.duties).map(([duty, { owner, at }]) => `- ${duty}: ${owner} (since ${at})`);
   return [
     "# Fleet board",
     "",
@@ -58,6 +91,10 @@ export function render(board) {
     "|---|---|---|---|---|---|",
     ...rows,
     "",
+    "## Standing duties",
+    "",
+    ...(duties.length > 0 ? duties : ["- none"]),
+    "",
     "## Not yet told",
     "",
     ...(open.length > 0 ? open : ["- nothing"]),
@@ -72,7 +109,7 @@ export function render(board) {
 function read(orchDir) {
   const file = path.join(orchDir, STATE);
   const board = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
-  return { writers: board.writers ?? {}, deliveries: board.deliveries ?? {}, log: board.log ?? [] };
+  return { writers: board.writers ?? {}, deliveries: board.deliveries ?? {}, duties: board.duties ?? {}, log: board.log ?? [] };
 }
 
 function write(orchDir, board, line, at) {
@@ -98,14 +135,49 @@ function ghHead(row) {
   }
 }
 
-function pushedHeads(board, pairs) {
-  const pushed = Object.fromEntries(pairs.map((pair) => {
+const THREADS_QUERY = "query($o:String!,$n:String!,$p:Int!){repository(owner:$o,name:$n){pullRequest(number:$p){reviewThreads(first:100){nodes{isResolved comments(first:1){nodes{author{login}}}}}}}}";
+
+/** Unresolved review threads a human opened, or null when gh cannot answer. */
+function ghThreads(row) {
+  const [owner, name] = row.repo.split("/");
+  try {
+    const out = execFileSync(process.env.BOARD_GH || "gh", ["api", "graphql", "-f", `query=${THREADS_QUERY}`, "-F", `o=${owner}`, "-F", `n=${name}`, "-F", `p=${row.pr}`],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 30_000 });
+    const nodes = JSON.parse(out)?.data?.repository?.pullRequest?.reviewThreads?.nodes ?? [];
+    return nodes.filter((node) => !node.isResolved && !BOTS.test(node.comments?.nodes?.[0]?.author?.login ?? "bot")).length;
+  } catch {
+    return null;
+  }
+}
+
+function pairs(texts, flag) {
+  return Object.fromEntries(texts.map((pair) => {
     const at = pair.indexOf("=");
     if (at <= 0) {
-      throw new Error(`--pushed needs <name>=<sha>, got ${pair}`);
+      throw new Error(`${flag} needs <name>=<value>, got ${pair}`);
     }
     return [pair.slice(0, at), pair.slice(at + 1)];
   }));
+}
+
+function threadCounts(board, texts) {
+  const threads = Object.fromEntries(Object.entries(pairs(texts, "--threads")).map(([name, n]) => [name, Number(n)]));
+  for (const [name, row] of Object.entries(board.writers)) {
+    if (threads[name] === undefined && row.runtime === "codex" && row.pr && row.repo) {
+      const count = ghThreads(row);
+      if (count !== null) threads[name] = count;
+    }
+  }
+  return threads;
+}
+
+function readHelpers(orchDir) {
+  const file = path.join(orchDir, "helpers.json");
+  return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+}
+
+function pushedHeads(board, texts) {
+  const pushed = pairs(texts, "--pushed");
   for (const [name, row] of Object.entries(board.writers)) {
     if (!pushed[name] && row.pr && row.repo) {
       const head = ghHead(row);
@@ -123,31 +195,51 @@ function main(argv) {
     options: {
       pr: { type: "string" }, repo: { type: "string" }, head: { type: "string" }, status: { type: "string" }, deps: { type: "string" },
       to: { type: "string" }, kind: { type: "string" }, reference: { type: "string" },
-      pushed: { type: "string", multiple: true }, now: { type: "string" },
+      pushed: { type: "string", multiple: true }, threads: { type: "string", multiple: true }, now: { type: "string" },
+      runtime: { type: "string" }, owner: { type: "string" },
     },
   });
-  if (!orchDir || !["writer", "deliver", "told", "status"].includes(action)) {
-    throw new Error("Usage: board.mjs <orchDir> writer|deliver|told|status ...");
+  if (!orchDir || !["writer", "deliver", "told", "duty", "status"].includes(action)) {
+    throw new Error("Usage: board.mjs <orchDir> writer|deliver|told|duty|status ...");
   }
   const board = read(orchDir);
-  const at = new Date(values.now ? Date.parse(values.now) : Date.now()).toISOString();
+  const now = values.now ? Date.parse(values.now) : Date.now();
+  const at = new Date(now).toISOString();
   if (action === "status") {
     const stale = staleRows(board, pushedHeads(board, values.pushed ?? []));
     for (const row of stale) process.stdout.write(`STALE ${row.name} board head ${row.head}, pushed ${row.pushed}\n`);
     const open = untold(board);
     for (const entry of open) process.stdout.write(`UNTOLD ${entry.item} ${entry.recipient}\n`);
-    process.stdout.write(`board: ${Object.keys(board.writers).length} writers, ${stale.length} stale, ${open.length} untold\n`);
-    return stale.length + open.length === 0 ? 0 : 1;
+    const slow = slowRows(board, threadCounts(board, values.threads ?? []), now);
+    for (const row of slow) {
+      process.stdout.write(`SLOW ${row.name} no push for ${row.minutes}m with ${row.threads} unresolved human threads; hand it to a Claude writer\n`);
+    }
+    const duties = unownedDuties(board, readHelpers(orchDir));
+    for (const entry of duties) process.stdout.write(`UNOWNED-DUTY ${entry.duty} owner ${entry.owner} ${entry.why}\n`);
+    process.stdout.write(`board: ${Object.keys(board.writers).length} writers, ${stale.length} stale, ${open.length} untold, ${slow.length} slow, ${duties.length} unowned duties\n`);
+    return stale.length + open.length + slow.length + duties.length === 0 ? 0 : 1;
   }
   const [name, recipient] = positionals;
   if (!name) {
     throw new Error(`${action} needs a name.`);
   }
+  if (action === "duty") {
+    if (!values.owner) {
+      throw new Error("duty needs --owner <writer or helper>; a standing duty is never left without one.");
+    }
+    board.duties[name] = { owner: values.owner, at };
+    write(orchDir, board, `duty ${name}: ${values.owner}`, at);
+    return 0;
+  }
   if (action === "writer") {
+    if (values.runtime !== undefined && !RUNTIMES.has(values.runtime)) {
+      throw new Error("--runtime must be codex or claude.");
+    }
     const row = board.writers[name] ?? {};
-    const update = Object.fromEntries(Object.entries({ pr: values.pr, repo: values.repo, head: values.head, status: values.status })
+    const update = Object.fromEntries(Object.entries({ pr: values.pr, repo: values.repo, head: values.head, status: values.status, runtime: values.runtime })
       .filter(([, value]) => value !== undefined));
-    board.writers[name] = { ...row, ...update, ...(values.deps === undefined ? {} : { deps: list(values.deps) }), updatedAt: at };
+    const moved = values.head !== undefined && values.head !== row.head;
+    board.writers[name] = { ...row, ...update, ...(values.deps === undefined ? {} : { deps: list(values.deps) }), ...(moved ? { headAt: at } : {}), updatedAt: at };
     write(orchDir, board, `${name}: ${Object.entries(update).map(([key, value]) => `${key} ${value}`).join(", ") || "touched"}`, at);
     return 0;
   }
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/board.test.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/board.test.mjs
index e8e05866..3940526e 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/board.test.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/board.test.mjs
@@ -63,3 +63,62 @@ test('a ruling and a ready checkpoint stay untold until each recipient is told d
   }
   assert.match(run([dir, 'status']).stdout, /board: 0 writers, 0 stale, 0 untold/);
 });
+
+test('a standing duty whose owner is stopped or unknown is UNOWNED-DUTY, and its owner cannot be stopped until it moves', (t) => {
+  const dir = tempDir(t);
+  const helpers = (args) => spawnSync(process.execPath, [path.join(HERE, 'helpers.mjs'), dir, ...args], { encoding: 'utf8' });
+  assert.equal(run([dir, 'duty', 'main-health']).status, 2, 'a duty always names an owner');
+  assert.equal(helpers(['start', 'main-ci-watch']).status, 0);
+  assert.equal(run([dir, 'duty', 'main-health', '--owner', 'main-ci-watch']).status, 0);
+  assert.equal(run([dir, 'duty', 'pr-shepherd', '--owner', 'w1']).status, 0);
+  assert.equal(run([dir, 'writer', 'w1', '--head', 'aaa']).status, 0);
+  assert.match(run([dir, 'status']).stdout, /board: 1 writers, 0 stale, 0 untold, 0 slow, 0 unowned duties/);
+  assert.match(readFileSync(path.join(dir, 'board.md'), 'utf8'), /^- main-health: main-ci-watch \(since /m);
+
+  const refused = helpers(['stopped', 'main-ci-watch']);
+  assert.equal(refused.status, 1);
+  assert.match(refused.stdout, /^OWNS main-health; give it a new owner first/m);
+  assert.equal(JSON.parse(readFileSync(path.join(dir, 'helpers.json'), 'utf8'))['main-ci-watch'].stoppedAt, undefined);
+
+  assert.equal(run([dir, 'duty', 'main-health', '--owner', 'gone-helper']).status, 0);
+  const unowned = run([dir, 'status']);
+  assert.equal(unowned.status, 1);
+  assert.match(unowned.stdout, /^UNOWNED-DUTY main-health owner gone-helper is not a writer or a running helper$/m);
+  assert.equal(helpers(['stopped', 'main-ci-watch']).status, 0, 'once the duty moved, the old owner stops');
+  assert.equal(run([dir, 'duty', 'main-health', '--owner', 'main-ci-watch']).status, 0);
+  assert.match(run([dir, 'status']).stdout, /^UNOWNED-DUTY main-health owner main-ci-watch stopped /m);
+});
+
+test('a Codex writer with no push for 30 minutes on a PR with unresolved human threads is SLOW', (t) => {
+  const dir = tempDir(t);
+  assert.equal(run([dir, 'writer', 'w1', '--runtime', 'codex', '--head', 'aaa', '--now', '2026-10-21T12:00:00Z']).status, 0);
+  assert.equal(run([dir, 'writer', 'w2', '--runtime', 'claude', '--head', 'bbb', '--now', '2026-10-21T12:00:00Z']).status, 0);
+  assert.equal(run([dir, 'writer', 'w1', '--status', 'review fixes', '--now', '2026-10-21T12:20:00Z']).status, 0, 'a status update is not a push');
+  const at = (time, threads = 'w1=9') => run([dir, 'status', '--threads', threads, '--threads', 'w2=4', '--now', time]);
+  assert.equal(at('2026-10-21T12:29:00Z').status, 0);
+  const slow = at('2026-10-21T12:35:00Z');
+  assert.equal(slow.status, 1);
+  assert.deepEqual(slow.stdout.split('\n').filter((line) => line.startsWith('SLOW')), [
+    'SLOW w1 no push for 35m with 9 unresolved human threads; hand it to a Claude writer',
+  ]);
+  assert.equal(at('2026-10-21T12:35:00Z', 'w1=0').status, 0, 'no unresolved human thread, nothing to hand over');
+  assert.equal(run([dir, 'writer', 'w1', '--head', 'ccc', '--now', '2026-10-21T12:40:00Z']).status, 0);
+  assert.equal(at('2026-10-21T12:41:00Z').status, 0, 'a push restarts the clock');
+  assert.equal(run([dir, 'writer', 'w3', '--runtime', 'gemini']).status, 2);
+});
+
+test('unresolved human threads are read with gh for a Codex row with a PR and repo; bot threads do not count', (t) => {
+  const dir = tempDir(t);
+  const gh = path.join(dir, 'gh');
+  const nodes = [
+    { isResolved: false, comments: { nodes: [{ author: { login: 'reviewer' } }] } },
+    { isResolved: false, comments: { nodes: [{ author: { login: 'review-bot' } }] } },
+    { isResolved: true, comments: { nodes: [{ author: { login: 'reviewer' } }] } },
+    { isResolved: false, comments: { nodes: [{ author: { login: 'lead' } }] } },
+  ];
+  writeFileSync(gh, `#!/bin/sh\ncase "$*" in\n  "api graphql"*) echo '${JSON.stringify({ data: { repository: { pullRequest: { reviewThreads: { nodes } } } } })}' ;;\n  *) echo aaa ;;\nesac\n`);
+  chmodSync(gh, 0o755);
+  assert.equal(run([dir, 'writer', 'w1', '--runtime', 'codex', '--pr', '7', '--repo', 'acme/app', '--head', 'aaa', '--now', '2026-10-21T12:00:00Z']).status, 0);
+  const slow = run([dir, 'status', '--now', '2026-10-21T13:00:00Z'], { BOARD_GH: gh });
+  assert.match(slow.stdout, /^SLOW w1 no push for 60m with 2 unresolved human threads; hand it to a Claude writer$/m);
+});
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.mjs
index 21089b4b..ed69745e 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.mjs
@@ -3,7 +3,7 @@
 //   node codex-session.mjs steer <stateDir> <name> --prompt-file <file>
 //   node codex-session.mjs last  <stateDir> <name> [--count <n>]
 // `turn` starts a thread bound to --cwd when <stateDir>/<name>.json does not exist (a new session also needs
-// --effort and a prompt that starts with `$vibe`, since every writer is a vibe session), otherwise resumes the thread it names, then starts a turn with the prompt file's text. `steer` adds the prompt to the active turn.
+// --model, --effort and a prompt that starts with `$vibe`, since every writer is a vibe session), otherwise resumes the thread it names, then starts a turn with the prompt file's text. `steer` adds the prompt to the active turn.
 // `last` prints the thread's status line and its last <n> agent messages (default 1).
 // The state file is the one codex-fleet-monitor reads for a `local|remote <name>` session line.
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
@@ -104,6 +104,8 @@ export function nextState(saved, options) {
   }
   if (!saved && !options.cwd) throw new Error('a new session needs --cwd');
   if (!saved && !options.effort) throw new Error('a new session needs --effort');
+  // Sessions started without a model once came up on a slower one and had to be restarted.
+  if (!saved && !options.model) throw new Error('a new session needs --model (set CODEX_MODEL in config.env)');
   return {
     threadId: saved?.threadId,
     cwd: saved?.cwd ?? options.cwd,
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.test.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.test.mjs
index 9dec3cb9..8d9fe8f4 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.test.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/codex-session.test.mjs
@@ -71,8 +71,9 @@ test('state files round trip, are absent until saved, and must name a thread and
 test('nextState binds a session to its first cwd and keeps model and effort between turns', () => {
   assert.throws(() => nextState(null, { effort: 'high' }), /a new session needs --cwd/);
   assert.throws(() => nextState(null, { cwd: '/wt' }), /a new session needs --effort/);
-  assert.deepEqual(nextState(null, { cwd: '/wt', effort: 'high' }), {
-    threadId: undefined, cwd: '/wt', model: undefined, effort: 'high', sandbox: undefined, turns: [],
+  assert.throws(() => nextState(null, { cwd: '/wt', effort: 'high' }), /a new session needs --model/);
+  assert.deepEqual(nextState(null, { cwd: '/wt', model: 'm1', effort: 'high' }), {
+    threadId: undefined, cwd: '/wt', model: 'm1', effort: 'high', sandbox: undefined, turns: [],
   });
   const saved = { threadId: 'T1', cwd: '/wt', model: 'm1', effort: 'medium', sandbox: 'workspace-write', turns: [{ turnId: 'u1' }] };
   assert.deepEqual(nextState(saved, { cwd: '/wt' }), saved);
@@ -117,7 +118,7 @@ test('turn on a saved session resumes its thread with the saved options', async
 test('a failed turn/start leaves the state file unchanged', async () => {
   const { dir, promptFile } = workDir();
   const client = stubClient({ 'thread/start': { thread: { id: 'T1' } }, 'turn/start': {} });
-  await assert.rejects(run(client, parseCli(['turn', dir, 'w1', '--prompt-file', promptFile, '--cwd', '/wt', '--effort', 'high'])), /no turn id/);
+  await assert.rejects(run(client, parseCli(['turn', dir, 'w1', '--prompt-file', promptFile, '--cwd', '/wt', '--model', 'm', '--effort', 'high'])), /no turn id/);
   assert.equal(loadState(dir, 'w1'), null);
 });
 
@@ -168,7 +169,7 @@ test('a new session refuses a prompt that does not start with $vibe; a saved one
   const plain = join(dir, 'plain.md');
   writeFileSync(plain, 'Fix the failing check.\n');
   const client = stubClient({ 'thread/resume': {}, 'turn/start': { turn: { id: 'U1' } } });
-  await assert.rejects(run(client, parseCli(['turn', dir, 'w1', '--prompt-file', plain, '--cwd', '/wt', '--effort', 'high'])), /must start with \$vibe/);
+  await assert.rejects(run(client, parseCli(['turn', dir, 'w1', '--prompt-file', plain, '--cwd', '/wt', '--model', 'm', '--effort', 'high'])), /must start with \$vibe/);
   assert.deepEqual(client.calls, []);
   saveState(dir, 'w1', { threadId: 'T1', cwd: '/wt', effort: 'high', turns: [] });
   assert.equal(await run(client, parseCli(['turn', dir, 'w1', '--prompt-file', plain])), 'w1 turn T1 U1');
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/helpers.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/helpers.mjs
index 06257eec..8b4e8180 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/helpers.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/helpers.mjs
@@ -27,6 +27,10 @@
 // lstart=,command=`), refusing one it cannot read, and every signal re-reads
 // them first: a pid whose identity differs, cannot be read, or was never
 // recorded is treated as not ours and never signalled, alone or as a group.
+// `stopped` also refuses, before ending anything, a helper that owns a standing
+// duty on the fleet board (board.mjs `duty`): it prints `OWNS <duty>` and exits
+// 1 until the duty has another owner. Main's post-merge health once went
+// unwatched for an hour after its watcher was stopped with no replacement.
 // `hand` marks a running app stack (a worktree path, port or URL) as handed to
 // a human QA guide; `start --stack` on a handed stack exits 1, so a rerun that
 // toggles flags or moves data launches its own stack.
@@ -161,6 +165,13 @@ function write(orchDir, ledger) {
   renameSync(`${file}.tmp`, file);
 }
 
+/** Standing duties on the fleet board (board.json) that `name` owns. */
+export function ownedDuties(orchDir, name) {
+  const file = path.join(orchDir, "board.json");
+  const duties = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).duties ?? {} : {};
+  return Object.entries(duties).filter(([, duty]) => duty?.owner === name).map(([duty]) => duty);
+}
+
 function requireName(action, name) {
   if (!name) {
     throw new Error(`${action} needs a name.`);
@@ -245,6 +256,13 @@ async function main(argv) {
   } else if (action === "accepted") {
     ledger[name] = { ...(ledger[name] ?? {}), acceptedAt: at };
   } else {
+    const owned = ownedDuties(orchDir, name);
+    if (owned.length > 0) {
+      for (const duty of owned) {
+        process.stdout.write(`OWNS ${duty}; give it a new owner first: board.mjs <orchDir> duty ${duty} --owner <replacement>\n`);
+      }
+      return 1;
+    }
     const grace = values["grace-seconds"] === undefined ? DEFAULT_GRACE_SECONDS : Number(values["grace-seconds"]);
     const entry = ledger[name] ?? {};
     const groups = new Set(entry.groups ?? []);
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.mjs
new file mode 100644
index 00000000..77ae64d2
--- /dev/null
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.mjs
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Is a lessons PR already open? Lessons ship as one combined PR per plugin
+// repo, added to until it merges; four stacked lessons PRs once conflicted
+// with main and had to be restacked. Run it before opening a lessons PR.
+//
+// Usage: lessons-pr.mjs --repo <owner/repo> [--match <regex, default "lesson">]
+//
+// Lists your open PRs in the repo whose title or branch matches. Prints
+// `OPEN <url> <branch>: push this batch onto that branch` for each and exits 1;
+// prints `no open lessons PR` and exits 0 when none matches, and exits 2 when
+// gh cannot answer. `LESSONS_GH` overrides the gh binary.
+
+import { execFileSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+/** Open PRs whose title or branch matches `pattern`. */
+export function openLessonsPrs(prs, pattern) {
+  return prs.filter((pr) => pattern.test(pr?.title ?? "") || pattern.test(pr?.headRefName ?? ""));
+}
+
+function listOpen(repo) {
+  const out = execFileSync(process.env.LESSONS_GH || "gh", ["pr", "list", "-R", repo, "--state", "open", "--author", "@me", "--json", "number,title,headRefName,url"],
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 30_000 });
+  return JSON.parse(out);
+}
+
+function main(argv) {
+  const { values } = parseArgs({ args: argv, options: { repo: { type: "string" }, match: { type: "string" } } });
+  if (!values.repo) {
+    throw new Error("Usage: lessons-pr.mjs --repo <owner/repo> [--match <regex>]");
+  }
+  const open = openLessonsPrs(listOpen(values.repo), new RegExp(values.match ?? "lesson", "i"));
+  for (const pr of open) process.stdout.write(`OPEN ${pr.url} ${pr.headRefName}: push this batch onto that branch\n`);
+  if (open.length === 0) process.stdout.write("no open lessons PR\n");
+  return open.length === 0 ? 0 : 1;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    process.exit(main(process.argv.slice(2)));
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(2);
+  }
+}
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.test.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.test.mjs
new file mode 100644
index 00000000..68608d8e
--- /dev/null
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/lessons-pr.test.mjs
@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT = fileURLToPath(new URL('./lessons-pr.mjs', import.meta.url));
+
+function fakeGh(t, body) {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'fleet-lessons-pr-'));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const gh = path.join(dir, 'gh');
+  writeFileSync(gh, `#!/bin/sh\n${body}\n`);
+  chmodSync(gh, 0o755);
+  return (args) => spawnSync(process.execPath, [SCRIPT, ...args], { encoding: 'utf8', env: { ...process.env, LESSONS_GH: gh } });
+}
+
+test('an open lessons PR is reported so the next batch goes onto its branch, not a stacked PR', (t) => {
+  const prs = [
+    { number: 31, title: 'fix(vibe): encode the open fleet lessons', headRefName: 'fix/vibe-lessons-a', url: 'https://example.test/pull/31' },
+    { number: 32, title: 'feat: unrelated', headRefName: 'feat/other', url: 'https://example.test/pull/32' },
+  ];
+  const run = fakeGh(t, `echo '${JSON.stringify(prs)}'`);
+  const found = run(['--repo', 'acme/plugins']);
+  assert.equal(found.status, 1);
+  assert.equal(found.stdout, 'OPEN https://example.test/pull/31 fix/vibe-lessons-a: push this batch onto that branch\n');
+  assert.equal(run(['--repo', 'acme/plugins', '--match', 'release']).stdout, 'no open lessons PR\n');
+});
+
+test('no open lessons PR passes; gh failing is an error, never a pass', (t) => {
+  assert.equal(fakeGh(t, "echo '[]'")(['--repo', 'acme/plugins']).status, 0);
+  const broken = fakeGh(t, 'exit 1')(['--repo', 'acme/plugins']);
+  assert.equal(broken.status, 2);
+  assert.equal(fakeGh(t, "echo '[]'")([]).status, 2);
+});
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.mjs
index 0d4ee41e..883253bc 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.mjs
@@ -1,12 +1,17 @@
 #!/usr/bin/env node
 // Validates the single operator review page. Duplicate F1-style IDs across
 // audits made findings ambiguous, so IDs are globally unique and encode kind.
+// A decision row (D###) also names where the code was checked first
+// (`checked in code: <file>:<line>`): questions the schema already answered
+// (an owner that comes from the code host cannot be reassigned) once reached
+// the operator.
 // Usage: review-page-check.mjs <review.md>
 
 import { readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 
-const ROW = /^\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/gm;
+const ROW = /^\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|(.*)$/gm;
+const CODE_EVIDENCE = /checked in code:\s*[^\s|:]+:\d+/i;
 const ID = /^[DXNSR]\d{3,}$/;
 const STATUS = { D: "decision needed", X: "fixing", N: "stands", S: "superseded", R: "ruling" };
 
@@ -21,6 +26,9 @@ export function reviewPageProblems(text) {
     if (!ID.test(id)) problems.push(`${id}: ID must be D###, X###, N###, S### or R###`);
     else if (seen.has(id)) problems.push(`${id}: duplicate ID; review IDs are never reused`);
     else if (status !== STATUS[id[0]]) problems.push(`${id}: status must be ${STATUS[id[0]]}`);
+    else if (id[0] === "D" && !CODE_EVIDENCE.test(match[3])) {
+      problems.push(`${id}: a decision names where the code was checked first (checked in code: <file>:<line>); drop it if the code already answers it`);
+    }
     seen.add(id);
   }
   if (seen.size === 0) problems.push("no operator review rows");
diff --git a/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.test.mjs b/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.test.mjs
index c4e68e31..801f7f48 100644
--- a/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.test.mjs
+++ b/plugins/vibe/skills/fleet-orchestrator/scripts/review-page-check.test.mjs
@@ -3,7 +3,7 @@ import test from "node:test";
 import { reviewPageProblems } from "./review-page-check.mjs";
 
 test("operator review IDs encode kind, have at least three digits and never repeat", () => {
-  const valid = `| ID | status | PR | finding | resolution |\n|---|---|---|---|---|\n| D001 | decision needed | #1 | choose | A |\n| X002 | fixing | #2 | bug | patch |\n`;
+  const valid = `| ID | status | PR | finding | resolution |\n|---|---|---|---|---|\n| D001 | decision needed | #1 | choose; checked in code: src/owner.ts:42 | A |\n| X002 | fixing | #2 | bug | patch |\n`;
   assert.deepEqual(reviewPageProblems(valid), []);
   assert.deepEqual(reviewPageProblems(`${valid}| F1 | open | #3 | ambiguous | none |\n| D001 | decision needed | #4 | reused | none |\n`), [
     "F1: ID must be D###, X###, N###, S### or R###",
@@ -11,3 +11,13 @@ test("operator review IDs encode kind, have at least three digits and never repe
   ]);
   assert.deepEqual(reviewPageProblems('| R003 | open | #1 | ruling | none |\n'), ['R003: status must be ruling']);
 });
+
+test('a decision row names where the code was checked, so a question the code answers never reaches the operator', () => {
+  const head = '| ID | status | PR | finding | resolution |\n|---|---|---|---|---|\n';
+  assert.deepEqual(reviewPageProblems(`${head}| D004 | decision needed | #5 | can branches get a bulk owner? | ask |\n`), [
+    'D004: a decision names where the code was checked first (checked in code: <file>:<line>); drop it if the code already answers it',
+  ]);
+  assert.deepEqual(reviewPageProblems(`${head}| D004 | decision needed | #5 | bulk owner? checked in code: schema.prisma | ask |\n`).length, 1, 'a file without a line is not evidence');
+  assert.deepEqual(reviewPageProblems(`${head}| D004 | decision needed | #5 | bulk owner? Checked in code: prisma/schema.prisma:120 | ask |\n`), []);
+  assert.deepEqual(reviewPageProblems(`${head}| X005 | fixing | #5 | bug | patch |\n`), [], 'only decisions need it');
+});
diff --git a/plugins/vibe/skills/handoff/scripts/executed-check.mjs b/plugins/vibe/skills/handoff/scripts/executed-check.mjs
index f845fbb5..0b20ff36 100644
--- a/plugins/vibe/skills/handoff/scripts/executed-check.mjs
+++ b/plugins/vibe/skills/handoff/scripts/executed-check.mjs
@@ -4,10 +4,14 @@
 // feature flag its shipped changes rely on, where to see each in production,
 // and each flag's current production state, checked after the last merge, so
 // someone else can visual-QA the work in production.
+// A PRD is also executed only when every child it PRODUCES is DONE or
+// CANCELED: a PRD was once marked EXECUTED with four children still open.
 // Prints one JSON object; exits 0 when the document may be marked EXECUTED and
 // 1 otherwise. Changes nothing.
 //
-// Usage: executed-check.mjs --file <document body .md> --last-merge <iso time of the last merged pull request>
+// Usage: executed-check.mjs --kind plan --file <document body .md> --last-merge <iso time of the last merged pull request>
+//        executed-check.mjs --kind prd --file <...> --last-merge <...> --children <children.json>
+// children.json: the PRODUCES children read just now, `[{"slug", "status"}]`.
 
 import { readFileSync } from "node:fs";
 import path from "node:path";
@@ -19,6 +23,18 @@ const HEADING = /^##\s+(.+?)\s*$/;
 const CHECKED = /^\s*(?:[-*]\s+)?Checked:\s*(\S+)/m;
 const FLAG_ROW = /^\s*(?:[-*]\s+`[^`]+`|\|\s*`[^`]+`\s*\|)/m;
 const NO_FLAGS = /^\s*(?:[-*]\s+)?No flags:\s*\S/m;
+const KINDS = new Set(["plan", "prd"]);
+const FINISHED = new Set(["DONE", "CANCELED"]);
+
+/** Problems with a PRD's children: each one not DONE or CANCELED. */
+export function childProblems(children) {
+  if (!Array.isArray(children)) {
+    return ["--children must be a JSON array of {slug, status}"];
+  }
+  return children
+    .filter((child) => !FINISHED.has(child?.status))
+    .map((child) => `child ${child?.slug ?? "?"} is ${child?.status ?? "missing a status"}; a PRD is executed only when every PRODUCES child is DONE or CANCELED`);
+}
 
 /** Problems that keep `body` from being marked EXECUTED after a merge at `lastMerge`. */
 export function executedProblems(body, lastMerge) {
@@ -46,12 +62,19 @@ export function executedProblems(body, lastMerge) {
 }
 
 function main() {
-  const { values } = parseArgs({ options: { file: { type: "string" }, "last-merge": { type: "string" } } });
-  if (!values.file || !values["last-merge"]) {
-    process.stdout.write(`${JSON.stringify({ ok: false, error: "--file and --last-merge are required." })}\n`);
+  const { values } = parseArgs({ options: { kind: { type: "string" }, file: { type: "string" }, "last-merge": { type: "string" }, children: { type: "string" } } });
+  const error = !KINDS.has(values.kind) ? "--kind plan or --kind prd is required."
+    : !values.file || !values["last-merge"] ? "--file and --last-merge are required."
+    : values.kind === "prd" && !values.children ? "--kind prd needs --children <file> with its PRODUCES children read just now."
+    : null;
+  if (error) {
+    process.stdout.write(`${JSON.stringify({ ok: false, error })}\n`);
     process.exit(1);
   }
-  const problems = executedProblems(readFileSync(path.resolve(values.file), "utf8"), values["last-merge"]);
+  const problems = [
+    ...executedProblems(readFileSync(path.resolve(values.file), "utf8"), values["last-merge"]),
+    ...(values.kind === "prd" ? childProblems(JSON.parse(readFileSync(path.resolve(values.children), "utf8"))) : []),
+  ];
   process.stdout.write(`${JSON.stringify({ ok: problems.length === 0, problems }, null, 2)}\n`);
   process.exit(problems.length === 0 ? 0 : 1);
 }
diff --git a/plugins/vibe/skills/handoff/scripts/executed-check.test.mjs b/plugins/vibe/skills/handoff/scripts/executed-check.test.mjs
index 965dc7d3..8c9106c7 100644
--- a/plugins/vibe/skills/handoff/scripts/executed-check.test.mjs
+++ b/plugins/vibe/skills/handoff/scripts/executed-check.test.mjs
@@ -3,7 +3,7 @@ import { writeFileSync } from "node:fs";
 import path from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
-import { executedProblems } from "./executed-check.mjs";
+import { childProblems, executedProblems } from "./executed-check.mjs";
 import { makeHome, runNode } from "../../vibe/scripts/test-fixtures.mjs";
 
 const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), "executed-check.mjs");
@@ -36,8 +36,31 @@ test("the CLI exits 1 on a document missing the section", (t) => {
   const bad = path.join(home.root, "bad.md");
   writeFileSync(good, SECTION);
   writeFileSync(bad, "# PRD\n\n## Problem\n");
-  assert.equal(runNode(SCRIPT, ["--file", good, "--last-merge", MERGED], home.home).status, 0);
-  const refused = runNode(SCRIPT, ["--file", bad, "--last-merge", MERGED], home.home);
+  assert.equal(runNode(SCRIPT, ["--kind", "plan", "--file", good, "--last-merge", MERGED], home.home).status, 0);
+  const refused = runNode(SCRIPT, ["--kind", "plan", "--file", bad, "--last-merge", MERGED], home.home);
   assert.equal(refused.status, 1);
   assert.equal(refused.json.ok, false);
 });
+
+test("a PRD is executed only when every PRODUCES child is DONE or CANCELED", (t) => {
+  assert.deepEqual(childProblems([{ slug: "A-1", status: "DONE" }, { slug: "A-2", status: "CANCELED" }]), []);
+  assert.deepEqual(childProblems([{ slug: "A-1", status: "DONE" }, { slug: "A-3", status: "IN_REVIEW" }, { slug: "A-4", status: "BACKLOG" }]), [
+    "child A-3 is IN_REVIEW; a PRD is executed only when every PRODUCES child is DONE or CANCELED",
+    "child A-4 is BACKLOG; a PRD is executed only when every PRODUCES child is DONE or CANCELED",
+  ]);
+  const home = makeHome("vibe-executed-check-");
+  t.after(home.cleanup);
+  const prd = path.join(home.root, "prd.md");
+  const open = path.join(home.root, "open.json");
+  const done = path.join(home.root, "done.json");
+  writeFileSync(prd, SECTION);
+  writeFileSync(open, JSON.stringify([{ slug: "A-1", status: "DONE" }, { slug: "A-3", status: "IN_PROGRESS" }]));
+  writeFileSync(done, JSON.stringify([{ slug: "A-1", status: "DONE" }]));
+  const args = ["--kind", "prd", "--file", prd, "--last-merge", MERGED];
+  assert.match(runNode(SCRIPT, args, home.home).json.error, /--kind prd needs --children/);
+  assert.match(runNode(SCRIPT, ["--file", prd, "--last-merge", MERGED], home.home).json.error, /--kind plan or --kind prd is required/);
+  const refused = runNode(SCRIPT, [...args, "--children", open], home.home);
+  assert.equal(refused.status, 1);
+  assert.deepEqual(refused.json.problems, ["child A-3 is IN_PROGRESS; a PRD is executed only when every PRODUCES child is DONE or CANCELED"]);
+  assert.equal(runNode(SCRIPT, [...args, "--children", done], home.home).status, 0);
+});
diff --git a/plugins/vibe/skills/vibe/SKILL.md b/plugins/vibe/skills/vibe/SKILL.md
index 6b52ccb7..dd13000e 100644
--- a/plugins/vibe/skills/vibe/SKILL.md
+++ b/plugins/vibe/skills/vibe/SKILL.md
@@ -842,7 +842,9 @@ except the startup version question, which runs once per conversation
 1. Before asking, run `node scripts/session-questions.mjs ask --key <topic>
    --question "<exact words>" [--worktree "<wt>"]`. For a product question,
    also pass `--product --code-evidence "<file:line>"`; the command refuses it
-   without the required code/data-model check. Use a short stable key
+   without the required code/data-model check. It also refuses a request for
+   permission to do in-scope work (a test repair, a main merge, a push, a fix):
+   tell the writer to go ahead and report it. Use a short stable key
    for the topic (`sample-data`, `page-wording`, `button-label`). Before the
    session exists leave `--worktree` out; `vibe-sessions.mjs new` moves those
    questions onto the session. In "Starting new", run
diff --git a/plugins/vibe/skills/vibe/scripts/session-questions.mjs b/plugins/vibe/skills/vibe/scripts/session-questions.mjs
index 19ff54c1..50ed425d 100644
--- a/plugins/vibe/skills/vibe/scripts/session-questions.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-questions.mjs
@@ -18,6 +18,12 @@
 // `ask` answers whether to ask: {"ask":true} only for a key never asked. A key
 // already asked returns {"ask":false} with its pending question or its answer,
 // so the caller uses the answer or keeps waiting, and never repeats it.
+// `ask` also refuses a request for permission to do in-scope engineering work
+// (repair a test the change broke, merge main, push, rerun a check, fix a
+// finding): that work never waits, so the writer does it and reports it. A
+// writer once sat idle for an hour "pending authorization" to repair tests.
+// Only a flag key, a product question, a destructive action or a credential
+// waits for the person.
 // Every command prints one JSON object; errors print {"ok":false,"error":...}.
 
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -29,6 +35,14 @@ import { readSessionRecord, writeSessionRecord } from "./session-record.mjs";
 
 const KEY_PATTERN = /^[a-z0-9]+(?:[-:][a-z0-9]+)*$/;
 const MAX_TEXT = 4000;
+const ASKS_LEAVE = /\b(?:may|can|shall|should) i\b|\b(?:ok|okay|fine) (?:for me )?to\b|\bpermission\b|\bauthori[sz](?:e|ation)\b|\bapprov(?:e|al)\b|\bgo-?ahead\b/i;
+const IN_SCOPE_WORK = /\b(?:tests?|fixtures?|specs?|snapshots?|merge (?:main|the base)|main merge|rebase|push|commit|rerun|re-run|lint|typecheck|fix(?:es)?|repair)\b/i;
+const HUMAN_ONLY = /\b(?:flags?|feature flag|credentials?|password|token|sign(?:ed)?[ -]?in|log ?in|delete|discard|destroy|drop|force|wording|copy|product)\b/i;
+
+/** In-scope engineering work asked as permission; it never waits for the person. */
+export function asksLeaveForInScopeWork(question) {
+  return ASKS_LEAVE.test(question) && IN_SCOPE_WORK.test(question) && !HUMAN_ONLY.test(question);
+}
 
 /** Where questions asked before the session exists are kept. */
 export function startupFile(home = os.homedir()) {
@@ -39,6 +53,9 @@ export function startupFile(home = os.homedir()) {
 export function askQuestion(questions, { key, question, product = false, codeEvidence, now = new Date().toISOString() }) {
   requireKey(key);
   requireText("--question", question);
+  if (asksLeaveForInScopeWork(question)) {
+    throw new Error("in-scope work never waits for authorization: repairing tests the change broke, a main merge, a push, a rerun or an in-scope fix goes ahead now and is reported afterwards; only a flag key, a product question, a destructive action or a credential waits");
+  }
   if (product && !/^\S.*:\d+(?:-\d+)?$/.test(codeEvidence ?? "")) {
     throw new Error("a product question needs --code-evidence <file:line> proving the code and data model were checked first");
   }
diff --git a/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs b/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
index 3f62254c..3534f603 100644
--- a/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
-import { askQuestion } from "./session-questions.mjs";
+import { askQuestion, asksLeaveForInScopeWork } from "./session-questions.mjs";
 import { makeCheckout, makeHome, mainSyncRecipeFiles, runNode } from "./test-fixtures.mjs";
 
 const DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -95,3 +95,25 @@ test("answering an unrecorded question is refused", (t) => {
   assert.equal(result.status, 1);
   assert.match(result.json.error, /record it with ask first/);
 });
+
+test("permission to do in-scope engineering work is refused; flags, product calls, destruction and credentials still wait", () => {
+  const goAhead = [
+    "May I update the two other test files my change broke?",
+    "Pending authorization to repair five stale Desktop tests; OK to proceed?",
+    "Should I merge main now or hold the push for the other PR?",
+    "Do I have approval to rerun the failing check?",
+  ];
+  for (const question of goAhead) {
+    assert.equal(asksLeaveForInScopeWork(question), true, question);
+    assert.throws(() => askQuestion([], { key: "go-ahead", question }), /in-scope work never waits for authorization/);
+  }
+  const waits = [
+    "May I add the new feature flag key for this screen?",
+    "Should I delete the old branch and discard its stash?",
+    "Can owners change in bulk?",
+    "Which wording should the empty state use?",
+    "May I sign in to the preview with your account?",
+  ];
+  for (const question of waits) assert.equal(asksLeaveForInScopeWork(question), false, question);
+  assert.equal(askQuestion([], { key: "flag-key", question: waits[0] }).result.ask, true);
+});
diff --git a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
new file mode 100644
index 00000000..8004372b
--- /dev/null
+++ b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
@@ -0,0 +1,89 @@
+"""Contract coverage for the vibe 1.0.75 lessons release."""
+
+import re
+from pathlib import Path
+
+from vibe_contract_text import flat
+
+
+PLUGIN = Path(__file__).resolve().parents[2]
+PLUGINS = PLUGIN.parent
+VIBE = PLUGIN / "skills" / "vibe"
+FLEET = PLUGIN / "skills" / "fleet-orchestrator"
+MONITOR = PLUGIN / "skills" / "codex-fleet-monitor"
+
+TOP_LEVEL_MAIN = re.compile(r"^(?:if \(.*\)\s*)?await main\(")
+TOP_LEVEL_DECLARATION = re.compile(r"^(?:export\s+)?(?:const|let|class)\s+(\w+)")
+
+
+def _text(path: Path) -> str:
+    return flat(path.read_text())
+
+
+def declarations_after_top_level_await(text: str) -> list[str]:
+    """Top-level const, let or class declarations below a top-level `await main()`.
+
+    A top-level await pauses module evaluation, so main runs while those are
+    still uninitialized; liveness.mjs printed READFAIL for every failed turn.
+    """
+    lines = text.splitlines()
+    start = next((index for index, line in enumerate(lines) if TOP_LEVEL_MAIN.match(line)), None)
+    if start is None:
+        return []
+    return [match.group(1) for line in lines[start + 1:] if (match := TOP_LEVEL_DECLARATION.match(line))]
+
+
+def test_no_plugin_script_declares_a_constant_below_its_top_level_await_main() -> None:
+    offenders = {
+        str(path.relative_to(PLUGINS)): found
+        for path in sorted(PLUGINS.rglob("*.mjs"))
+        if "node_modules" not in path.parts and (found := declarations_after_top_level_await(path.read_text()))
+    }
+    assert offenders == {}
+
+
+def test_the_top_level_await_scan_catches_the_shape_that_hid_usage_limits() -> None:
+    assert declarations_after_top_level_await("if (isEntryPoint(import.meta.url)) await main();\n\nexport const Failure = {};\n") == ["Failure"]
+    assert declarations_after_top_level_await("const A = 1;\nawait main();\n") == []
+    assert declarations_after_top_level_await("async function main() {\n  await main();\n  const inner = 1;\n}\n") == []
+
+
+def test_the_watcher_flags_model_drift_wider_questions_and_a_second_copy() -> None:
+    snapshot = (MONITOR / "scripts" / "snapshot.sh").read_text()
+    assert snapshot.count("CODEX_MODEL=${CODEX_MODEL:-}") == 2, "local and remote liveness both get the configured model"
+    assert "watch.lock" in (MONITOR / "scripts" / "watch.sh").read_text()
+    monitor = _text(MONITOR / "SKILL.md")
+    for wired in ("MODEL(<model>/<effort>!=<want>)", "`notLoaded`", "permission, authorization or approval", "never with `&`", "resets"):
+        assert wired in monitor, wired
+
+
+def test_fleet_orchestrator_runs_each_new_check() -> None:
+    skill = _text(FLEET / "SKILL.md")
+    for wired in (
+        "checked in code: <file>:<line>",
+        "refuses to start without a model or an effort",
+        "`MODEL(...)`",
+        "resets=<n>",
+        "move its busiest writers to Claude writers",
+        "board.mjs <orchDir> duty <duty> --owner",
+        "`UNOWNED-DUTY`",
+        "--runtime codex|claude",
+        "A `SLOW` row",
+        "never with `&`",
+        "one umbrella ticket",
+        "Work outside the program goes to its owner",
+        "lessons-pr.mjs --repo <owner/repo>",
+        "executed-check.mjs --kind prd",
+        "--children",
+    ):
+        assert wired in skill, wired
+    assert "checked in code: <file>:<line>" in _text(FLEET / "references" / "templates.md")
+    for script in ("lessons-pr.mjs", "board.mjs", "helpers.mjs", "review-page-check.mjs"):
+        assert (FLEET / "scripts" / script).exists(), script
+
+
+def test_vibe_writers_never_wait_for_authorization_on_in_scope_work() -> None:
+    assert "Never stop for authorization on in-scope work" in _text(PLUGIN / "agents" / "vibe-change-worker.md")
+    assert "permission to do in-scope work" in _text(VIBE / "SKILL.md")
+    assert "asksLeaveForInScopeWork" in (VIBE / "scripts" / "session-questions.mjs").read_text()
+    assert "executed-check.mjs --kind plan" in _text(PLUGIN / "agents" / "vibe-ticket-worker.md")

From 7fba7cf49a44f91709914a39e9671b690062ecff Mon Sep 17 00:00:00 2001
From: Daniel Ochoa <daniel.ochoa@closedloop.ai>
Date: Wed, 21 Oct 2026 23:51:29 -0500
Subject: [PATCH 2/5] test(vibe): end a refused watcher's group if the lock
 regresses

- The second-copy test starts the refused copy detached and kills its
  group afterwards, so a regression that lets it run leaves no sleep.

Testing: watcher.test.mjs on a second machine, with and without the
lock in watch.sh.
Risks: None identified.
---
 .../scripts/watcher.test.mjs                  | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs b/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
index 91a72cf8..d41b18f9 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/watcher.test.mjs
@@ -95,10 +95,26 @@ test('a second watch.sh on the same work dir is refused while the first runs, an
   };
   t.after(killGroup);
   for (let i = 0; i < 100 && !existsSync(join(dir, 'watcher.json')); i += 1) await new Promise((resolve) => setTimeout(resolve, 100));
-  const second = spawnSync('zsh', [WATCH, dir, '600'], { encoding: 'utf8', timeout: 10_000 });
-  assert.equal(second.status, 3);
-  assert.match(second.stderr, new RegExp(`watcher pid ${child.pid} already runs`));
-  assert.match(second.stderr, /run_in_background\), never with &/);
+  // Detached too, so if it is not refused, killing its group also ends the sleep it would wait in.
+  const second = spawn('zsh', [WATCH, dir, '600'], { stdio: ['ignore', 'ignore', 'pipe'], detached: true });
+  t.after(() => {
+    if (second.pid > 1) {
+      try {
+        process.kill(-second.pid, 'SIGKILL');
+      } catch {
+        // Already gone.
+      }
+    }
+  });
+  let stderr = '';
+  second.stderr.on('data', (chunk) => { stderr += chunk; });
+  const status = await Promise.race([
+    new Promise((resolve) => second.on('exit', resolve)),
+    new Promise((resolve) => setTimeout(() => resolve('still running'), 5_000)),
+  ]);
+  assert.equal(status, 3);
+  assert.match(stderr, new RegExp(`watcher pid ${child.pid} already runs`));
+  assert.match(stderr, /run_in_background\), never with &/);
   assert.equal(JSON.parse(readFileSync(join(dir, 'watcher.json'), 'utf8')).pid, child.pid, 'the refused copy leaves the live watcher record alone');
   const exited = new Promise((resolve) => child.on('exit', resolve));
   killGroup();

From 0f63ae49df98e71f41988e45fb9b43ee710f1d07 Mon Sep 17 00:00:00 2001
From: Daniel Ochoa <daniel.ochoa@closedloop.ai>
Date: Thu, 22 Oct 2026 00:24:20 -0500
Subject: [PATCH 3/5] fix(vibe): a plan no human approved is never a scope
 ruling

- A writer skipped two tickets on an uncited Out-of-scope line of a
  plan vibe had set to APPROVED with no approver, against a direct
  instruction to build them.
- rulings-check.mjs --plan reads a PLN's get-document JSON; with no
  approverId, each out-of-scope, non-goal, excluded, deferred,
  descoped, not-covered or GAP item must cite a ticket AC, PRD or
  operator ruling.
- The ticket worker runs it before setting a PLN APPROVED, handoff on
  every linked PLN, fleet-orchestrator at dispatch and QA prep; the
  takeover and resume prompts make the incoming writer trace every
  inherited exclusion to a human source.

Testing: rulings-check tests on a fixture shaped like the plan, failing
when APPROVED is trusted, when a line-level citation covers every item,
and when only labeled lines are read.
Risks: vibe plans with uncited exclusions now return NEEDS_CHANGE at
the APPROVED transition until each one is cited or brought in scope.
---
 CHANGELOG.md                                  |  1 +
 plugins/vibe/agents/vibe-ticket-worker.md     |  7 ++
 .../vibe/skills/fleet-orchestrator/SKILL.md   |  1 +
 .../references/templates.md                   |  4 +-
 plugins/vibe/skills/handoff/SKILL.md          |  7 +-
 .../skills/handoff/scripts/rulings-check.mjs  | 83 +++++++++++++++++--
 .../handoff/scripts/rulings-check.test.mjs    | 67 ++++++++++++++-
 .../python/test_vibe_1075_lessons_contract.py |  9 ++
 8 files changed, 168 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7fe710bd..765b906f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,7 @@ The open fleet lessons from the 2026-10-21 and 2026-10-22 orchestration runs, ea
 - `executed-check.mjs` takes `--kind plan|prd`; a PRD also needs `--children` and is refused while any PRODUCES child is not DONE or CANCELED.
 - `review-page-check.mjs` refuses a decision row without `checked in code: <file>:<line>`, and vibe's `session-questions.mjs ask` refuses a request for permission to do in-scope work (a test repair, a main merge, a push, a fix); the change worker does that work and reports it.
 - `lessons-pr.mjs` names an open lessons PR to push onto before another is opened.
+- `rulings-check.mjs --plan` reads a PLN's `get-document` JSON: a plan with no human approver (vibe sets a PLN's status, never its approver) fails on each out-of-scope, non-goal, excluded, deferred, descoped, not-covered or GAP item that cites no ticket AC, PRD or operator ruling. The ticket worker runs it before setting a PLN `APPROVED`, handoff runs it on every linked PLN, and fleet-orchestrator runs it at dispatch and QA prep; takeover and resume prompts make the incoming writer trace every inherited exclusion to a human source or build or escalate it.
 - fleet-orchestrator prose: near a Codex usage limit, tell the operator with the available resets and, when they are away, move the busiest writers to Claude writers; group bug fixes into one umbrella ticket with PRs split by code area; work outside the program goes to its owner as a ticket.
 
 ### vibe v1.0.74
diff --git a/plugins/vibe/agents/vibe-ticket-worker.md b/plugins/vibe/agents/vibe-ticket-worker.md
index 5461e0af..f6e81a18 100644
--- a/plugins/vibe/agents/vibe-ticket-worker.md
+++ b/plugins/vibe/agents/vibe-ticket-worker.md
@@ -160,6 +160,13 @@ F. Status. The PLN's status follows the work:
    external dependency evidence. A ticket that still says the collector,
    selector, monitor or other dependency is missing keeps that task open and
    the PLN `DRAFT`; return `NEEDS_CHANGE` rather than approving it.
+   You never set a PLN's approver, so the `APPROVED` you set means built
+   and checked, never a human approval. Before setting it, save the PLN's
+   `get-document` JSON and its latest text and run
+   `node ../skills/handoff/scripts/rulings-check.mjs --plan <json> --plan-body <text>`;
+   each exclusion it names (out of scope, deferred, not covered, a GAP line)
+   goes back to the writer as `NEEDS_CHANGE`: cite the ticket AC, PRD or
+   operator ruling behind it, or bring the work back into scope.
 
 ## Create mode
 
diff --git a/plugins/vibe/skills/fleet-orchestrator/SKILL.md b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
index b1c3f91c..8d0712bf 100644
--- a/plugins/vibe/skills/fleet-orchestrator/SKILL.md
+++ b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
@@ -53,6 +53,7 @@ The closedloop-graph MCP server is required; decide from it, not from guesses. T
 
 - Before assigning work or ruling between PRs, check open-PR and ticket overlap with `query_collisions` and `blast_radius_tickets`; read a ticket's PRD lineage and children with `ticket_detail`.
 - Before dispatching a ticket, and in every QA-prep brief, run vibe's newest-ruling search ([requirements worker](../../agents/vibe-requirements-worker.md), Newest ruling). On a hit, stop and ask the operator.
+- In the same step, check every plan linked to the ticket (`list-artifact-links`, PRODUCES): save its `get-document` JSON and latest text and run `node ../handoff/scripts/rulings-check.mjs --plan <json> --plan-body <text>`. A plan with no human approver is not a ruling, so each exclusion it reports is scope the brief tells the writer to build or you escalate, never one to skip. A writer once skipped two tickets on an uncited Out-of-scope line of a plan vibe itself had marked approved.
 - Before a shared change, read its callers and importers (`code_callers`, `code_importers`).
 - Which tests to run, or rerun, after any change, fix or merge (a conflict resolution included) is decided by `code_tests_for`, the only route to tests, over the files that change touched: run exactly those and nothing broader by default. Files that map to no tests (changelog, README, version text) run none, and CI confirms.
 - Trace a surprising difference in a before and after comparison to the commit and ticket that introduced it before blaming the PR.
diff --git a/plugins/vibe/skills/fleet-orchestrator/references/templates.md b/plugins/vibe/skills/fleet-orchestrator/references/templates.md
index e3fe5bb8..83155137 100644
--- a/plugins/vibe/skills/fleet-orchestrator/references/templates.md
+++ b/plugins/vibe/skills/fleet-orchestrator/references/templates.md
@@ -21,12 +21,13 @@ Requirement: <ticket, PRD or acceptance criterion this proves>
 
 ## Worker preamble
 
-Prepend to every Claude writer prompt; keep the `Takeover` line only when replacing a dead Codex writer. A Codex writer's prompt starts with `$vibe <ticket or PRD>` instead of the first line.
+Prepend to every Claude writer prompt; keep the `Takeover` line only when replacing a dead Codex writer, and the `Inherited scope` line whenever the writer continues another writer's branch. A Codex writer's prompt starts with `$vibe <ticket or PRD>` instead of the first line.
 
 ```
 Invoke vibe:vibe first: resume the vibe session for <ticket or PRD>, or start one for it, and follow its rules for all of the work below.
 You are the only writer on <owner/repo>#<number>, worktree <path> on <machine>, branch <branch>.
 Takeover: a Codex vibe session wrote this branch and stopped (<usage-limit|runtime-unavailable>). Resume that same vibe session and, before any other step, move its writer to you with vibe's harness switch (`writer-state.mjs migrate` with `harnessSwitch`, vibe's quality loop, "A writer whose runtime cannot run"). Never start a second session on this branch. Continue from its last pushed head <sha>; commit normally.
+Inherited scope: trace every exclusion, deferral, "obsolete" or narrowed criterion you inherit from the previous writer (its plan, PLN, change log or report) to a human source: a ticket AC, a PRD line, an operator ruling, or a plan with a named human approver. Anything without one is built or escalated, never dropped; `rulings-check.mjs --plan` lists a linked PLN's uncited exclusions.
 Before editing, read the repo docs that own the paths you touch (AGENTS.md files or contributor guide) or the team knowledge base.
 Research graph-first with closedloop-graph before searching files by hand, as vibe requires: ticket_detail for the ticket and its PRD, query_collisions and blast_radius_tickets for overlapping work, code_callers and code_importers before a shared change.
 Tests: after any change, fix or merge (a conflict resolution included), run exactly the tests code_tests_for maps to the files it touched, nothing broader by default; files that map to no tests (changelog, README, version text) run none and CI confirms.
@@ -53,6 +54,7 @@ $vibe resume the vibe session for <ticket or PRD>.
 Worktree <path> on <machine>, branch <branch>, PR <owner/repo>#<number>, pushed head <full sha>. You are its only writer.
 Done: <what is finished and pushed>
 Left: <what remains, in order>
+Inherited scope: trace every exclusion, deferral, "obsolete" or narrowed criterion the previous writer left (its plan, PLN, change log or report) to a human source: a ticket AC, a PRD line, an operator ruling, or a plan with a named human approver. Anything without one is built or escalated, never dropped; `rulings-check.mjs --plan` lists a linked PLN's uncited exclusions.
 Rulings in force: read <orchDir>/rulings.md; the ticket carries the applicable per-ticket rulings through handoff's rulings check.
 Research graph-first with closedloop-graph before searching files by hand, as vibe requires: ticket_detail for the ticket and its PRD, query_collisions and blast_radius_tickets for overlapping work, code_callers and code_importers before a shared change.
 Tests: after any change, fix or merge (a conflict resolution included), run exactly the tests code_tests_for maps to the files it touched, nothing broader by default; files that map to no tests (changelog, README, version text) run none and CI confirms.
diff --git a/plugins/vibe/skills/handoff/SKILL.md b/plugins/vibe/skills/handoff/SKILL.md
index d7295ca2..290da60e 100644
--- a/plugins/vibe/skills/handoff/SKILL.md
+++ b/plugins/vibe/skills/handoff/SKILL.md
@@ -922,9 +922,10 @@ the MET/PARTIAL/MISSED audit, and
 `node scripts/criteria-audit.mjs --worktree "<wt>" --ticket <body> --audit <audit> --matrix <matrix>`
 must pass (every criterion MET, and every criterion x surface x input x flag
 cell evidenced, flag-off cells by a diff against the base or a ruling).
-`node scripts/rulings-check.mjs --ticket <body> --record <QA record>` must
-pass too: every ruling made during the work is on the ticket with the
-criteria it amends. From then on the pull request is shepherded:
+`node scripts/rulings-check.mjs --ticket <body> --record <QA record> --plan <each linked PLN's get-document JSON> --plan-body <its latest text>`
+must pass too: every ruling made during the work is on the ticket with the
+criteria it amends, and a plan no human approved excludes nothing without
+citing a ticket AC, PRD or operator ruling. From then on the pull request is shepherded:
 `node ../vibe/scripts/shepherd.mjs --pr <n> --repo <owner/repo>` polls it
 every two minutes and stops on a conflict (merge main at once in final-merge
 mode, push, run it again), failed checks (the SAME writer fixes them), a
diff --git a/plugins/vibe/skills/handoff/scripts/rulings-check.mjs b/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
index 81105646..0316643a 100644
--- a/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
+++ b/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
@@ -6,6 +6,7 @@
 //
 // Usage: rulings-check.mjs --ticket <ticket body .md> --record <QA record or resume log> [--record <file>]...
 //        rulings-check.mjs --program <rulings.md> --record <orchestrator transcript or QA record> [--record <file>]...
+//        rulings-check.mjs --plan <get-document JSON of a PLN> [--plan-body <its latest version text>] [--plan ...]
 //
 // A ruling in a record is a line `Ruling <anything>: <decision>` (the resume
 // log's `- Ruling (operator): ...`, or the same line in a QA record). The
@@ -13,6 +14,16 @@
 // `- Ruling <date> (<who>): "<decision>"; amends: <criteria, or none>`. Prints
 // {"ok","problems"} and exits 1 when a record's ruling is missing from the
 // ticket or a ticket ruling names no amended criteria.
+//
+// A plan with no human approver (`approverId` null; vibe sets a PLN's status
+// but never its approver) is not a ruling, so each exclusion in it must cite
+// a human source: a ticket AC (`<slug> AC-<n>`), a PRD, an operator ruling, or
+// a plan approved by a named human. An exclusion is an item on an
+// Out-of-scope, Non-goals, Excluded, Deferred, Descoped or Not covered line, a
+// GAP line, a bullet under such a heading, or a clause saying out of scope,
+// outside this scope, not covered, deferred or descoped. A writer once skipped
+// two tickets on an uncited Out-of-scope line of a plan vibe itself had set to
+// APPROVED, against a direct instruction to build them.
 
 import { readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -23,6 +34,58 @@ const TICKET_RULING = /^\s*[-*]\s*Ruling\b[^:\n]*:\s*(.+?)\s*$/gm;
 const AMENDS = /;\s*amends:\s*(\S.*)$/;
 const PROGRAM_RULING = /^\s*[-*]\s*Ruling\s+(\d{4}-\d{2}-\d{2})\s+\((operator message|AskUserQuestion|ticket):\s*(\S.*?)\):\s*(\S.*)$/gm;
 
+const EXCLUSION_LABEL = /^\s*(?:[-*]\s+)?(?:\[[ xX]\]\s*)?\**\s*(out[- ]of[- ]scope|non-?goals?|excluded|exclusions?|deferred|descoped|not covered|GAP(?:-\d+)?)\s*\**\s*:\s*\**\s*(.*)$/i;
+const EXCLUSION_HEADING = /^#{2,6}\s+(?:out[- ]of[- ]scope|non-?goals?|excluded|exclusions|deferred|descoped|not covered|gaps?)\b/i;
+const EXCLUSION_PHRASE = /\b(?:out[- ]of[- ]scope|outside (?:of )?(?:this|the) (?:\w+ )?scope|not covered|deferred|descoped)\b/i;
+const HUMAN_SOURCE = /\bPRD-\d+\b|\b[A-Z]{2,}-\d+\s+AC-?\d+\b|\bacceptance criteri(?:on|a)\b|\boperator\b|\brulings?\b|\bruled\b|\bapproved by\b/i;
+const NOTHING = /^(?:none|nothing|n\/a|-)\.?$/i;
+
+/** The exclusions in a plan body that cite no human source. */
+export function uncitedExclusions(body) {
+  const uncited = [];
+  let underHeading = false;
+  for (const line of body.split("\n")) {
+    if (/^#{1,6}\s/.test(line)) {
+      underHeading = EXCLUSION_HEADING.test(line);
+      continue;
+    }
+    const label = EXCLUSION_LABEL.exec(line);
+    let items = [];
+    if (label) {
+      items = /^GAP/i.test(label[1]) ? [label[2]] : splitItems(label[2]);
+    } else if (underHeading && /^\s*[-*]\s+/.test(line)) {
+      items = splitItems(line.replace(/^\s*[-*]\s+(?:\[[ xX]\]\s*)?/, ""));
+    } else if (EXCLUSION_PHRASE.test(line)) {
+      items = line.split(/[|;]/).filter((clause) => EXCLUSION_PHRASE.test(clause));
+    }
+    for (const item of items.map((text) => text.trim().replace(/^\*+|\*+$/g, "").trim()).filter(Boolean)) {
+      if (!NOTHING.test(item) && !HUMAN_SOURCE.test(item)) uncited.push(item);
+    }
+  }
+  return uncited;
+}
+
+/** Items of a list line; a trailing citation clause ("..., per operator ruling") stays with its item. */
+function splitItems(text) {
+  const items = [];
+  for (const part of text.split(/;\s*|,\s*(?:and\s+)?|\s+and\s+(?=[A-Z]{2,}-\d)/)) {
+    if (items.length > 0 && /^\s*(?:\(|per\b|source\b|see\b|as ruled\b|ruled\b|approved by\b)/i.test(part)) items[items.length - 1] += `, ${part}`;
+    else items.push(part);
+  }
+  return items;
+}
+
+/** Problems with a plan read through get-document: uncited exclusions in a plan no human approved. */
+export function planProblems(doc, body = doc?.version?.content) {
+  const name = doc?.slug ?? "plan";
+  if (doc?.approverId) return [];
+  if (typeof body !== "string" || (body === doc?.version?.content && doc?.version?.contentTruncated)) {
+    return [`${name}: pass its full latest version text with --plan-body`];
+  }
+  return uncitedExclusions(body).map((item) =>
+    `${name} is ${doc?.status ?? "unapproved"} with no human approver, so its exclusion "${item.slice(0, 160)}" is not a ruling; cite a ticket AC, PRD or operator ruling for it, or build it or escalate it`);
+}
+
 function normalize(text) {
   return text.replace(/["“”']/g, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
@@ -65,14 +128,22 @@ export function programRulingProblems(program, records) {
 function main(argv) {
   const { values } = parseArgs({ args: argv, options: {
     ticket: { type: "string" }, program: { type: "string" }, record: { type: "string", multiple: true },
+    plan: { type: "string", multiple: true }, "plan-body": { type: "string", multiple: true },
   } });
-  if ((!values.ticket && !values.program) || !values.record?.length || (values.ticket && values.program)) {
-    throw new Error("Usage: rulings-check.mjs (--ticket <ticket body .md> | --program <rulings.md>) --record <file> [--record <file>]...");
+  const plans = values.plan ?? [];
+  const bodies = values["plan-body"] ?? [];
+  const rulingMode = Boolean(values.ticket || values.program);
+  if ((rulingMode && (!values.record?.length || (values.ticket && values.program))) || (!rulingMode && plans.length === 0) || bodies.length > plans.length) {
+    throw new Error("Usage: rulings-check.mjs (--ticket <ticket body .md> | --program <rulings.md>) --record <file>... | --plan <get-document JSON> [--plan-body <text>]...");
   }
-  const records = values.record.map((file) => readFileSync(file, "utf8"));
-  const problems = values.program
-    ? programRulingProblems(readFileSync(values.program, "utf8"), records)
-    : rulingProblems(readFileSync(values.ticket, "utf8"), records);
+  const records = (values.record ?? []).map((file) => readFileSync(file, "utf8"));
+  const problems = [];
+  if (values.program) problems.push(...programRulingProblems(readFileSync(values.program, "utf8"), records));
+  else if (values.ticket) problems.push(...rulingProblems(readFileSync(values.ticket, "utf8"), records));
+  plans.forEach((file, index) => {
+    const doc = JSON.parse(readFileSync(file, "utf8"));
+    problems.push(...planProblems(doc, bodies[index] === undefined ? undefined : readFileSync(bodies[index], "utf8")));
+  });
   process.stdout.write(`${JSON.stringify({ ok: problems.length === 0, problems }, null, 2)}\n`);
   return problems.length === 0 ? 0 : 1;
 }
diff --git a/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs b/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
index 4b3e1d25..bd063a1e 100644
--- a/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
+++ b/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
@@ -1,6 +1,13 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
-import { programRulingProblems, recordRulings, rulingProblems } from "./rulings-check.mjs";
+import { fileURLToPath } from "node:url";
+import { planProblems, programRulingProblems, recordRulings, rulingProblems, uncitedExclusions } from "./rulings-check.mjs";
+
+const SCRIPT = fileURLToPath(new URL("./rulings-check.mjs", import.meta.url));
 
 const RESUME_LOG = `## 2026-10-21 14:05
 - Ruling (operator): offline editing is descoped; edits are online only
@@ -33,3 +40,61 @@ test("the program index requires dated sources and contains every reconciled rul
   assert.deepEqual(programRulingProblems(program, [RESUME_LOG]), []);
   assert.match(programRulingProblems(program, [QA_RECORD])[0], /not in the program rulings index/);
 });
+
+// Shaped like the plan vibe set to APPROVED with no approver, whose uncited
+// Out-of-scope line a writer used to skip two tickets it was told to build.
+const SELF_APPROVED_PLAN = [
+  "# Implementation Plan: PRD-7 Responsive Narrow List",
+  "",
+  "**Scope:**",
+  "- In-scope: ISS-1; ISS-2, ISS-3 and the shared responsive branch.",
+  "- Out-of-scope: ISS-4 prototype recomposition, ISS-5 responsive preference versioning, public documentation, and broad local suites assigned by the operator to automatic CI.",
+  "",
+  "## Acceptance Criteria",
+  "",
+  "| ID | Criterion | Source |",
+  "|----|-----------|--------|",
+  "| AC-001 | The ledger maps every approved behavior to a component, defect, or non-goal. | PRD-7 |",
+  "| AC-004 | The preserved prototype imports the mastered implementation. | PRD-7; ISS-4 is explicitly outside this build scope and remains untouched |",
+  "",
+  "## Implementation Notes",
+  "",
+  "- Child mapping at handoff: covered are ISS-2 and ISS-3. Not covered and unchanged are ISS-4 and ISS-5.",
+  "",
+  "## Gaps",
+  "",
+  "- [ ] **GAP-001**: ISS-4 prototype recomposition is explicitly outside this build scope.",
+  "- [ ] **GAP-002**: ISS-5 responsive preference versioning is deferred per operator ruling 2026-10-19.",
+].join("\n");
+const planDoc = (extra = {}) => ({ slug: "PLN-1", status: "APPROVED", approverId: null, version: { content: SELF_APPROVED_PLAN, contentTruncated: false }, ...extra });
+
+test("a plan no human approved cannot exclude work without citing a human source for each exclusion", () => {
+  assert.deepEqual(uncitedExclusions(SELF_APPROVED_PLAN), [
+    "ISS-4 prototype recomposition",
+    "ISS-5 responsive preference versioning",
+    "public documentation",
+    "ISS-4 is explicitly outside this build scope and remains untouched",
+    "- Child mapping at handoff: covered are ISS-2 and ISS-3. Not covered and unchanged are ISS-4 and ISS-5.",
+    "ISS-4 prototype recomposition is explicitly outside this build scope.",
+  ]);
+  const problems = planProblems(planDoc());
+  assert.equal(problems.length, 6);
+  assert.match(problems[0], /PLN-1 is APPROVED with no human approver, so its exclusion "ISS-4 prototype recomposition" is not a ruling/);
+  assert.deepEqual(planProblems(planDoc({ approverId: "user-1" })), [], "a plan a named human approved is a source");
+  assert.deepEqual(uncitedExclusions("- Out-of-scope: none\n- Non-goals: ISS-9 per ISS-8 AC-3; offline sync (PRD-4)\n"), []);
+  assert.deepEqual(uncitedExclusions("## Out of scope\n\n- the export menu\n- bulk delete, per operator ruling 2026-10-20\n"), ["the export menu"]);
+  assert.match(planProblems(planDoc({ version: { content: "truncated", contentTruncated: true } })).join(), /--plan-body/);
+});
+
+test("the command fails on a self-approved plan with an uncited exclusion and passes once each one is cited", (t) => {
+  const dir = mkdtempSync(path.join(os.tmpdir(), "rulings-plan-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const doc = path.join(dir, "plan.json");
+  writeFileSync(doc, JSON.stringify(planDoc()));
+  const refused = spawnSync(process.execPath, [SCRIPT, "--plan", doc], { encoding: "utf8" });
+  assert.equal(refused.status, 1);
+  assert.equal(JSON.parse(refused.stdout).problems.length, 6);
+  const body = path.join(dir, "body.md");
+  writeFileSync(body, "- Out-of-scope: ISS-4 per ISS-4 AC-2 (operator ruling 2026-10-21)\n");
+  assert.equal(spawnSync(process.execPath, [SCRIPT, "--plan", doc, "--plan-body", body], { encoding: "utf8" }).status, 0);
+});
diff --git a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
index 8004372b..deea4c65 100644
--- a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
+++ b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
@@ -87,3 +87,12 @@ def test_vibe_writers_never_wait_for_authorization_on_in_scope_work() -> None:
     assert "permission to do in-scope work" in _text(VIBE / "SKILL.md")
     assert "asksLeaveForInScopeWork" in (VIBE / "scripts" / "session-questions.mjs").read_text()
     assert "executed-check.mjs --kind plan" in _text(PLUGIN / "agents" / "vibe-ticket-worker.md")
+
+
+def test_a_plan_no_human_approved_is_never_a_scope_ruling() -> None:
+    assert "planProblems" in (PLUGIN / "skills" / "handoff" / "scripts" / "rulings-check.mjs").read_text()
+    assert "rulings-check.mjs --plan <json> --plan-body <text>" in _text(PLUGIN / "agents" / "vibe-ticket-worker.md")
+    assert "--plan <each linked PLN's get-document JSON>" in _text(PLUGIN / "skills" / "handoff" / "SKILL.md")
+    assert "rulings-check.mjs --plan <json> --plan-body <text>" in _text(FLEET / "SKILL.md")
+    templates = _text(FLEET / "references" / "templates.md")
+    assert templates.count("Inherited scope: trace every exclusion") == 2, "takeover preamble and resume prompt"

From ecddcb8e84eca0395c03e0a7943596da5cbfbb8b Mon Sep 17 00:00:00 2001
From: Daniel Ochoa <daniel.ochoa@closedloop.ai>
Date: Thu, 22 Oct 2026 01:00:50 -0500
Subject: [PATCH 4/5] fix(vibe): mark vibe-approved plans self-approved

- Every PLN session-plan.mjs renders starts with a Self-approved line,
  since vibe sets a PLN's status but never its approver; the ticket
  worker sets APPROVED only with a human approver or that line.
- rulings-check.mjs --plan fails an APPROVED or EXECUTED plan with no
  approver that lacks the line, and reads obsolete calls as exclusions.
  The fixture is shaped like the plan a writer used to skip two tickets.
- fleet-orchestrator principle 1 states the operator's ruling that a
  scope exclusion, deferral or obsolete call needs a human source.
- session-questions lets a question about dropping or narrowing scope
  through; the change worker waits for that answer.

Testing: rulings-check, session-plan and session-questions tests; each
check shown failing with its part removed.
Risks: the first publish after upgrading versions every open session's
PLN once, adding the Self-approved line.
---
 CHANGELOG.md                                  |  2 +-
 plugins/vibe/agents/vibe-change-worker.md     |  3 +-
 plugins/vibe/agents/vibe-ticket-worker.md     |  5 +-
 .../vibe/skills/fleet-orchestrator/SKILL.md   |  1 +
 .../skills/handoff/scripts/rulings-check.mjs  | 20 ++++---
 .../handoff/scripts/rulings-check.test.mjs    | 53 +++++++++++--------
 .../vibe/skills/vibe/scripts/session-plan.mjs |  9 +++-
 .../skills/vibe/scripts/session-plan.test.mjs |  8 +--
 .../skills/vibe/scripts/session-questions.mjs |  8 +--
 .../vibe/scripts/session-questions.test.mjs   |  1 +
 .../python/test_vibe_1075_lessons_contract.py |  3 ++
 11 files changed, 71 insertions(+), 42 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 765b906f..63869673 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,7 +20,7 @@ The open fleet lessons from the 2026-10-21 and 2026-10-22 orchestration runs, ea
 - `executed-check.mjs` takes `--kind plan|prd`; a PRD also needs `--children` and is refused while any PRODUCES child is not DONE or CANCELED.
 - `review-page-check.mjs` refuses a decision row without `checked in code: <file>:<line>`, and vibe's `session-questions.mjs ask` refuses a request for permission to do in-scope work (a test repair, a main merge, a push, a fix); the change worker does that work and reports it.
 - `lessons-pr.mjs` names an open lessons PR to push onto before another is opened.
-- `rulings-check.mjs --plan` reads a PLN's `get-document` JSON: a plan with no human approver (vibe sets a PLN's status, never its approver) fails on each out-of-scope, non-goal, excluded, deferred, descoped, not-covered or GAP item that cites no ticket AC, PRD or operator ruling. The ticket worker runs it before setting a PLN `APPROVED`, handoff runs it on every linked PLN, and fleet-orchestrator runs it at dispatch and QA prep; takeover and resume prompts make the incoming writer trace every inherited exclusion to a human source or build or escalate it.
+- Every PLN vibe publishes starts with a `Self-approved` line (`session-plan.mjs`), since vibe sets a PLN's status but never its approver; the ticket worker sets `APPROVED` only on a plan with a human approver or that line. `rulings-check.mjs --plan` reads a PLN's `get-document` JSON: an `APPROVED` or `EXECUTED` plan with no human approver fails without the line, and any plan with no human approver fails on each out-of-scope, non-goal, excluded, deferred, descoped, obsolete, not-covered or GAP item that cites no ticket AC, PRD or operator ruling. The ticket worker runs it before setting a PLN `APPROVED`, handoff runs it on every linked PLN, and fleet-orchestrator runs it at dispatch and QA prep and states the operator's scope-source ruling; takeover and resume prompts make the incoming writer trace every inherited exclusion to a human source or build or escalate it.
 - fleet-orchestrator prose: near a Codex usage limit, tell the operator with the available resets and, when they are away, move the busiest writers to Claude writers; group bug fixes into one umbrella ticket with PRs split by code area; work outside the program goes to its owner as a ticket.
 
 ### vibe v1.0.74
diff --git a/plugins/vibe/agents/vibe-change-worker.md b/plugins/vibe/agents/vibe-change-worker.md
index ed6c8705..f6c8a165 100644
--- a/plugins/vibe/agents/vibe-change-worker.md
+++ b/plugins/vibe/agents/vibe-change-worker.md
@@ -567,7 +567,8 @@ asks for placement advice and continues the same request; `NEEDS_REVIEW` waits f
 human-only action, never a test or engineering choice. Never stop for
 authorization on in-scope work (repairing tests your change broke, a main
 merge, a push, an in-scope fix): do it and report it afterwards; only a flag
-key, a product question, a destructive action or a credential waits, and
+key, a product question, dropping or narrowing scope, a destructive action
+or a credential waits, and
 `session-questions.mjs ask` refuses any other permission question. `NEEDS_COMMIT` waits
 for the orchestrator; `DONE` means the whole requested feature passed its
 quick checks in the loop, or its checks and reviews at handoff, and always
diff --git a/plugins/vibe/agents/vibe-ticket-worker.md b/plugins/vibe/agents/vibe-ticket-worker.md
index f6e81a18..fe32a00d 100644
--- a/plugins/vibe/agents/vibe-ticket-worker.md
+++ b/plugins/vibe/agents/vibe-ticket-worker.md
@@ -161,7 +161,10 @@ F. Status. The PLN's status follows the work:
    selector, monitor or other dependency is missing keeps that task open and
    the PLN `DRAFT`; return `NEEDS_CHANGE` rather than approving it.
    You never set a PLN's approver, so the `APPROVED` you set means built
-   and checked, never a human approval. Before setting it, save the PLN's
+   and checked, never a human approval: set it only when `get-document`
+   shows a human `approverId`, or when the published text starts with the
+   `Self-approved` line `session-plan.mjs` renders (version an older text
+   in D first). Before setting it, save the PLN's
    `get-document` JSON and its latest text and run
    `node ../skills/handoff/scripts/rulings-check.mjs --plan <json> --plan-body <text>`;
    each exclusion it names (out of scope, deferred, not covered, a GAP line)
diff --git a/plugins/vibe/skills/fleet-orchestrator/SKILL.md b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
index 8d0712bf..7be966c7 100644
--- a/plugins/vibe/skills/fleet-orchestrator/SKILL.md
+++ b/plugins/vibe/skills/fleet-orchestrator/SKILL.md
@@ -12,6 +12,7 @@ You run a program of several PRs at once: you plan, route, review, push back and
 1. **The operator's attention is the scarcest resource.** Decide everything you can yourself (precedent, sibling consistency, repo rules, measurements), act on it, and tell the operator the ruling in one line so they can override. Escalate only what needs them (product trade-offs, irreversible actions, approvals the repo reserves for humans), one question at a time with a recommendation. Never forward a worker's question or result without first trying to settle or verify it.
    Before any ruling on behavior, follow the single ordered product-question
    research list in [vibe's quality loop](../vibe/references/quality-loop.md#communication-and-product-questions); do not copy or reorder it here. Under fleet orchestration, a writer's `NEEDS_PERSON` comes to you, and you finish that list before asking the operator.
+   A scope exclusion, deferral or "obsolete" call counts only with a human source (operator ruling): a ticket AC, a PRD line, a recorded operator ruling, or a plan with a named human approver. A self-approved plan or a handoff note never counts, and writers ask before dropping or narrowing anything.
    Every question to the operator names where you checked the code first (`checked in code: <file>:<line>`); drop one the code already answers. `scripts/review-page-check.mjs` refuses a decision row without it.
 
    A human-sourced line that conflicts with the ruling goes to the operator as a question with a recommendation. Record every ruling with its source in the resume log as `- Ruling (<who>): <decision>`, and have the writer add it to the ticket with the criteria it amends (`../handoff/scripts/rulings-check.mjs` fails until it is there) and cite it on the relevant thread.
diff --git a/plugins/vibe/skills/handoff/scripts/rulings-check.mjs b/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
index 0316643a..b2d9df65 100644
--- a/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
+++ b/plugins/vibe/skills/handoff/scripts/rulings-check.mjs
@@ -19,9 +19,11 @@
 // but never its approver) is not a ruling, so each exclusion in it must cite
 // a human source: a ticket AC (`<slug> AC-<n>`), a PRD, an operator ruling, or
 // a plan approved by a named human. An exclusion is an item on an
-// Out-of-scope, Non-goals, Excluded, Deferred, Descoped or Not covered line, a
+// Out-of-scope, Non-goals, Excluded, Deferred, Descoped, Obsolete or Not covered line, a
 // GAP line, a bullet under such a heading, or a clause saying out of scope,
-// outside this scope, not covered, deferred or descoped. A writer once skipped
+// outside this scope, not covered, deferred, descoped or obsolete. An APPROVED
+// or EXECUTED plan with no approver must also carry the self-approved marker
+// session-plan.mjs renders. A writer once skipped
 // two tickets on an uncited Out-of-scope line of a plan vibe itself had set to
 // APPROVED, against a direct instruction to build them.
 
@@ -34,10 +36,11 @@ const TICKET_RULING = /^\s*[-*]\s*Ruling\b[^:\n]*:\s*(.+?)\s*$/gm;
 const AMENDS = /;\s*amends:\s*(\S.*)$/;
 const PROGRAM_RULING = /^\s*[-*]\s*Ruling\s+(\d{4}-\d{2}-\d{2})\s+\((operator message|AskUserQuestion|ticket):\s*(\S.*?)\):\s*(\S.*)$/gm;
 
-const EXCLUSION_LABEL = /^\s*(?:[-*]\s+)?(?:\[[ xX]\]\s*)?\**\s*(out[- ]of[- ]scope|non-?goals?|excluded|exclusions?|deferred|descoped|not covered|GAP(?:-\d+)?)\s*\**\s*:\s*\**\s*(.*)$/i;
-const EXCLUSION_HEADING = /^#{2,6}\s+(?:out[- ]of[- ]scope|non-?goals?|excluded|exclusions|deferred|descoped|not covered|gaps?)\b/i;
-const EXCLUSION_PHRASE = /\b(?:out[- ]of[- ]scope|outside (?:of )?(?:this|the) (?:\w+ )?scope|not covered|deferred|descoped)\b/i;
+const EXCLUSION_LABEL = /^\s*(?:[-*]\s+)?(?:\[[ xX]\]\s*)?\**\s*(out[- ]of[- ]scope|non-?goals?|excluded|exclusions?|deferred|descoped|obsolete|not covered|GAP(?:-\d+)?)\s*\**\s*:\s*\**\s*(.*)$/i;
+const EXCLUSION_HEADING = /^#{2,6}\s+(?:out[- ]of[- ]scope|non-?goals?|excluded|exclusions|deferred|descoped|obsolete|not covered|gaps?)\b/i;
+const EXCLUSION_PHRASE = /\b(?:out[- ]of[- ]scope|outside (?:of )?(?:this|the) (?:\w+ )?scope|not covered|deferred|descoped|obsolete)\b/i;
 const HUMAN_SOURCE = /\bPRD-\d+\b|\b[A-Z]{2,}-\d+\s+AC-?\d+\b|\bacceptance criteri(?:on|a)\b|\boperator\b|\brulings?\b|\bruled\b|\bapproved by\b/i;
+const SELF_APPROVED = /^>\s*Self-approved:/m;
 const NOTHING = /^(?:none|nothing|n\/a|-)\.?$/i;
 
 /** The exclusions in a plan body that cite no human source. */
@@ -82,8 +85,11 @@ export function planProblems(doc, body = doc?.version?.content) {
   if (typeof body !== "string" || (body === doc?.version?.content && doc?.version?.contentTruncated)) {
     return [`${name}: pass its full latest version text with --plan-body`];
   }
-  return uncitedExclusions(body).map((item) =>
-    `${name} is ${doc?.status ?? "unapproved"} with no human approver, so its exclusion "${item.slice(0, 160)}" is not a ruling; cite a ticket AC, PRD or operator ruling for it, or build it or escalate it`);
+  const unmarked = ["APPROVED", "EXECUTED"].includes(doc?.status) && !SELF_APPROVED.test(body)
+    ? [`${name} is ${doc.status} with no human approver and is not marked self-approved; publish it from session-plan.mjs, which renders the marker, or have a human approve it`]
+    : [];
+  return [...unmarked, ...uncitedExclusions(body).map((item) =>
+    `${name} is ${doc?.status ?? "unapproved"} with no human approver, so its exclusion "${item.slice(0, 160)}" is not a ruling; cite a ticket AC, PRD or operator ruling for it, or build it or escalate it`)];
 }
 
 function normalize(text) {
diff --git a/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs b/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
index bd063a1e..45141b38 100644
--- a/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
+++ b/plugins/vibe/skills/handoff/scripts/rulings-check.test.mjs
@@ -41,60 +41,67 @@ test("the program index requires dated sources and contains every reconciled rul
   assert.match(programRulingProblems(program, [QA_RECORD])[0], /not in the program rulings index/);
 });
 
-// Shaped like the plan vibe set to APPROVED with no approver, whose uncited
-// Out-of-scope line a writer used to skip two tickets it was told to build.
-const SELF_APPROVED_PLAN = [
-  "# Implementation Plan: PRD-7 Responsive Narrow List",
+// Shaped like PLN-2212 v2: APPROVED by vibe's own handoff with approverId null,
+// whose uncited Out-of-scope line a writer used to skip ISS-9381 and ISS-9522
+// after the orchestrator told it to build both.
+const PLN_2212_SHAPED = [
+  "# Implementation Plan: PRD-727 Responsive Narrow Gridview",
   "",
   "**Scope:**",
-  "- In-scope: ISS-1; ISS-2, ISS-3 and the shared responsive branch.",
-  "- Out-of-scope: ISS-4 prototype recomposition, ISS-5 responsive preference versioning, public documentation, and broad local suites assigned by the operator to automatic CI.",
+  "- In-scope: ISS-12683; ISS-9377, ISS-9380 and ISS-12631; the shared responsive branch.",
+  "- Out-of-scope: ISS-9381 prototype recomposition, ISS-9522 responsive preference versioning, public documentation, and broad local suites assigned by the operator to automatic CI.",
   "",
   "## Acceptance Criteria",
   "",
   "| ID | Criterion | Source |",
   "|----|-----------|--------|",
-  "| AC-001 | The ledger maps every approved behavior to a component, defect, or non-goal. | PRD-7 |",
-  "| AC-004 | The preserved prototype imports the mastered implementation. | PRD-7; ISS-4 is explicitly outside this build scope and remains untouched |",
+  "| AC-001 | The ledger maps every approved behavior to a component, defect, or non-goal. | PRD-727 |",
+  "| AC-004 | The preserved prototype imports the mastered implementation. | PRD-727; ISS-9381 is explicitly outside this build scope and remains untouched |",
   "",
   "## Implementation Notes",
   "",
-  "- Child mapping at handoff: covered are ISS-2 and ISS-3. Not covered and unchanged are ISS-4 and ISS-5.",
+  "- Child mapping at handoff: covered are ISS-9377 and ISS-9380. Not covered and unchanged are ISS-9381 and ISS-9522.",
+  "- The card fallback tests are obsolete and deleted, as PRD-727 retires that fallback.",
   "",
   "## Gaps",
   "",
-  "- [ ] **GAP-001**: ISS-4 prototype recomposition is explicitly outside this build scope.",
-  "- [ ] **GAP-002**: ISS-5 responsive preference versioning is deferred per operator ruling 2026-10-19.",
+  "- [ ] **GAP-001**: ISS-9381 prototype recomposition is explicitly outside this build scope.",
+  "- [ ] **GAP-002**: ISS-9522 responsive preference versioning is deferred per operator ruling 2026-10-19.",
 ].join("\n");
-const planDoc = (extra = {}) => ({ slug: "PLN-1", status: "APPROVED", approverId: null, version: { content: SELF_APPROVED_PLAN, contentTruncated: false }, ...extra });
+const planDoc = (extra = {}) => ({ slug: "PLN-2212", status: "APPROVED", approverId: null, version: { content: PLN_2212_SHAPED, contentTruncated: false }, ...extra });
+const MARKER = "> Self-approved: vibe sets this plan's status and no human approved it.";
 
 test("a plan no human approved cannot exclude work without citing a human source for each exclusion", () => {
-  assert.deepEqual(uncitedExclusions(SELF_APPROVED_PLAN), [
-    "ISS-4 prototype recomposition",
-    "ISS-5 responsive preference versioning",
+  assert.deepEqual(uncitedExclusions(PLN_2212_SHAPED), [
+    "ISS-9381 prototype recomposition",
+    "ISS-9522 responsive preference versioning",
     "public documentation",
-    "ISS-4 is explicitly outside this build scope and remains untouched",
-    "- Child mapping at handoff: covered are ISS-2 and ISS-3. Not covered and unchanged are ISS-4 and ISS-5.",
-    "ISS-4 prototype recomposition is explicitly outside this build scope.",
+    "ISS-9381 is explicitly outside this build scope and remains untouched",
+    "- Child mapping at handoff: covered are ISS-9377 and ISS-9380. Not covered and unchanged are ISS-9381 and ISS-9522.",
+    "ISS-9381 prototype recomposition is explicitly outside this build scope.",
   ]);
   const problems = planProblems(planDoc());
-  assert.equal(problems.length, 6);
-  assert.match(problems[0], /PLN-1 is APPROVED with no human approver, so its exclusion "ISS-4 prototype recomposition" is not a ruling/);
+  assert.equal(problems.length, 7);
+  assert.match(problems[0], /PLN-2212 is APPROVED with no human approver and is not marked self-approved/);
+  assert.match(problems[1], /PLN-2212 is APPROVED with no human approver, so its exclusion "ISS-9381 prototype recomposition" is not a ruling/);
+  assert.equal(planProblems(planDoc(), `${MARKER}\n\n${PLN_2212_SHAPED}`).length, 6, "the marker says it is self-approved; its exclusions still need sources");
   assert.deepEqual(planProblems(planDoc({ approverId: "user-1" })), [], "a plan a named human approved is a source");
+  assert.equal(planProblems(planDoc({ status: "DRAFT" })).length, 6, "a draft is not a ruling either, and needs no marker");
   assert.deepEqual(uncitedExclusions("- Out-of-scope: none\n- Non-goals: ISS-9 per ISS-8 AC-3; offline sync (PRD-4)\n"), []);
   assert.deepEqual(uncitedExclusions("## Out of scope\n\n- the export menu\n- bulk delete, per operator ruling 2026-10-20\n"), ["the export menu"]);
+  assert.deepEqual(uncitedExclusions("- Obsolete: the RTL criterion\n"), ["the RTL criterion"]);
   assert.match(planProblems(planDoc({ version: { content: "truncated", contentTruncated: true } })).join(), /--plan-body/);
 });
 
-test("the command fails on a self-approved plan with an uncited exclusion and passes once each one is cited", (t) => {
+test("the command fails on a PLN-2212-shaped plan and passes once it is marked and each exclusion is cited", (t) => {
   const dir = mkdtempSync(path.join(os.tmpdir(), "rulings-plan-"));
   t.after(() => rmSync(dir, { recursive: true, force: true }));
   const doc = path.join(dir, "plan.json");
   writeFileSync(doc, JSON.stringify(planDoc()));
   const refused = spawnSync(process.execPath, [SCRIPT, "--plan", doc], { encoding: "utf8" });
   assert.equal(refused.status, 1);
-  assert.equal(JSON.parse(refused.stdout).problems.length, 6);
+  assert.equal(JSON.parse(refused.stdout).problems.length, 7);
   const body = path.join(dir, "body.md");
-  writeFileSync(body, "- Out-of-scope: ISS-4 per ISS-4 AC-2 (operator ruling 2026-10-21)\n");
+  writeFileSync(body, `${MARKER}\n\n- Out-of-scope: ISS-9381 per ISS-9381 AC-2 (operator ruling 2026-10-21)\n`);
   assert.equal(spawnSync(process.execPath, [SCRIPT, "--plan", doc, "--plan-body", body], { encoding: "utf8" }).status, 0);
 });
diff --git a/plugins/vibe/skills/vibe/scripts/session-plan.mjs b/plugins/vibe/skills/vibe/scripts/session-plan.mjs
index a9e4fdc3..42713d9f 100644
--- a/plugins/vibe/skills/vibe/scripts/session-plan.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-plan.mjs
@@ -15,6 +15,12 @@
 // worker): true when it matches the rendered body apart from whitespace, so a
 // whitespace-only edit is not a material change. `empty: true` means the
 // session has no plan yet and nothing is written.
+//
+// The body starts with SELF_APPROVED_MARKER: vibe sets a PLN's status but
+// never its approver, so its APPROVED means built and checked, not a human
+// approval, and none of its exclusions is a ruling unless it cites a human
+// source (handoff's rulings-check.mjs --plan). A writer once skipped two
+// tickets on an uncited Out-of-scope line of such a plan.
 
 import { createHash } from "node:crypto";
 import { chmodSync, lstatSync, readdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
@@ -27,6 +33,7 @@ import { checkPublishableText } from "./publishable-text.mjs";
 import { git } from "./session-record.mjs";
 
 const PLAN_SEPARATOR = "\n\n---\n\n";
+export const SELF_APPROVED_MARKER = "> Self-approved: vibe sets this plan's status and no human approved it; an exclusion here counts only where it cites a ticket AC, a PRD or an operator ruling.";
 
 /** The session's plans: top-level regular `.md` files of the local plan folder, in request ID order. */
 export function localPlanFiles(worktree) {
@@ -69,7 +76,7 @@ export function renderSessionPlan(worktree, { roots, privateWords }) {
     problems.push(...checked.problems.map((problem) => ({ file, ...problem })));
     return checked.text.trim();
   });
-  return { plans, body: plans.length ? `${bodies.join(PLAN_SEPARATOR)}\n` : "", problems };
+  return { plans, body: plans.length ? `${SELF_APPROVED_MARKER}\n\n${bodies.join(PLAN_SEPARATOR)}\n` : "", problems };
 }
 
 /** The checkout paths that become repo-relative: the session worktree, then the main checkout. */
diff --git a/plugins/vibe/skills/vibe/scripts/session-plan.test.mjs b/plugins/vibe/skills/vibe/scripts/session-plan.test.mjs
index da964cf6..41338fab 100644
--- a/plugins/vibe/skills/vibe/scripts/session-plan.test.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-plan.test.mjs
@@ -4,7 +4,7 @@ import path from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 import { checkPublishableText } from "./publishable-text.mjs";
-import { localPlanFiles, planDigest, renderSessionPlan } from "./session-plan.mjs";
+import { localPlanFiles, planDigest, renderSessionPlan, SELF_APPROVED_MARKER } from "./session-plan.mjs";
 import { git, makeCheckout, makeHome, runNode } from "./test-fixtures.mjs";
 
 const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), "session-plan.mjs");
@@ -78,7 +78,7 @@ test("plans are the top-level markdown files in request ID order; subfolders sta
   writePlan(checkout, "notes.txt", "not a plan\n");
   assert.deepEqual(localPlanFiles(checkout), [".closedloop-ai/vibe-plans/request-2.md", ".closedloop-ai/vibe-plans/request-10.md"]);
   const rendered = renderSessionPlan(checkout, { roots: [checkout] });
-  assert.equal(rendered.body, "# Two\n\n---\n\n# Ten\n");
+  assert.equal(rendered.body, `${SELF_APPROVED_MARKER}\n\n# Two\n\n---\n\n# Ten\n`);
   assert.deepEqual(rendered.problems, []);
 });
 
@@ -95,9 +95,9 @@ test("the CLI writes the sanitized body and reports whether the published versio
   writePlan(checkout, "request-1.md", `# Implementation Plan: Board chips\n\nChange \`${checkout}/apps/app/board.tsx\`.\n`);
   const first = runNode(SCRIPT, ["--worktree", checkout, "--out", out], home);
   assert.equal(first.status, 0, JSON.stringify(first.json));
-  assert.equal(readFileSync(out, "utf8"), "# Implementation Plan: Board chips\n\nChange `apps/app/board.tsx`.\n");
+  assert.equal(readFileSync(out, "utf8"), `${SELF_APPROVED_MARKER}\n\n# Implementation Plan: Board chips\n\nChange \`apps/app/board.tsx\`.\n`);
   const published = path.join(path.dirname(out), "vibe-live-plan-published.md");
-  writeFileSync(published, "# Implementation Plan: Board chips\n\n\nChange `apps/app/board.tsx`.   \n");
+  writeFileSync(published, `${SELF_APPROVED_MARKER}\n\n# Implementation Plan: Board chips\n\n\nChange \`apps/app/board.tsx\`.   \n`);
   assert.equal(runNode(SCRIPT, ["--worktree", checkout, "--out", out, "--published", published], home).json.current, true);
   writePlan(checkout, "request-2.md", "# Implementation Plan: Selected chip fill\n");
   assert.equal(runNode(SCRIPT, ["--worktree", checkout, "--out", out, "--published", published], home).json.current, false);
diff --git a/plugins/vibe/skills/vibe/scripts/session-questions.mjs b/plugins/vibe/skills/vibe/scripts/session-questions.mjs
index 50ed425d..2ac3bbd2 100644
--- a/plugins/vibe/skills/vibe/scripts/session-questions.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-questions.mjs
@@ -22,8 +22,8 @@
 // (repair a test the change broke, merge main, push, rerun a check, fix a
 // finding): that work never waits, so the writer does it and reports it. A
 // writer once sat idle for an hour "pending authorization" to repair tests.
-// Only a flag key, a product question, a destructive action or a credential
-// waits for the person.
+// Only a flag key, a product question, dropping or narrowing scope, a
+// destructive action or a credential waits for the person.
 // Every command prints one JSON object; errors print {"ok":false,"error":...}.
 
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -37,7 +37,7 @@ const KEY_PATTERN = /^[a-z0-9]+(?:[-:][a-z0-9]+)*$/;
 const MAX_TEXT = 4000;
 const ASKS_LEAVE = /\b(?:may|can|shall|should) i\b|\b(?:ok|okay|fine) (?:for me )?to\b|\bpermission\b|\bauthori[sz](?:e|ation)\b|\bapprov(?:e|al)\b|\bgo-?ahead\b/i;
 const IN_SCOPE_WORK = /\b(?:tests?|fixtures?|specs?|snapshots?|merge (?:main|the base)|main merge|rebase|push|commit|rerun|re-run|lint|typecheck|fix(?:es)?|repair)\b/i;
-const HUMAN_ONLY = /\b(?:flags?|feature flag|credentials?|password|token|sign(?:ed)?[ -]?in|log ?in|delete|discard|destroy|drop|force|wording|copy|product)\b/i;
+const HUMAN_ONLY = /\b(?:flags?|feature flag|credentials?|password|token|sign(?:ed)?[ -]?in|log ?in|delete|discard|destroy|drop|force|wording|copy|product|skip|narrow|defer|exclude|descope|obsolete|out of scope)\b/i;
 
 /** In-scope engineering work asked as permission; it never waits for the person. */
 export function asksLeaveForInScopeWork(question) {
@@ -54,7 +54,7 @@ export function askQuestion(questions, { key, question, product = false, codeEvi
   requireKey(key);
   requireText("--question", question);
   if (asksLeaveForInScopeWork(question)) {
-    throw new Error("in-scope work never waits for authorization: repairing tests the change broke, a main merge, a push, a rerun or an in-scope fix goes ahead now and is reported afterwards; only a flag key, a product question, a destructive action or a credential waits");
+    throw new Error("in-scope work never waits for authorization: repairing tests the change broke, a main merge, a push, a rerun or an in-scope fix goes ahead now and is reported afterwards; only a flag key, a product question, dropping or narrowing scope, a destructive action or a credential waits");
   }
   if (product && !/^\S.*:\d+(?:-\d+)?$/.test(codeEvidence ?? "")) {
     throw new Error("a product question needs --code-evidence <file:line> proving the code and data model were checked first");
diff --git a/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs b/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
index 3534f603..2f4858e2 100644
--- a/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
+++ b/plugins/vibe/skills/vibe/scripts/session-questions.test.mjs
@@ -113,6 +113,7 @@ test("permission to do in-scope engineering work is refused; flags, product call
     "Can owners change in bulk?",
     "Which wording should the empty state use?",
     "May I sign in to the preview with your account?",
+    "Should I skip the tests for the two tickets the plan calls out of scope?",
   ];
   for (const question of waits) assert.equal(asksLeaveForInScopeWork(question), false, question);
   assert.equal(askQuestion([], { key: "flag-key", question: waits[0] }).result.ask, true);
diff --git a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
index deea4c65..0d95d8f8 100644
--- a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
+++ b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
@@ -96,3 +96,6 @@ def test_a_plan_no_human_approved_is_never_a_scope_ruling() -> None:
     assert "rulings-check.mjs --plan <json> --plan-body <text>" in _text(FLEET / "SKILL.md")
     templates = _text(FLEET / "references" / "templates.md")
     assert templates.count("Inherited scope: trace every exclusion") == 2, "takeover preamble and resume prompt"
+    assert "SELF_APPROVED_MARKER}" in (VIBE / "scripts" / "session-plan.mjs").read_text()
+    assert "starts with the `Self-approved` line" in _text(PLUGIN / "agents" / "vibe-ticket-worker.md")
+    assert "A self-approved plan or a handoff note never counts" in _text(FLEET / "SKILL.md")

From e1939fe81bfbf98a77e8114b355abc1abe1e2c7d Mon Sep 17 00:00:00 2001
From: Daniel Ochoa <daniel.ochoa@closedloop.ai>
Date: Thu, 22 Oct 2026 08:44:15 -0500
Subject: [PATCH 5/5] fix(vibe): flag PRs blocked by unresolved review threads

- snapshot.sh reads each watched PR's unresolved review threads and
  prints threads=<n>; an open PR with any ends BLOCKED(unresolved
  threads), apart from its review decision and checks. Two approved
  PRs with auto-merge armed sat blocked for hours while their writers
  waited and the block was read as a missing approval.

Testing: snapshot.test.mjs with a fake gh, failing with the flag
removed.
Risks: one more gh call per watched PR per tick.
---
 CHANGELOG.md                                      |  1 +
 plugins/vibe/skills/codex-fleet-monitor/SKILL.md  |  3 ++-
 .../codex-fleet-monitor/scripts/snapshot.sh       |  9 +++++++--
 .../codex-fleet-monitor/scripts/snapshot.test.mjs | 15 ++++++++++++++-
 .../python/test_vibe_1075_lessons_contract.py     |  3 ++-
 5 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2cf0ced..0041d172 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ The open fleet lessons from the 2026-10-21 and 2026-10-22 orchestration runs, ea
 #### Added
 - A thread the App Server unloaded (`notLoaded`) after its turn finished reads `IDLE` with its final message, the same as a loaded one; a test proves it, so no code change was needed.
 - `liveness.mjs` adds `MODEL(<model>/<effort>!=<want>)` to a session whose thread runs on another model or effort than `CODEX_MODEL` and `CODEX_EFFORT`, and `fleet.sh` refuses a new Codex session without a model as well as an effort.
+- A watched PR line carries `threads=<n>` unresolved review threads and ends `BLOCKED(unresolved threads)` while an open PR has any, apart from its review decision and checks; approved PRs with auto-merge armed once sat blocked for hours.
 - `watch.sh` holds a lock per work dir; a second copy (one started with `&`) exits 3 and says to start it with the harness's background option, and a lock whose pid died is taken over.
 - fleet-orchestrator: `board.mjs duty` gives each standing duty (main's post-merge health, a PR shepherd, the watcher) an owner, `status` prints `UNOWNED-DUTY`, and `helpers.mjs stopped` refuses a helper that owns one. `status` also prints `SLOW` for a Codex writer 30 minutes without a push while its PR has unresolved human threads, the cue to hand it to a Claude writer.
 - `executed-check.mjs` takes `--kind plan|prd`; a PRD also needs `--children` and is refused while any PRODUCES child is not DONE or CANCELED.
diff --git a/plugins/vibe/skills/codex-fleet-monitor/SKILL.md b/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
index dc2e5da3..68161153 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
+++ b/plugins/vibe/skills/codex-fleet-monitor/SKILL.md
@@ -90,7 +90,8 @@ Start it with `run_in_background`, never with `&`; a second copy for the same wo
 | `codex-usage ... unknown` / `unreadable READFAIL` | the App Server answered without rate limits, or it or the remote host could not be read | check `codex` on that machine |
 | `requests <local\|remote> <count> <newest file>` / `requests ... UNREADABLE` | a session dropped (or you removed) a delegated-work request file | hand the new request to a Claude worker, then steer its result back to the session that asked |
 | `open-prs <repo> <numbers>` | open PR list changed | add the new PR to `prs.txt` and start its review |
-| `pr ... <state> <head> <reviewDecision> <mergeable> comments= reviews= inline= checks=` | any field changed | new head: re-review; count up: read the feedback; `CONFLICTING`: tell the owning session to merge the base branch; checks: act on failures. Check counts change only once settled; while any check is pending the last settled counts show with ` (running)` |
+| `pr ... BLOCKED(unresolved threads)` | an open PR has unresolved review threads (`threads=<n>`), which block its merge even when it is approved with auto-merge armed | treat each thread as work: route it to the owning writer now, and never read the block as a missing approval |
+| `pr ... <state> <head> <reviewDecision> <mergeable> comments= reviews= inline= threads= checks=` | any field changed | new head: re-review; count up: read the feedback; `CONFLICTING`: tell the owning session to merge the base branch; checks: act on failures. Check counts change only once settled; while any check is pending the last settled counts show with ` (running)` |
 
 Surface everything that needs a human to the user immediately: limits, paid-credit spending, stalls, failures, and new human review comments.
 
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
index 1218994a..de0d3261 100755
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.sh
@@ -58,7 +58,7 @@ done
 prune_pr_state() {
   local -A live; local r n f rest
   [ -f $W/prs.txt ] && while read r n; do [ -n "$n" ] && live[${r//[^A-Za-z0-9_-]/_}-$n]=1 && live[${r//\//_}-$n]=1; done < $W/prs.txt
-  for f in $W/keep-(st|c|v|i|ck)-*.txt(N) $W/merge-*.txt(N) $W/checks-*.txt(N); do
+  for f in $W/keep-(st|c|v|i|t|ck)-*.txt(N) $W/merge-*.txt(N) $W/checks-*.txt(N); do
     rest=${${f:t:r}#keep-}; rest=${rest#*-}
     [ -n "${live[$rest]:-}" ] || rm -f $f
   done
@@ -67,6 +67,7 @@ prune_pr_state
 [ -s $W/prs.txt ] || exit 0
 ME=${MY_GH_LOGIN:-$(gh api user --jq .login 2>/dev/null)}
 skip="(.user.login==\"$ME\" or (.user.login|test(\"$BOT_LOGIN_REGEX\";\"i\")))"
+THREADS='query($o:String!,$n:String!,$p:Int!){repository(owner:$o,name:$n){pullRequest(number:$p){reviewThreads(first:100){nodes{isResolved}}}}}'
 while read r n; do
   [ -z "$n" ] && continue
   st=$(gh pr view $n -R $r --json state,headRefOid,reviewDecision,mergeable --jq '"\(.state) \(.headRefOid[0:8]) \(.reviewDecision) \(.mergeable)"' 2>/dev/null); st=$(keep st-$r-$n "$st")
@@ -77,6 +78,9 @@ while read r n; do
   c=$(gh api "repos/$r/issues/$n/comments" --jq "[.[]|select($skip|not)]|length" 2>/dev/null); c=$(keep c-$r-$n "$c")
   v=$(gh api "repos/$r/pulls/$n/reviews" --jq "[.[]|select($skip|not)]|length" 2>/dev/null); v=$(keep v-$r-$n "$v")
   i=$(gh api "repos/$r/pulls/$n/comments" --jq "[.[]|select($skip|not)]|length" 2>/dev/null); i=$(keep i-$r-$n "$i")
+  # Unresolved review threads block a merge on their own, with approvals and auto-merge in place; approved PRs once
+  # sat blocked for hours while their writers waited for auto-merge, so the block is its own word on the line.
+  t=$(gh api graphql -f query="$THREADS" -F o=${r%%/*} -F n=${r#*/} -F p=$n --jq '[.data.repository.pullRequest.reviewThreads.nodes[]|select(.isResolved|not)]|length' 2>/dev/null); t=$(keep t-$r-$n "$t")
   ck=$(gh pr checks $n -R $r 2>/dev/null | awk -F'\t' '{print $2}' | sort | uniq -c | tr -s ' ' | tr '\n' ',')
   # Report only settled results: while any check is pending, repeat the last settled value. An empty
   # answer (a failed call, or GitHub re-listing the checks) repeats the last printed value instead.
@@ -84,5 +88,6 @@ while read r n; do
   if [ -z "$ck" ]; then ck=$(keep ck-$r-$n "")
   elif [[ "$ck" == *pending* ]]; then ck=$(keep ck-$r-$n "$(cat $kc 2>/dev/null) (running)")
   else echo "$ck" > $kc; ck=$(keep ck-$r-$n "$ck"); fi
-  echo "pr $r#$n $st comments=$c reviews=$v inline=$i checks=$ck"
+  blocked=; [[ ${st%% *} == OPEN && ${t:-0} -gt 0 ]] && blocked=" BLOCKED(unresolved threads)"
+  echo "pr $r#$n $st comments=$c reviews=$v inline=$i threads=$t checks=$ck$blocked"
 done < $W/prs.txt
diff --git a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.test.mjs b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.test.mjs
index 34836356..cefec714 100644
--- a/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.test.mjs
+++ b/plugins/vibe/skills/codex-fleet-monitor/scripts/snapshot.test.mjs
@@ -14,6 +14,7 @@ const FAKE_GH = `#!/bin/sh
 [ "$(cat "$FAKE_ROOT/gh-mode")" = ok ] || exit 1
 case "$*" in
   "api user"*) echo me ;;
+  "api graphql"*) cat "$FAKE_ROOT/threads" 2>/dev/null || echo 0 ;;
   "pr list"*) printf '5\\n7\\n' ;;
   "pr view"*) echo "OPEN abcdef12 APPROVED MERGEABLE" ;;
   "pr checks"*) printf 'build\\tpass\\t1m\\nlint\\tpass\\t1m\\n' ;;
@@ -50,7 +51,7 @@ test('a blank gh read keeps the last value for each key, so it is not an event',
   const f = fixture();
   const good = f.run('ok');
   assert.match(good, /^open-prs acme\/app 5 7 $/m);
-  assert.match(good, /^pr acme\/app#42 OPEN abcdef12 APPROVED MERGEABLE comments=2 reviews=1 inline=3 checks=/m);
+  assert.match(good, /^pr acme\/app#42 OPEN abcdef12 APPROVED MERGEABLE comments=2 reviews=1 inline=3 threads=0 checks=/m);
   assert.equal(f.run('fail'), good);
   assert.equal(f.run('ok'), good);
 });
@@ -112,3 +113,15 @@ test('state files of a PR that left prs.txt are removed; those of a watched PR s
     assert.equal(existsSync(join(f.work, name)), true, `${name} stays`);
   }
 });
+
+test('an approved PR with unresolved review threads is BLOCKED, apart from its reviews and checks', TIMEOUT, () => {
+  const f = fixture();
+  writeFileSync(join(f.root, 'threads'), '2\n');
+  const blocked = f.run('ok');
+  assert.match(blocked, /^pr acme\/app#42 OPEN abcdef12 APPROVED MERGEABLE comments=2 reviews=1 inline=3 threads=2 checks=.*pass.* BLOCKED\(unresolved threads\)$/m);
+  assert.equal(f.run('fail'), blocked, 'a failed read keeps the block');
+  writeFileSync(join(f.root, 'threads'), '0\n');
+  const clear = f.run('ok');
+  assert.match(clear, /^pr acme\/app#42 .* threads=0 checks=/m);
+  assert.doesNotMatch(clear, /BLOCKED/);
+});
diff --git a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
index 0d95d8f8..f7fdc5be 100644
--- a/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
+++ b/plugins/vibe/tools/python/test_vibe_1075_lessons_contract.py
@@ -52,8 +52,9 @@ def test_the_watcher_flags_model_drift_wider_questions_and_a_second_copy() -> No
     snapshot = (MONITOR / "scripts" / "snapshot.sh").read_text()
     assert snapshot.count("CODEX_MODEL=${CODEX_MODEL:-}") == 2, "local and remote liveness both get the configured model"
     assert "watch.lock" in (MONITOR / "scripts" / "watch.sh").read_text()
+    assert "BLOCKED(unresolved threads)" in snapshot
     monitor = _text(MONITOR / "SKILL.md")
-    for wired in ("MODEL(<model>/<effort>!=<want>)", "`notLoaded`", "permission, authorization or approval", "never with `&`", "resets"):
+    for wired in ("BLOCKED(unresolved threads)", "MODEL(<model>/<effort>!=<want>)", "`notLoaded`", "permission, authorization or approval", "never with `&`", "resets"):
         assert wired in monitor, wired