diff --git a/docs/conventions/hook-budget/README.md b/docs/conventions/hook-budget/README.md
index effc765cf0..ef7acb6d80 100644
--- a/docs/conventions/hook-budget/README.md
+++ b/docs/conventions/hook-budget/README.md
@@ -140,7 +140,15 @@ Every shipped hook row, except the shell-form rows named under "Scope", is exec
 - **What shipped.** Every row in `plugins/*/hooks/hooks.json` and in the skill-frontmatter hooks of
   `disk-hygiene:clean` and `repo-hygiene:clean`, except the shell-form rows named under "Scope",
   carries `args` and `"command": "node"`. Option gates
-  that used to be shell tests are launcher flags (`--require-true`, `--run-if-unset-or-true`). Two
+  that used to be shell tests are launcher flags (`--require-true`, `--run-if-unset-or-true`).
+  Two more flags skip the bash start on a row whose script would exit at once:
+  `--skip-if-all-false A,B,...` skips only when every named option is exactly `false` (the
+  guardrails verify rows, whose three verifiers each keep their own switch), and
+  `--skip-unless-stdin-contains TEXT` buffers stdin and skips a payload without TEXT (the testing
+  `Bash` row). `--skip-unless-stdin-contains` is advisory-only and must never gate a blocking
+  guard row: a stdin stall past the idle bound exits 0 without running the script, so a guard
+  behind it would fail open. The flag list is in the header of
+  [`lib/exec-bash.mjs`](../../../lib/exec-bash.mjs). Two
   scripts check the spelling. `scripts/check-exec-form-windows-probe.sh` rejects a `.sh` path, a
   `.cmd`/`.bat` shim, or bare `bash` as `command`; a non-Windows skip of its spawn half does not show
   that [anthropics/claude-code#90495](https://github.com/anthropics/claude-code/issues/90495) is
@@ -160,7 +168,7 @@ Every shipped hook row, except the shell-form rows named under "Scope", is exec
   [`lib/exec-bash.mjs`](../../../lib/exec-bash.mjs)).
 - **Scope.** The `SessionStart` node-notice row of every hook plugin (the [prerequisites convention](../prerequisites/README.md#hook-notices)) and the `hook-failure-audit` Stop row in `harness-ops` stay shell form so they can report a missing `node`.
   Neither check script inspects a shell-form row; `scripts/node-notice-rows.test.sh` pins the node-notice
-  rows and the hook test of `harness-ops` pins its Stop row, so a sweep back to `node` fails them. A plugin hook config carries no
+  rows (and the matcher that skips them on compaction) and the hook test of `harness-ops` pins its Stop row, so a sweep back to `node` fails them. A plugin hook config carries no
   `${user_config.*}` token (the [philosophy Hooks row](../../plugin-philosophy.md#component-stances)),
   so no `userConfig` rule requires exec form and exec form fleet-wide is this sweep's choice.
 - **Measurement.** The reference figures above (Windows, 2026-07-31 and 2026-09-02) were taken before
diff --git a/docs/conventions/prerequisites/README.md b/docs/conventions/prerequisites/README.md
index 619ead0a38..5f2430f095 100644
--- a/docs/conventions/prerequisites/README.md
+++ b/docs/conventions/prerequisites/README.md
@@ -142,8 +142,16 @@ and `toolchain`) ships `check-prerequisites` and names that. No hook installs an
 
 | Notice | Fires | How |
 | --- | --- | --- |
-| `node` is missing | `SessionStart`, once per session across every plugin | Each hook plugin carries one shell-form `SessionStart` row that runs `lib/prerequisites.sh node-notice`, then `lib/prerequisites.ps1 node-notice`. A POSIX shell (bash, or dash as `/bin/sh` on Debian and Ubuntu) takes the first and leaves at `${PPID:+exit}`, because every POSIX shell sets `PPID`; PowerShell, the default shell on Windows without Git Bash, has no `sh`, skips to the second. Both stubs share a latch keyed by session id in the temp directory, so a session with several hook plugins sees one notice. A plugin's `<name>_enabled` kill switch, passed as the last argument, silences its row. |
-| Another hook dependency is missing | `SessionStart` for an entry whose `for` names a hook, via `probe`; and at the point of use | `hook::require <id>` in `lib/hook-utils.sh`. It fails open: when `<id>` is not on `PATH` it prints one skip notice per session and agent and exits 0. The text comes from the plugin's declared entry: `degrade`, the `docs` install link and `check`. An entry that names only a skill never notifies at session start. |
+| `node` is missing | `SessionStart` except on compaction, once per session across every plugin | Each hook plugin carries one shell-form `SessionStart` row that runs `lib/prerequisites.sh node-notice`, then `lib/prerequisites.ps1 node-notice`. A POSIX shell (bash, or dash as `/bin/sh` on Debian and Ubuntu) takes the first and leaves at `${PPID:+exit}`, because every POSIX shell sets `PPID`; PowerShell, the default shell on Windows without Git Bash, has no `sh`, skips to the second. Both stubs share a latch keyed by session id in the temp directory, so a session with several hook plugins sees one notice. A plugin's `<name>_enabled` kill switch, passed as the last argument, silences its row. |
+| Another hook dependency is missing | `SessionStart` except on compaction, for an entry whose `for` names a hook, via `probe`; and at the point of use | `hook::require <id>` in `lib/hook-utils.sh`. It fails open: when `<id>` is not on `PATH` it prints one skip notice per session and agent and exits 0. The text comes from the plugin's declared entry: `degrade`, the `docs` install link and `check`. An entry that names only a skill never notifies at session start. |
+
+The group holding the node-notice row and the group holding the `probe` row both carry
+`"matcher": "startup|resume|clear|fork"`, every SessionStart source but `compact` (the source
+list is the SessionStart matcher table in the
+[hooks reference](https://code.claude.com/docs/en/hooks), as of 2026-10-04; recheck when that table
+changes). A compaction keeps the session id (inferred from transcripts, which keep one sessionId across a compact boundary; not probed from a hook payload), and both latches with it, so a re-fire there prints
+nothing and only starts processes. `clear`, `resume` and `fork` stay: each can begin a context
+that has not seen the notice. `scripts/node-notice-rows.test.sh` pins the matcher on both rows.
 
 `hook::require` reads an entry with bash alone, from its `id` to the next one, so write `id` first in every entry.
 
diff --git a/lib/exec-bash.gates.test.mjs b/lib/exec-bash.gates.test.mjs
new file mode 100644
index 0000000000..efdd84812f
--- /dev/null
+++ b/lib/exec-bash.gates.test.mjs
@@ -0,0 +1,221 @@
+// Launch flags of exec-bash.mjs that decide, before bash starts, whether a row
+// has anything to do: --skip-if-all-false (option list) and
+// --skip-unless-stdin-contains (payload text). The live cases run on every
+// platform, Windows included.
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { needsStdin, optionGateOpen, parseLaunchArgs, stdinGateOpen, stdinIdleMs } from "./exec-bash.mjs";
+
+const VERIFY = "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED";
+const NAMES = VERIFY.split(",");
+const env = (values) =>
+  Object.fromEntries(
+    NAMES.flatMap((name, i) => (values[i] === undefined ? [] : [[`CLAUDE_PLUGIN_OPTION_${name}`, values[i]]])),
+  );
+
+// --- parsing -----------------------------------------------------------------
+const verify = parseLaunchArgs(["--skip-if-all-false", VERIFY, "/hooks/run-guards.sh", "cli-flag-verify.sh"]);
+assert.equal(verify.script, "/hooks/run-guards.sh");
+assert.deepEqual(verify.args, ["cli-flag-verify.sh"]);
+assert.equal(needsStdin(verify.gates), false);
+
+for (const bad of ["", "A,,B", "A,", ",A", "cli_flag", "-A", "A B"]) {
+  const parsed = parseLaunchArgs(["--skip-if-all-false", bad, "x.sh"]);
+  assert.match(parsed.error ?? "", /^usage: --skip-if-all-false .*CLAUDE_PLUGIN_OPTION_/, JSON.stringify(bad));
+}
+assert.match(parseLaunchArgs(["--skip-if-all-false"]).error, /^usage: --skip-if-all-false /);
+assert.match(parseLaunchArgs(["--skip-unless-stdin-contains", ""]).error, /^usage: --skip-unless-stdin-contains /);
+assert.match(parseLaunchArgs(["--skip-unless-stdin-contains", "x"]).error, /^usage: node exec-bash\.mjs /);
+
+// Flags combine in any order; the old gate keeps its meaning beside a new one.
+const scan = parseLaunchArgs([
+  "--require-true",
+  "TEST_GUARDS_ENABLED",
+  "--skip-unless-stdin-contains",
+  "bashEditDiff",
+  "/hooks/test-scan-bash.sh",
+]);
+assert.equal(scan.script, "/hooks/test-scan-bash.sh");
+assert.equal(needsStdin(scan.gates), true);
+assert.equal(optionGateOpen(scan.gates, {}), false);
+assert.equal(optionGateOpen(scan.gates, { CLAUDE_PLUGIN_OPTION_TEST_GUARDS_ENABLED: "true" }), true);
+
+// --- --skip-if-all-false: skips only when every switch is exactly "false" -----
+// Each verifier runs when its variable is unset, empty or "true", and exits at
+// its switch otherwise; the gate is stricter still and runs on any value that is
+// not literally "false", so a malformed value still starts bash.
+assert.equal(optionGateOpen(verify.gates, env(["false", "false", "false"])), false);
+for (const on of [undefined, "", "true", "TRUE", "0", " false", "False"]) {
+  for (let i = 0; i < 3; i += 1) {
+    const values = ["false", "false", "false"];
+    values[i] = on;
+    assert.equal(optionGateOpen(verify.gates, env(values)), true, `${NAMES[i]}=${JSON.stringify(on)}`);
+  }
+}
+assert.equal(optionGateOpen(verify.gates, {}), true);
+
+// --- --skip-unless-stdin-contains ----------------------------------------------
+assert.equal(stdinGateOpen(scan.gates, Buffer.from('{"tool_response":{"bashEditDiff":{}}}')), true);
+assert.equal(stdinGateOpen(scan.gates, Buffer.from('{"tool_response":{"stdout":"ok"}}')), false);
+assert.equal(stdinGateOpen(scan.gates, Buffer.alloc(0)), false);
+
+// The idle bound reads stdin_read_timeout the way hook::resolve_read_timeout_to does.
+assert.equal(stdinIdleMs({}), 2000);
+assert.equal(stdinIdleMs({ CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "0.5" }), 500);
+assert.equal(stdinIdleMs({ CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "5" }), 5000);
+for (const bad of ["0", "0.0", "-1", "abc", "1e3", "", "0.000001"]) {
+  assert.equal(stdinIdleMs({ CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: bad }), 2000, bad);
+}
+
+// --- live: a skipped row never resolves bash ----------------------------------
+// With an empty PATH on a stubbed win32 no bash resolves, so a launcher that got
+// as far as resolving prints "no bash found" and exits 1; a skipped row exits 0
+// silently.
+const launcher = fileURLToPath(new URL("./exec-bash.mjs", import.meta.url));
+const root = mkdtempSync(path.join(tmpdir(), "exec-bash-gates-"));
+const stub = path.join(root, "win32-stub.mjs");
+writeFileSync(stub, 'Object.defineProperty(process, "platform", { value: "win32" });\n');
+
+function runNoBash(args, extraEnv = {}, input = "") {
+  return spawnSync(process.execPath, ["--import", pathToFileURL(stub).href, launcher, ...args, "x.sh"], {
+    env: { SystemRoot: process.env.SystemRoot, PATH: "", ...extraEnv },
+    input,
+    encoding: "utf8",
+  });
+}
+function assertSkipped(run, label) {
+  assert.equal(run.status, 0, `${label}: ${run.stderr}`);
+  assert.equal(run.stderr, "", label);
+  assert.equal(run.stdout, "", label);
+}
+function assertReachedBash(run, label) {
+  assert.equal(run.status, 1, label);
+  assert.match(run.stderr, /no bash found/, label);
+}
+
+const editMd = JSON.stringify({ hook_event_name: "PostToolUse", tool_name: "Edit", tool_input: { file_path: "a.md" } });
+assertSkipped(runNoBash(["--skip-if-all-false", VERIFY], env(["false", "false", "false"]), editMd), "all three off");
+assertReachedBash(runNoBash(["--skip-if-all-false", VERIFY], env(["false", "true", "false"]), editMd), "one on");
+assertReachedBash(runNoBash(["--skip-if-all-false", VERIFY], env(["false", "false"]), editMd), "one unset");
+assertReachedBash(runNoBash(["--skip-if-all-false", VERIFY], {}, editMd), "all unset");
+
+// A malformed list is a launcher usage error: exit 1, nothing on stdout, one
+// stderr line under 240 characters, and no hook runs.
+for (const args of [["--skip-if-all-false", "a,b"], ["--skip-if-all-false", "A,,B"], ["--skip-unless-stdin-contains", ""]]) {
+  const run = runNoBash(args, {}, editMd);
+  assert.equal(run.status, 1, JSON.stringify(args));
+  assert.equal(run.stdout, "", JSON.stringify(args));
+  assert.equal(run.stderr.split("\n").length, 2, run.stderr);
+  assert.ok(run.stderr.length < 240, run.stderr);
+  assert.match(run.stderr, /^exec-bash: the launcher itself was called wrongly, so no hook ran: usage: --skip-/);
+}
+
+const flag = ["--skip-unless-stdin-contains", "bashEditDiff"];
+assertSkipped(runNoBash(flag, {}, '{"tool_name":"Bash","tool_response":{"stdout":"x"}}'), "no diff");
+assertSkipped(runNoBash(flag, {}, ""), "empty stdin");
+assertReachedBash(runNoBash(flag, {}, '{"tool_response":{"bashEditDiff":{"changedFiles":[]}}}'), "diff");
+
+// A closed option gate exits before stdin is read: stdin left open does not hold it.
+function runOpen(args, extraEnv, { writeAfterMs = null, payload = "" } = {}) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const child = spawn(process.execPath, ["--import", pathToFileURL(stub).href, launcher, ...args], {
+      env: { SystemRoot: process.env.SystemRoot, PATH: "", ...extraEnv },
+    });
+    let stderr = "";
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.stdin.on("error", () => {});
+    if (writeAfterMs !== null) setTimeout(() => child.stdin.end(payload), writeAfterMs);
+    child.on("exit", (code) => {
+      child.stdin.destroy();
+      resolve({ code, stderr, ms: Date.now() - started });
+    });
+  });
+}
+
+const gated = await runOpen(["--require-true", "TEST_GUARDS_ENABLED", ...flag, "x.sh"], {
+  CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "30",
+});
+assert.equal(gated.code, 0, gated.stderr);
+assert.ok(gated.ms < 10000, `closed gate waited on stdin for ${gated.ms} ms`);
+
+// A stdin that stalls past the idle bound exits 0 without running the script.
+const stalled = await runOpen([...flag, "x.sh"], { CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "0.3" });
+assert.equal(stalled.code, 0, stalled.stderr);
+assert.equal(stalled.stderr, "");
+
+// A payload that arrives inside the idle bound is still read.
+const late = await runOpen([...flag, "x.sh"], { CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "5" }, {
+  writeAfterMs: 300,
+  payload: '{"bashEditDiff":{}}',
+});
+assertReachedBash({ status: late.code, stderr: late.stderr }, "payload inside the bound");
+
+// --- live with bash: the script gets the payload byte for byte -----------------
+const echoScript = path.join(root, "echo-stdin.sh");
+writeFileSync(echoScript, "cat\n");
+function runBash(args, input, extraEnv = {}) {
+  return spawnSync(process.execPath, [launcher, ...args, echoScript], {
+    env: { ...process.env, ...extraEnv },
+    input,
+  });
+}
+const big = Buffer.from(`{"tool_response":{"bashEditDiff":{"x":"${"y".repeat(200 * 1024)}"}}}`);
+const unicode = Buffer.from('{"tool_response":{"bashEditDiff":{"path":"tëst-ü-日本.test.ts"}}}');
+const crlf = Buffer.from('{"tool_response":\r\n{"bashEditDiff":{"a":"b\r\n"}}}\r\n');
+for (const [label, payload] of [
+  ["over 64 KB", big],
+  ["non-ASCII", unicode],
+  ["CRLF", crlf],
+]) {
+  const run = runBash(flag, payload);
+  assert.equal(run.status, 0, `${label}: ${run.stderr}`);
+  assert.ok(Buffer.compare(run.stdout, payload) === 0, `${label}: payload changed on the way to the script`);
+}
+
+// A payload dripped in chunks with gaps inside the idle bound arrives whole.
+function dripRun(args, chunks, gapMs, extraEnv) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [launcher, ...args, echoScript], { env: { ...process.env, ...extraEnv } });
+    const out = [];
+    child.stdout.on("data", (d) => out.push(d));
+    child.stdin.on("error", () => {});
+    let i = 0;
+    const next = () => {
+      if (i === chunks.length) return child.stdin.end();
+      child.stdin.write(chunks[i]);
+      i += 1;
+      setTimeout(next, gapMs);
+    };
+    next();
+    child.on("close", (code) => resolve({ code, stdout: Buffer.concat(out) }));
+  });
+}
+const drip = ['{"tool_response":', '{"bashEd', 'itDiff":{', '"a":1}}}'];
+const dripped = await dripRun(flag, drip, 150, { CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "1" });
+assert.equal(dripped.code, 0);
+assert.equal(dripped.stdout.toString(), drip.join(""));
+
+// A row without a stdin flag keeps stdin inherited: a payload that starts later
+// than the stdin flag's idle bound still reaches the script.
+const delayed = await new Promise((resolve) => {
+  const child = spawn(process.execPath, [launcher, echoScript], {
+    env: { ...process.env, CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT: "0.2" },
+  });
+  const out = [];
+  child.stdout.on("data", (d) => out.push(d));
+  setTimeout(() => child.stdin.end("late payload"), 800);
+  child.on("close", (code) => resolve({ code, stdout: Buffer.concat(out).toString() }));
+});
+assert.equal(delayed.code, 0);
+assert.equal(delayed.stdout, "late payload");
+
+rmSync(root, { recursive: true, force: true });
+console.log("exec-bash gates: option list, stdin predicate, stall, and byte-for-byte delivery passed.");
diff --git a/lib/exec-bash.gates.test.sh b/lib/exec-bash.gates.test.sh
new file mode 100755
index 0000000000..d62910b212
--- /dev/null
+++ b/lib/exec-bash.gates.test.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Owns lib/exec-bash.gates.test.mjs for the plugin test lane.
+# scripts/run-outside-node-suites.sh treats a sibling .test.sh as the runner.
+set -euo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+exec node exec-bash.gates.test.mjs
diff --git a/lib/exec-bash.mjs b/lib/exec-bash.mjs
index f51cd990ab..522973eaec 100755
--- a/lib/exec-bash.mjs
+++ b/lib/exec-bash.mjs
@@ -1,16 +1,37 @@
 #!/usr/bin/env node
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -67,41 +88,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -169,19 +281,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/actionlint/.claude-plugin/plugin.json b/plugins/actionlint/.claude-plugin/plugin.json
index 0ad04703a5..cdb1221c3d 100644
--- a/plugins/actionlint/.claude-plugin/plugin.json
+++ b/plugins/actionlint/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "actionlint",
-  "version": "0.12.7",
+  "version": "0.12.8",
   "description": "Lint GitHub Actions workflow files on edit via actionlint, surfacing findings as advisory context.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/actionlint/CHANGELOG.md b/plugins/actionlint/CHANGELOG.md
index 72f88b8c76..5ad06c4a63 100644
--- a/plugins/actionlint/CHANGELOG.md
+++ b/plugins/actionlint/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `actionlint` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.12.8] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.12.7] - 2026-10-04
 
 ### Changed
diff --git a/plugins/actionlint/hooks/exec-bash.mjs b/plugins/actionlint/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/actionlint/hooks/exec-bash.mjs
+++ b/plugins/actionlint/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/actionlint/hooks/hooks.json b/plugins/actionlint/hooks/hooks.json
index c4bf262b43..5e72508627 100644
--- a/plugins/actionlint/hooks/hooks.json
+++ b/plugins/actionlint/hooks/hooks.json
@@ -32,6 +32,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -49,6 +50,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/animation/.claude-plugin/plugin.json b/plugins/animation/.claude-plugin/plugin.json
index e2200d2f1f..90495e0642 100644
--- a/plugins/animation/.claude-plugin/plugin.json
+++ b/plugins/animation/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "animation",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Hand-drawn-style 2D animation as code, rendered in headless Chromium by an ink brush engine. rotoscope copies a reference clip drawing by drawing: trace to vector paths, render, measure against the source (XOR, SSIM), and fit per-shot brush overrides. learn-style measures a clip into a style pack (ships woodcut-ink) and checks films against it. produce turns a brief into approved boards, a shot list, frames, and a delivered file. setup checks ffmpeg, Node, Chromium, and Python.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/animation/CHANGELOG.md b/plugins/animation/CHANGELOG.md
index a4f268226b..7b9bc1af01 100644
--- a/plugins/animation/CHANGELOG.md
+++ b/plugins/animation/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to the `animation` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.4.8] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
+### Fixed
+
+- The `pydeps.py` helper is now passed to native Python as a Windows path (#6250).
+
 ## [0.4.7] - 2026-10-04
 
 ### Changed
diff --git a/plugins/animation/hooks/exec-bash.mjs b/plugins/animation/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/animation/hooks/exec-bash.mjs
+++ b/plugins/animation/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/animation/hooks/hooks.json b/plugins/animation/hooks/hooks.json
index 641c043f40..14d7cbe587 100644
--- a/plugins/animation/hooks/hooks.json
+++ b/plugins/animation/hooks/hooks.json
@@ -13,7 +13,12 @@
             ],
             "timeout": 300,
             "statusMessage": "Installing animation Python packages..."
-          },
+          }
+        ]
+      },
+      {
+        "matcher": "startup|resume|clear|fork",
+        "hooks": [
           {
             "type": "command",
             "command": "sh \"${CLAUDE_PLUGIN_ROOT}/lib/prerequisites.sh\" node-notice /animation:check-prerequisites; ${PPID:+exit}; powershell -NoProfile -ExecutionPolicy Bypass -File \"${CLAUDE_PLUGIN_ROOT}/lib/prerequisites.ps1\" node-notice /animation:check-prerequisites",
diff --git a/plugins/animation/hooks/install-python-deps.sh b/plugins/animation/hooks/install-python-deps.sh
index 56c8556e46..bc4dd2751b 100755
--- a/plugins/animation/hooks/install-python-deps.sh
+++ b/plugins/animation/hooks/install-python-deps.sh
@@ -35,7 +35,30 @@ if [[ -z "$py" ]]; then
   exit 0
 fi
 
-if ! out="$("$py" "$ROOT/scripts/pydeps.py" install --data-dir "$data" </dev/null 2>&1)"; then
+# to_native <path> -> the path as a native Windows Python reads it. Under Git Bash or Cygwin a POSIX
+# path (/c/...) goes through cygpath -m: a session with MSYS path conversion switched off hands it
+# over as is, and Python resolves it against the current drive (C:\c\...). Fails rather than
+# return the unconverted path.
+to_native() {
+  case "${OSTYPE:-}" in
+  msys* | cygwin*)
+    [[ "$1" == /* ]] || {
+      printf '%s' "$1"
+      return 0
+    }
+    local converted
+    converted="$(cygpath -m "$1" 2>/dev/null)" && [[ -n "$converted" ]] && printf '%s' "$converted"
+    ;;
+  *) printf '%s' "$1" ;;
+  esac
+}
+
+if ! script="$(to_native "$ROOT/scripts/pydeps.py")" || ! data_dir="$(to_native "$data")"; then
+  notice "animation: cygpath could not convert its pydeps.py or data directory path to Windows form, so its Python packages are not installed and the rotoscope, learn-style and produce scripts will stop. Check that cygpath runs in Git Bash and start a new session."
+  exit 0
+fi
+
+if ! out="$("$py" "$script" install --data-dir "$data_dir" </dev/null 2>&1)"; then
   notice "animation: its Python packages could not be installed, so the rotoscope, learn-style and produce scripts will stop until they are. $out"
 fi
 exit 0
diff --git a/plugins/animation/hooks/install-python-deps.test.sh b/plugins/animation/hooks/install-python-deps.test.sh
index d52873a7ca..30eb572322 100755
--- a/plugins/animation/hooks/install-python-deps.test.sh
+++ b/plugins/animation/hooks/install-python-deps.test.sh
@@ -131,6 +131,45 @@ else
   fail "no python: rc=$rc output=[$out]"
 fi
 
+# Native Windows Python under Git Bash or Cygwin: pydeps.py and a POSIX data directory reach it as drive-letter
+# paths even with MSYS path conversion switched off, and a cygpath that fails is a notice, never the unconverted
+# path. The stub python3 logs its arguments; the stub cygpath maps -m /dir to C:/dir, or fails.
+# native_hook <ostype> <cygpath body> -> runs the hook with MSYS_NO_PATHCONV=1 and a POSIX data directory; sets OUT,
+# RC and ARGV.
+# shellcheck disable=SC2016  # the stub bodies expand when the stubs run, not here
+native_hook() {
+  local stubs="$WORK/stubs-$1"
+  mkdir -p "$stubs"
+  printf '#!/bin/sh\n[ "$1" = -c ] && exit 0\nprintf "%%s|" "$@" >"%s/argv.log"\n' "$WORK" >"$stubs/python3"
+  printf '#!/bin/sh\n%s\n' "$2" >"$stubs/cygpath"
+  chmod +x "$stubs/python3" "$stubs/cygpath"
+  rm -f "$WORK/argv.log"
+  OUT="$(env PATH="$stubs:$tools" OSTYPE="$1" MSYS_NO_PATHCONV=1 CLAUDE_PLUGIN_DATA="$WORK/data-native" "$tools/bash" "$root/hooks/install-python-deps.sh" <<<'{}')"
+  RC=$?
+  ARGV="$(cat "$WORK/argv.log" 2>/dev/null)"
+}
+# shellcheck disable=SC2016  # the stub body expands when the stub runs, not here
+for ostype in msys cygwin; do
+  native_hook "$ostype" '[ "$1" = -m ] && printf "C:%s\n" "$2"'
+  if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "C:$root/scripts/pydeps.py|install|--data-dir|C:$WORK/data-native|" ]]; then
+    ok "OSTYPE=$ostype with path conversion off hands Python drive-letter pydeps.py and data directory paths"
+  else
+    fail "OSTYPE=$ostype conversion: rc=$RC argv=[$ARGV] output=[$OUT]"
+  fi
+done
+native_hook msys 'exit 1'
+if [[ "$RC" -eq 0 && -z "$ARGV" && "$OUT" == *'"systemMessage"'* && "$OUT" == *'cygpath could not convert'* ]]; then
+  ok "a failing cygpath is a notice and Python never gets the unconverted path"
+else
+  fail "failing cygpath: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+native_hook linux-gnu 'exit 1'
+if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "$root/scripts/pydeps.py|install|--data-dir|$WORK/data-native|" ]]; then
+  ok "outside Git Bash and Cygwin the paths reach Python unchanged"
+else
+  fail "linux paths: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+
 echo "---"
 echo "passed: $PASS, failed: $FAIL"
 [[ "$FAIL" -eq 0 ]]
diff --git a/plugins/autonomy/.claude-plugin/plugin.json b/plugins/autonomy/.claude-plugin/plugin.json
index 7cebd16728..0be6d40bd5 100644
--- a/plugins/autonomy/.claude-plugin/plugin.json
+++ b/plugins/autonomy/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "autonomy",
-  "version": "0.26.8",
+  "version": "0.26.9",
   "description": "Contracts for governed autonomous agent operation: role topology, binding seam, telemetry, return accounting, trigger dispatch, a per-work-class guardrail matrix, a standing-routine catalog, and a runner charter. A guided setup skill writes an org's binding, wires OTLP telemetry (file default), human-attested return capture, and signal adapters behind one governed dispatch entrypoint, binds the guardrail matrix to isolation substrates after a live probe, and schedules routines.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/autonomy/CHANGELOG.md b/plugins/autonomy/CHANGELOG.md
index 914d68bce6..7cbc77f7b5 100644
--- a/plugins/autonomy/CHANGELOG.md
+++ b/plugins/autonomy/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `autonomy` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.26.9] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.26.8] - 2026-10-04
 
 ### Changed
diff --git a/plugins/autonomy/hooks/exec-bash.mjs b/plugins/autonomy/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/autonomy/hooks/exec-bash.mjs
+++ b/plugins/autonomy/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/autonomy/hooks/hooks.json b/plugins/autonomy/hooks/hooks.json
index 777a5d5075..5e47805e28 100644
--- a/plugins/autonomy/hooks/hooks.json
+++ b/plugins/autonomy/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/bash-format/.claude-plugin/plugin.json b/plugins/bash-format/.claude-plugin/plugin.json
index 20fc885361..da75509aef 100644
--- a/plugins/bash-format/.claude-plugin/plugin.json
+++ b/plugins/bash-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "bash-format",
-  "version": "0.10.7",
+  "version": "0.10.8",
   "description": "Auto-format and lint shell scripts on edit via shfmt + ShellCheck, using the consuming repo's own .editorconfig and .shellcheckrc.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/bash-format/CHANGELOG.md b/plugins/bash-format/CHANGELOG.md
index 681545b068..78b07a0fd1 100644
--- a/plugins/bash-format/CHANGELOG.md
+++ b/plugins/bash-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `bash-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.10.8] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.10.7] - 2026-10-04
 
 ### Changed
diff --git a/plugins/bash-format/hooks/exec-bash.mjs b/plugins/bash-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/bash-format/hooks/exec-bash.mjs
+++ b/plugins/bash-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/bash-format/hooks/hooks.json b/plugins/bash-format/hooks/hooks.json
index b83381b4ac..c269939d26 100644
--- a/plugins/bash-format/hooks/hooks.json
+++ b/plugins/bash-format/hooks/hooks.json
@@ -32,6 +32,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -49,6 +50,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/biome-format/.claude-plugin/plugin.json b/plugins/biome-format/.claude-plugin/plugin.json
index 1bde52fec3..a2719c403d 100644
--- a/plugins/biome-format/.claude-plugin/plugin.json
+++ b/plugins/biome-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "biome-format",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "Auto-format and lint JS/TS/JSX/JSON on edit via Biome, only when a biome.json governs the repo, using the consuming repo's own Biome config.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/biome-format/CHANGELOG.md b/plugins/biome-format/CHANGELOG.md
index b2851db8e7..5d931baf84 100644
--- a/plugins/biome-format/CHANGELOG.md
+++ b/plugins/biome-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `biome-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.8.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.8.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/biome-format/hooks/exec-bash.mjs b/plugins/biome-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/biome-format/hooks/exec-bash.mjs
+++ b/plugins/biome-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/biome-format/hooks/hooks.json b/plugins/biome-format/hooks/hooks.json
index 328a9026ef..ab6c0bc96f 100644
--- a/plugins/biome-format/hooks/hooks.json
+++ b/plugins/biome-format/hooks/hooks.json
@@ -120,6 +120,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -137,6 +138,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/context-budget/.claude-plugin/plugin.json b/plugins/context-budget/.claude-plugin/plugin.json
index ff9afb54e3..330cb20286 100644
--- a/plugins/context-budget/.claude-plugin/plugin.json
+++ b/plugins/context-budget/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "context-budget",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Measures a Claude Code session's fixed startup context payload per item at a pinned binary version, including per-tool attribution of the built-in tool pools that /context reports only as totals, derived by A/B deny differencing under comparability rules. Falls back from an SDK meter to a headless /context parser, then to an error rather than a wrong number. Keeps a per-project before/after ledger per lever. Report-only by default; fix applies one approved project-scope trim.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/context-budget/CHANGELOG.md b/plugins/context-budget/CHANGELOG.md
index 4046f7ec8f..f50609259e 100644
--- a/plugins/context-budget/CHANGELOG.md
+++ b/plugins/context-budget/CHANGELOG.md
@@ -7,6 +7,16 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 Versions 0.6.38 and 0.6.40 were reserved by parallel changes and never published.
 
+## [0.9.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+
+### Fixed
+
+- `/context-budget:audit` now parses a headless `/context` table that has no `System tools` row (#6260).
+
 ## [0.9.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/context-budget/hooks/hooks.json b/plugins/context-budget/hooks/hooks.json
index 294b2bfa7e..99de6476c5 100644
--- a/plugins/context-budget/hooks/hooks.json
+++ b/plugins/context-budget/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/context-budget/skills/audit/reference/engine.md b/plugins/context-budget/skills/audit/reference/engine.md
index 4838187864..e86ba889a8 100644
--- a/plugins/context-budget/skills/audit/reference/engine.md
+++ b/plugins/context-budget/skills/audit/reference/engine.md
@@ -10,12 +10,26 @@ that shows it, at the consumer's binary, and stamped with that binary's version.
 | Rung | Mode | Precision | Requires | Recorded caveats |
 |---|---|---|---|---|
 | 1 | `sdk` | `exact` (integer tokens) | `@anthropic-ai/claude-agent-sdk` resolvable from `--sdk-dir` or the working directory | none |
-| 2 | `cli-parse` | `display-rounded` (table cells like `11.4k`) | `<binary> -p "/context"` producing the category table | rounded values; headless `/context` is undocumented as a `-p`-capable command, so this rung depends on unsanctioned behavior. When the token-counting API is unavailable, `/context` uses a local estimate instead of extra small-model requests (Claude Code 2.1.261). The commands page `/context` row, fetched 2026-09-28, does not yet say that; the changelog is the behavior source until the row does |
+| 2 | `cli-parse` | `display-rounded` (table cells like `11.4k`) | `<binary> -p "/context"` producing the category table with at least one of the two system-tool rows. The engine spawns the binary directly; a hand check from Git Bash must run `MSYS_NO_PATHCONV=1 claude -p "/context"`, because path conversion otherwise rewrites `/context` and the session answers in prose | rounded values; a system-tool row the table lacks is named in a caveat and left unmeasured; headless `/context` is undocumented as a `-p`-capable command, so this rung depends on unsanctioned behavior. When the token-counting API is unavailable, `/context` uses a local estimate instead of extra small-model requests (Claude Code 2.1.261). The commands page `/context` row, fetched 2026-09-28, does not yet say that; the changelog is the behavior source until the row does |
 | 3 | n/a | n/a | n/a | exit 3 with a `context-budget.error/1` record naming the remediation; **never a wrong number** |
 
 The `/context` output format carries no stability guarantee in either direction and has materially
-changed several times; the parser therefore refuses loudly (rung 3) when the expected sections are
-absent rather than guessing. Known parse traps handled: an unredirected-stdin warning line
+changed several times; the parser therefore refuses loudly (rung 3) when the category table is
+absent, or when it carries neither `System tools` nor `System tools (deferred)`, rather than
+guessing. A table with only one of the two parses: the missing bucket stays out of `categories`
+(unmeasured, never zero-filled, because a cli-parse absence cannot tell format drift from an
+emptied bucket) and a caveat names it with the binary version.
+
+- **Observation:** headless `/context` on Claude Code 2.1.289 printed a `System tools (deferred)`
+  row and no `System tools` row. Whether every built-in tool is deferred in headless sessions or
+  the format changed is not documented.
+- **Pointer:** the `/context` row of [commands](https://code.claude.com/docs/en/commands), which
+  does not list `/context` as available with `-p`.
+- **As of:** 2026-10-04.
+- **Recheck trigger:** a release note names headless `/context`, tool deferral in `-p` sessions,
+  or the `/context` category table.
+
+Known parse traps handled: an unredirected-stdin warning line
 prepended to output; skill token cells formatted `~<int>` or `< <int>` unlike every other table;
 `--output-format json` returning the same markdown as a string (the engine parses plain output
 instead).
@@ -90,8 +104,8 @@ All records are JSON on stdout (and `--out <file>`), schema-tagged:
   (`--verify-additivity`: one combined-deny run checked against the sum of parts, with its own
   `comparable`/`reasons`, plus `perBucket` carrying `{sumOfParts, combinedSaved, additive,
   reasons}` for each attributed bucket, read off the `prefixDelta`/`deferredDelta` the saver rows
-  already carry rather than from any extra run; a bucket absent from both runs is outside the
-  binary's category vocabulary and gets no verdict row). Per-bucket measurability is independent:
+  already carry rather than from any extra run; a bucket absent from both runs gets no verdict
+  row: a deferred bucket because it is a non-event, the prefix bucket because it is unmeasured). Per-bucket measurability is independent:
   skill-listing and Skills-token checks gate only the prefix column, while the shared mode/binary
   checks gate both, so a combined-run listing mismatch leaves a measurable deferred verdict in
   place. Every `additive` field, top level and per bucket, is tri-state: `true` and `false` are
@@ -120,12 +134,20 @@ All records are JSON on stdout (and `--out <file>`), schema-tagged:
   consumer can tell a reported 0 from a filled-in omission. The attribution record's `caveats`
   are the baseline's caveats merged with every deny run and, when it ran, the combined
   additivity run, in that order, with duplicates dropped. A deny run's disclosure is not
-  discarded. A bucket absent from *both* runs is
-  outside that binary's category vocabulary and simply contributes nothing.
+  discarded. A `System tools (deferred)` bucket absent from *both* runs is a non-event (no
+  deferred pool at that binary) and simply contributes nothing. A prefix `System tools` bucket
+  absent from both runs whose row a cli-parse caveat disclosed as absent is unmeasured instead:
+  the row reports `savedTokens: null` with `comparable: false` and the reason. Remaining risk:
+  cli-parse cannot tell a deferred row lost to format drift from a binary with no deferred pool,
+  so drift on that row reads as "no deferred bucket" and the prefix delta alone is published as
+  the saving. The parser's caveat naming the absent row is the only signal.
 - `context-budget.ledger/1` is one before/after: `lever`, `emittedConfig`, `before`/`after`
   summaries, `delta` per category, `totalDelta`, `comparability` (`ok`, `systemToolsComparable`
   for the prefix bucket, `modeBinaryComparable` for the shared mode/binary checks, `reasons`).
-  A category present in only one run gets `null`, never an invented number.
+  A category present in only one run gets `null`, never an invented number, and an `unmeasured`
+  entry (`{category: reason}`) saying why. A category absent from both runs gets no `delta` key; the prefix `System tools`
+  bucket absent from both still gets an `unmeasured` entry when either run's caveats disclose its
+  row as absent.
 - `context-budget.catalogue-verify/1` is the `verify-catalogue` record: a docs-independent
   existence check. Reads the stamped binary and reports `present`/`absent` (with hit counts) for
   every settings key and env name the catalogue row names. The binary is the authority on *existence
diff --git a/plugins/context-budget/skills/audit/scripts/fixtures/context-deferred-only.md b/plugins/context-budget/skills/audit/scripts/fixtures/context-deferred-only.md
new file mode 100644
index 0000000000..a531754f0b
--- /dev/null
+++ b/plugins/context-budget/skills/audit/scripts/fixtures/context-deferred-only.md
@@ -0,0 +1,29 @@
+# Synthetic /context capture: parser test fixture only
+
+This fixture mirrors the shape headless `claude -p "/context"` was observed to print on Claude
+Code 2.1.289: a `System tools (deferred)` row and no prefix `System tools` row. Every number in it
+is invented for the test; none is a measurement, and nothing may ever be reported from this file.
+
+## Context Usage
+
+**Model:** claude-test-model  
+**Tokens:** 19.2k / 500k (4%)
+
+### Estimated usage by category
+
+| Category | Tokens | Percentage |
+|----------|--------|------------|
+| System prompt | 2.5k | 0.5% |
+| System tools (deferred) | 14k | 2.8% |
+| Custom agents | 1.1k | 0.2% |
+| Skills | 4.7k | 0.9% |
+| Messages | 42 | 0.0% |
+| Free space | 446.4k | 89.3% |
+| Autocompact buffer | 34k | 6.8% |
+
+### Skills
+
+| Skill | Source | Tokens |
+|-------|--------|--------|
+| sample-user-skill | User | ~150 |
+| example:alpha | Plugin (example) | 320 |
diff --git a/plugins/context-budget/skills/audit/scripts/measure.mjs b/plugins/context-budget/skills/audit/scripts/measure.mjs
index 600b222473..068005ea2a 100755
--- a/plugins/context-budget/skills/audit/scripts/measure.mjs
+++ b/plugins/context-budget/skills/audit/scripts/measure.mjs
@@ -280,7 +280,12 @@ function findSection(lines, heading) {
   return null;
 }
 
-function parseContextMarkdown(text) {
+// The disclosure phrase the parser writes into a caveat and compare reads back.
+function absentRowPhrase(bucket) {
+  return `"${bucket}" row absent`;
+}
+
+function parseContextMarkdown(text, { binaryVersion: version = null } = {}) {
   // Trap: unredirected stdin prepends a warning line; anything before the
   // first markdown heading is not /context output.
   const firstHeading = text.search(/^#/m);
@@ -301,9 +306,16 @@ function parseContextMarkdown(text) {
     categories[cells[0]] = tokens;
     anyRounded = anyRounded || rounded;
   }
-  if (!('System tools' in categories)) {
-    throw new ParseError('category table parsed but carries no "System tools" row — refusing to guess');
+  // No system-tool bucket at all is format drift: refuse. One bucket alone is a
+  // shape headless /context has been observed to print; the absent bucket stays
+  // absent (unmeasured, never zero-filled) and a caveat names it.
+  const missingBuckets = SYSTEM_TOOL_BUCKETS.filter((b) => !(b in categories));
+  if (missingBuckets.length === SYSTEM_TOOL_BUCKETS.length) {
+    throw new ParseError('category table parsed but carries neither a "System tools" nor a '
+      + '"System tools (deferred)" row; refusing to guess');
   }
+  const absenceCaveats = missingBuckets.map((b) => `cli-parse: ${absentRowPhrase(b)}`
+    + `${version ? ` at ${version}` : ''}; recorded as unmeasured, not zero`);
 
   const model = (text.match(/\*\*Model:\*\*\s*(\S+)/) || [])[1] ?? null;
 
@@ -331,7 +343,7 @@ function parseContextMarkdown(text) {
   // fake binary uses them so a deny run can carry a disclosure the baseline
   // does not. A real /context render has none, and unknown lines elsewhere
   // stay ignored.
-  const caveats = [];
+  const caveats = [...absenceCaveats];
   for (const line of lines) {
     const match = /^Caveat:\s+(.+)$/.exec(line);
     if (match) caveats.push(match[1].trim());
@@ -482,7 +494,8 @@ function cliSnapshot({ bin, deny, label }) {
     throw new ParseError(`headless /context failed (exit ${r.status ?? 'spawn-error'}): `
       + `${(r.stderr || String(r.error || '')).trim().slice(0, 300)}`);
   }
-  const parsed = parseContextMarkdown(r.stdout);
+  const version = binaryVersion(bin);
+  const parsed = parseContextMarkdown(r.stdout, { binaryVersion: version });
   const synthesizedZeroBuckets = [];
   // Harness-only marker; contract in the cli-parse paragraph of reference/engine.md.
   for (const match of r.stdout.matchAll(/<!--\s*synthesized-zero:\s*([^>]+?)\s*-->/g)) {
@@ -503,7 +516,7 @@ function cliSnapshot({ bin, deny, label }) {
     precision: parsed.precision,
     sessionKind: 'headless',
     label: label ?? null,
-    binary: { path: bin, version: binaryVersion(bin) },
+    binary: { path: bin, version },
     sdk: null,
     model: parsed.model,
     cwd: process.cwd(),
@@ -564,7 +577,8 @@ async function takeSnapshot(args) {
       } catch (e2) {
         degrade('measurement-failed', `sdk mode failed (${String(e).slice(0, 200)}); `
           + `cli-parse fallback also failed (${String(e2).slice(0, 200)})`,
-        'Verify the binary runs (`claude --version`) and that `claude -p "/context"` produces the category table.');
+        'Verify the binary runs (`claude --version`) and that `claude -p "/context"` produces the category table '
+        + '(from Git Bash run it as `MSYS_NO_PATHCONV=1 claude -p "/context"`, or path conversion rewrites the command).');
       }
     }
   }
@@ -575,7 +589,8 @@ async function takeSnapshot(args) {
       `@anthropic-ai/claude-agent-sdk is not resolvable (tried: ${sdkCandidates.filter(Boolean).join(', ')}) `
       + `and cli-parse failed: ${String(e).slice(0, 300)}`,
       'For exact measurement install the Agent SDK (npm install @anthropic-ai/claude-agent-sdk in a directory '
-      + 'passed as --sdk-dir). For the fallback, verify `claude -p "/context"` prints the category table at your version.');
+      + 'passed as --sdk-dir). For the fallback, verify `claude -p "/context"` prints the category table at your version '
+      + '(from Git Bash run it as `MSYS_NO_PATHCONV=1 claude -p "/context"`, or path conversion rewrites the command).');
   }
 }
 
@@ -622,11 +637,27 @@ function compareSnapshots(before, after, { lever = null, emittedConfig = null }
 
   const names = new Set([...Object.keys(before.categories || {}), ...Object.keys(after.categories || {})]);
   const delta = {};
+  const unmeasured = {};
   for (const name of names) {
     const b = before.categories?.[name];
     const a = after.categories?.[name];
-    if (typeof b === 'number' && typeof a === 'number') delta[name] = a - b;
-    else delta[name] = null; // present in one run only — never invent a number
+    if (typeof b === 'number' && typeof a === 'number') {
+      delta[name] = a - b;
+    } else {
+      // Present in one run only: never invent a number, and say why it is null.
+      delta[name] = null;
+      unmeasured[name] = `"${name}" present in only one run, so its delta is unmeasured, not zero`;
+    }
+  }
+  // The prefix bucket is the one every /context table was expected to carry,
+  // so when a run's parser disclosed its row as absent it went unmeasured,
+  // even if absent from both runs. A deferred bucket absent from both runs
+  // stays a non-event (a binary without that pool).
+  const prefix = SYSTEM_TOOL_BUCKETS[0];
+  const caveats = [...(before.caveats || []), ...(after.caveats || [])];
+  if (!names.has(prefix)
+    && caveats.some((c) => typeof c === 'string' && c.includes(absentRowPhrase(prefix)))) {
+    unmeasured[prefix] = `"${prefix}" row absent from both runs' /context tables, so its delta is unmeasured, not zero`;
   }
   const totalDelta = (typeof before.totalTokens === 'number' && typeof after.totalTokens === 'number')
     ? after.totalTokens - before.totalTokens : null;
@@ -644,6 +675,7 @@ function compareSnapshots(before, after, { lever = null, emittedConfig = null }
     before: summarize(before),
     after: summarize(after),
     delta,
+    unmeasured,
     totalDelta,
     comparability: {
       ok: reasons.length === 0,
@@ -667,18 +699,22 @@ function compareSnapshots(before, after, { lever = null, emittedConfig = null }
 //   number     measured in both runs — use it;
 //   null       present in one run only (a deny can empty a bucket out of the
 //              snapshot entirely) — a missing measurement, NEVER zero;
-//   undefined  absent from both runs — outside this binary's category
-//              vocabulary, a non-event that contributes nothing.
-// `saved` is null when any needed bucket vanished; the record is then
-// published as incomparable with the vanished buckets named in `reasons`,
+//   undefined  absent from both runs. For the deferred bucket that is a
+//              non-event (no deferred pool at this binary) contributing
+//              nothing. For the prefix bucket a parser-disclosed absent row
+//              lands in cmp.unmeasured and is unmeasured like the null case.
+// `saved` is null when any needed bucket is unmeasured; the record is then
+// published as incomparable with the unmeasured buckets named in `reasons`,
 // never coerced to 0.
 function systemBucketSaving(cmp) {
-  const vanished = SYSTEM_TOOL_BUCKETS.filter((b) => b in cmp.delta && cmp.delta[b] === null);
+  const unmeasured = cmp.unmeasured || {};
+  const vanished = SYSTEM_TOOL_BUCKETS.filter((b) => b in unmeasured
+    || (b in cmp.delta && cmp.delta[b] === null));
   return {
     saved: vanished.length ? null : -SYSTEM_TOOL_BUCKETS.reduce((s, b) => s + (cmp.delta[b] ?? 0), 0),
     comparable: cmp.comparability.systemToolsComparable && !vanished.length,
     reasons: vanished.length
-      ? [...cmp.comparability.reasons, vanishedReason(vanished)]
+      ? [...cmp.comparability.reasons, ...vanished.map((b) => unmeasured[b] ?? vanishedReason([b]))]
       : cmp.comparability.reasons,
   };
 }
@@ -712,8 +748,9 @@ function withinAdditivityEpsilon(combinedSaved, sumOfParts) {
 function bucketAdditivity(rows, cmp, synthesized) {
   const perBucket = {};
   for (const bucket of SYSTEM_TOOL_BUCKETS) {
-    // A bucket absent from BOTH runs is outside this binary's category
-    // vocabulary: a non-event, so it gets no verdict row at all.
+    // A bucket absent from BOTH runs gets no verdict row at all: for the
+    // deferred bucket a non-event, for the prefix bucket unmeasured (the
+    // per-tool rows already carry that as savedTokens null).
     if (!(bucket in cmp.delta)) continue;
     const parts = rows.map((r) => r[BUCKET_ROW_FIELD[bucket]]);
     const sumOfParts = parts.some((d) => typeof d !== 'number')
diff --git a/plugins/context-budget/skills/audit/scripts/measure.test.sh b/plugins/context-budget/skills/audit/scripts/measure.test.sh
index 8cced0187d..a793cf772c 100755
--- a/plugins/context-budget/skills/audit/scripts/measure.test.sh
+++ b/plugins/context-budget/skills/audit/scripts/measure.test.sh
@@ -76,6 +76,9 @@ if ! command -v node >/dev/null 2>&1; then
 fi
 
 WORK="$(mktemp -d)"
+# Git Bash hands node a POSIX /tmp path inside JS source strings unconverted;
+# a mixed-form path reads on both sides.
+if command -v cygpath >/dev/null 2>&1; then WORK="$(cygpath -m "$WORK")"; fi
 cleanup() { rm -rf "$WORK"; }
 trap cleanup EXIT
 
@@ -91,7 +94,9 @@ jsonmutate() {
 }
 
 # write_snapshot <file> <mode> <version> <signature> <systemtools> <skilltokens>
-# Minimal but schema-valid snapshot record for compare tests.
+# Minimal but schema-valid snapshot record for compare tests. The deferred
+# bucket is the literal 1000 in every record, which is why two of them compare
+# with a deferred delta of 0 (the dA/dB test below).
 write_snapshot() {
   printf '{"schema":"context-budget.snapshot/1","timestampUtc":"2026-01-01T00:00:00Z","mode":"%s","precision":"exact","label":null,"deny":[],"binary":{"path":"/opt/fake/claude","version":"%s"},"categories":{"System tools":%s,"System tools (deferred)":1000,"Skills":%s},"totalTokens":%s,"skillListing":{"signature":"%s","tokens":%s,"rows":3}}\n' \
     "$2" "$3" "$5" "$6" "$5" "$4" "$6" >"$1"
@@ -157,6 +162,41 @@ assert_degrade "$WORK/norow-out.json" 'System tools' \
   "missing System tools row: expected exit 3 naming the row" \
   node "$ENGINE" parse-context --file "$WORK/norow.md"
 
+# --- parse-context: one system-tool bucket alone parses --------------------
+
+# Deferred-only shape (observed on headless Claude Code 2.1.289). Expected
+# values come from the fixture's own cells: 14k deferred, 2.5k system prompt.
+donly="$WORK/deferred-only.json"
+if node "$ENGINE" parse-context --file "$SCRIPT_DIR/fixtures/context-deferred-only.md" --out "$donly" >/dev/null; then
+  ok "deferred-only table exits 0"
+  assert_eq "$(jsonget "$donly" '"System tools" in j.categories')" "false" \
+    "absent System tools row stays absent (unmeasured, not zero-filled)" "absent System tools row was filled in"
+  assert_eq "$(jsonget "$donly" 'j.categories["System tools (deferred)"]')" "14000" \
+    "deferred row 14k parses to 14000" "deferred row misparsed"
+  assert_eq "$(jsonget "$donly" 'j.categories["System prompt"]')" "2500" \
+    "other categories still parse alongside a missing bucket" "other categories lost"
+  assert_eq "$(jsonget "$donly" 'Object.keys(j.categories).length')" "7" \
+    "every category row in the fixture is reported" "category count wrong"
+  assert_eq "$(jsonget "$donly" 'j.caveats.some((c)=>c.includes("\"System tools\" row absent") && c.includes("unmeasured"))')" "true" \
+    "a caveat names the missing System tools row" "missing-row caveat absent"
+else
+  fail "deferred-only table did not parse"
+fi
+
+# Prefix-only shape: the deferred row is the absent one.
+printf '## Context Usage\n\n### Estimated usage by category\n\n| Category | Tokens | Percentage |\n|---|---|---|\n| System tools | 3.0k | 1.0%% |\n| Messages | 10 | 0.0%% |\n' >"$WORK/prefix-only.md"
+ponly="$WORK/prefix-only.json"
+if node "$ENGINE" parse-context --file "$WORK/prefix-only.md" --out "$ponly" >/dev/null; then
+  assert_eq "$(jsonget "$ponly" 'j.categories["System tools"]')" "3000" \
+    "prefix-only table parses its System tools row" "prefix-only System tools misparsed"
+  assert_eq "$(jsonget "$ponly" '"System tools (deferred)" in j.categories')" "false" \
+    "absent deferred row stays absent" "absent deferred row was filled in"
+  assert_eq "$(jsonget "$ponly" 'j.caveats.some((c)=>c.includes("\"System tools (deferred)\" row absent"))')" "true" \
+    "a caveat names the missing deferred row" "missing deferred-row caveat absent"
+else
+  fail "prefix-only table did not parse"
+fi
+
 # --- compare: identical runs are comparable, deltas are zero --------------
 
 write_snapshot "$WORK/a.json" sdk 9.9.9 sigAAAA 5000 2000
@@ -216,6 +256,26 @@ assert_eq "$(jsonget "$WORK/row-skills.json" 'j.comparability.modeBinaryComparab
   "Skills-token drift does not poison the shared mode/binary predicate" \
   "Skills-token drift wrongly flipped modeBinaryComparable"
 
+# --- compare: a bucket missing from a cli-parse snapshot -------------------
+
+jsonmutate "$WORK/a.json" "$WORK/dA.json" 'delete j.categories["System tools"]'
+jsonmutate "$WORK/b.json" "$WORK/dB.json" 'delete j.categories["System tools"]'
+node "$ENGINE" compare --before "$WORK/dA.json" --after "$WORK/dB.json" --out "$WORK/row-donly.json" >/dev/null
+assert_eq "$(jsonget "$WORK/row-donly.json" '"System tools" in j.delta')" "false" \
+  "two deferred-only snapshots yield no System tools delta row" "System tools delta invented for two deferred-only runs"
+assert_eq "$(jsonget "$WORK/row-donly.json" 'j.delta["System tools (deferred)"]')" "0" \
+  "the measured deferred bucket still compares" "deferred delta lost between deferred-only runs"
+node "$ENGINE" compare --before "$WORK/dA.json" --after "$WORK/b.json" --out "$WORK/row-mixed.json" >/dev/null
+assert_eq "$(jsonget "$WORK/row-mixed.json" 'j.delta["System tools"]')" "null" \
+  "deferred-only vs full snapshot yields a null System tools delta, never 0" "one-sided System tools delta not null"
+if [[ "$(jsonget "$WORK/row-mixed.json" 'j.unmeasured["System tools"]')" == *"only one run"* ]]; then
+  ok "the null System tools delta carries a reason"
+else
+  fail "null System tools delta has no reason"
+fi
+assert_eq "$(jsonget "$WORK/row-self.json" 'Object.keys(j.unmeasured).length')" "0" \
+  "fully measured runs carry no unmeasured reasons" "unmeasured reasons on a fully measured compare"
+
 # --- emit: --out creates missing parent directories -----------------------
 
 deepout="$WORK/fresh/data/dir/parsed.json"
@@ -297,7 +357,9 @@ if (mode === 'nonadd') prefixSaved['AlphaTool+BetaTool'] = 1200;
 // saturate — combined prefix numbers would add, but the run is marked a
 // synthesized zero. The verdict must be unmeasured, not the true the
 // arithmetic would publish.
-const table = { 'System tools': 18000 - (prefixSaved[key] ?? 0) };
+// noprefix: the observed headless shape with no prefix System tools row.
+const table = {};
+if (mode !== 'noprefix') table['System tools'] = 18000 - (prefixSaved[key] ?? 0);
 // The deferred bucket is dropped (omitted, not reported as 0) when:
 //   novocab      — this fake "version" has no deferred bucket in any run;
 //   vanish       — the combined deny empties it out of the snapshot (#3197);
@@ -706,6 +768,49 @@ assert_degrade "$WORK/nobin.json" 'binary-not-found' \
   "missing --binary: expected exit 3 + binary-not-found" \
   node "$ENGINE" snapshot --binary "$WORK/does-not-exist"
 
+# Headless /context with no prefix System tools row (the 2.1.289 shape) and no
+# Agent SDK: snapshot must return a cli-parse record, not exit 3.
+snapnp="$WORK/snap-noprefix.json"
+if (cd "$WORK" && FAKE_MODE=noprefix node "$ENGINE" snapshot --binary "$FAKE" --out "$snapnp" >/dev/null); then
+  assert_eq "$(jsonget "$snapnp" 'j.mode')" "cli-parse" \
+    "snapshot without a System tools row returns a cli-parse record" "snapshot mode wrong"
+  assert_eq "$(jsonget "$snapnp" '"System tools" in j.categories')" "false" \
+    "snapshot leaves the absent System tools bucket out" "snapshot filled the absent System tools bucket"
+  assert_eq "$(jsonget "$snapnp" 'j.caveats.some((c)=>c.includes("\"System tools\" row absent at 9.9.9"))')" "true" \
+    "snapshot caveat names the missing row and the binary version" "snapshot caveat missing row or version"
+else
+  fail "snapshot exited nonzero on a table without a System tools row"
+fi
+
+# Two such snapshots compared: the prefix bucket is absent from both, but the
+# parser disclosed it, so the ledger row must say it went unmeasured. Both
+# runs print the same deferred cell (12000), so that delta is 0.
+snapnp2="$WORK/snap-noprefix-2.json"
+(cd "$WORK" && FAKE_MODE=noprefix node "$ENGINE" snapshot --binary "$FAKE" --out "$snapnp2" >/dev/null)
+node "$ENGINE" compare --before "$snapnp" --after "$snapnp2" --out "$WORK/row-noprefix.json" >/dev/null
+assert_eq "$(jsonget "$WORK/row-noprefix.json" '"System tools" in j.delta')" "false" \
+  "disclosed-absent bucket gets no invented delta" "delta invented for a bucket absent from both runs"
+assert_eq "$(jsonget "$WORK/row-noprefix.json" 'typeof j.unmeasured["System tools"]')" "string" \
+  "disclosed-absent bucket is listed in unmeasured with a reason" "ledger hides the unmeasured System tools bucket"
+assert_eq "$(jsonget "$WORK/row-noprefix.json" 'j.delta["System tools (deferred)"]')" "0" \
+  "the measured deferred bucket still compares" "deferred delta wrong between noprefix runs"
+
+# Attribution over the same shape: the deferred side moves by 400 (12000 vs
+# 11600 with AlphaTool denied), but with the prefix bucket unmeasured the
+# saving is null and the row incomparable, never 400 with the prefix as 0.
+anp="$WORK/attr-noprefix.json"
+if attr noprefix "$anp" --tools AlphaTool; then
+  assert_eq "$(jsonget "$anp" 'j.perTool[0].deferredDelta')" "-400" \
+    "deferred delta is still measured when the prefix bucket is absent" "deferred delta lost"
+  assert_eq "$(jsonget "$anp" 'j.perTool[0].savedTokens')" "null" \
+    "unmeasured prefix bucket makes savedTokens null, not the deferred side alone" \
+    "unmeasured prefix bucket counted as zero in savedTokens"
+  assert_eq "$(jsonget "$anp" 'j.perTool[0].comparable')" "false" \
+    "unmeasured prefix bucket marks the row incomparable" "row with an unmeasured prefix bucket published comparable"
+else
+  fail "attribute (noprefix scenario) exited nonzero"
+fi
+
 # --- summary ---------------------------------------------------------------
 
 echo
diff --git a/plugins/context-guard/.claude-plugin/plugin.json b/plugins/context-guard/.claude-plugin/plugin.json
index 00158482d5..c90f4b5bd0 100644
--- a/plugins/context-guard/.claude-plugin/plugin.json
+++ b/plugins/context-guard/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "context-guard",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Per-session context-window observability. A mod writes each session's context-window figures to a snapshot file and tells Claude its context zone (smart, acceptable or dumb, from bands in zones.json) at each crossing, approach and compaction; the person gets a toast and a transcript line. /context-guard prints status and toggles an optional band row. It answers a status tool. Optional blocking mode gates new mutating work in a blocked zone, except handoffs. A PostCompact hook leaves a marker.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/context-guard/CHANGELOG.md b/plugins/context-guard/CHANGELOG.md
index 36683c0e94..f24b771fa4 100644
--- a/plugins/context-guard/CHANGELOG.md
+++ b/plugins/context-guard/CHANGELOG.md
@@ -5,6 +5,13 @@ All notable changes to the `context-guard` plugin.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.13.2] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.13.1] - 2026-10-04
 
 ### Changed
diff --git a/plugins/context-guard/hooks/exec-bash.mjs b/plugins/context-guard/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/context-guard/hooks/exec-bash.mjs
+++ b/plugins/context-guard/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/context-guard/hooks/hooks.json b/plugins/context-guard/hooks/hooks.json
index 568337647b..2edf2b6cb0 100644
--- a/plugins/context-guard/hooks/hooks.json
+++ b/plugins/context-guard/hooks/hooks.json
@@ -4,6 +4,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/desktop-notification/.claude-plugin/plugin.json b/plugins/desktop-notification/.claude-plugin/plugin.json
index 254cd22171..5018db64ad 100644
--- a/plugins/desktop-notification/.claude-plugin/plugin.json
+++ b/plugins/desktop-notification/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "desktop-notification",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "Alert you when Claude Code needs input: an audible terminal bell, an OSC 9 terminal notification, and an OS-native toast (macOS/Linux) on permission and idle prompts.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/desktop-notification/CHANGELOG.md b/plugins/desktop-notification/CHANGELOG.md
index 633d055b94..4aa2d226c4 100644
--- a/plugins/desktop-notification/CHANGELOG.md
+++ b/plugins/desktop-notification/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `desktop-notification` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.8.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.8.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/desktop-notification/hooks/exec-bash.mjs b/plugins/desktop-notification/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/desktop-notification/hooks/exec-bash.mjs
+++ b/plugins/desktop-notification/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/desktop-notification/hooks/hooks.json b/plugins/desktop-notification/hooks/hooks.json
index 91deb97285..971746aa53 100644
--- a/plugins/desktop-notification/hooks/hooks.json
+++ b/plugins/desktop-notification/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/disk-hygiene/.claude-plugin/plugin.json b/plugins/disk-hygiene/.claude-plugin/plugin.json
index 549e47dcc4..aa8e6f763d 100644
--- a/plugins/disk-hygiene/.claude-plugin/plugin.json
+++ b/plugins/disk-hygiene/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "disk-hygiene",
-  "version": "0.43.8",
+  "version": "0.43.9",
   "description": "Context-aware disk hygiene for arbitrary directory trees: inventories orphaned and temporary artifacts, classifies evidence into review tiers, and offers exact-path cleanup only after a fresh safety preview and explicit per-tier approval. The target is read-only by default; OS-managed paths, links and mount points, VCS-tracked content without the complete checkout evidence bundle, changed entries, and live-handle uncertainty fail closed.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/disk-hygiene/CHANGELOG.md b/plugins/disk-hygiene/CHANGELOG.md
index c6e532d0ea..6bad318e23 100644
--- a/plugins/disk-hygiene/CHANGELOG.md
+++ b/plugins/disk-hygiene/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `disk-hygiene` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.43.9] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.43.8] - 2026-10-04
 
 ### Changed
diff --git a/plugins/disk-hygiene/hooks/exec-bash.mjs b/plugins/disk-hygiene/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/disk-hygiene/hooks/exec-bash.mjs
+++ b/plugins/disk-hygiene/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/disk-hygiene/hooks/hooks.json b/plugins/disk-hygiene/hooks/hooks.json
index 4a29215067..7adc313e77 100644
--- a/plugins/disk-hygiene/hooks/hooks.json
+++ b/plugins/disk-hygiene/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/eol-normalizer/.claude-plugin/plugin.json b/plugins/eol-normalizer/.claude-plugin/plugin.json
index efd0f1769c..a65bea4958 100644
--- a/plugins/eol-normalizer/.claude-plugin/plugin.json
+++ b/plugins/eol-normalizer/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "eol-normalizer",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Normalize a written file's working-tree line endings to its .gitattributes eol value on edit: symmetric CRLF/LF driven by git check-attr, advisory and never blocking.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/eol-normalizer/CHANGELOG.md b/plugins/eol-normalizer/CHANGELOG.md
index 0d402612c2..f6a4902625 100644
--- a/plugins/eol-normalizer/CHANGELOG.md
+++ b/plugins/eol-normalizer/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `eol-normalizer` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.9.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.9.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/eol-normalizer/hooks/exec-bash.mjs b/plugins/eol-normalizer/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/eol-normalizer/hooks/exec-bash.mjs
+++ b/plugins/eol-normalizer/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/eol-normalizer/hooks/hooks.json b/plugins/eol-normalizer/hooks/hooks.json
index 25a22ee91d..d24a283ab4 100644
--- a/plugins/eol-normalizer/hooks/hooks.json
+++ b/plugins/eol-normalizer/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/explainer-video/.claude-plugin/plugin.json b/plugins/explainer-video/.claude-plugin/plugin.json
index 2f6a6e64c0..ca5d6eb000 100644
--- a/plugins/explainer-video/.claude-plugin/plugin.json
+++ b/plugins/explainer-video/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "explainer-video",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Short explainer videos made with ManimCE, narrated when the speech plugin is installed and silent otherwise. The produce skill plans the beats, writes one scene script whose scene changes follow the narration's word timings, renders at low quality first, muxes narration and captions with ffmpeg, and checks every render with ffprobe and a frame read-back. A SessionStart hook installs the hash-locked Python packages; the check skill reports readiness.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/explainer-video/CHANGELOG.md b/plugins/explainer-video/CHANGELOG.md
index a3ee7cd43a..e708d1ede1 100644
--- a/plugins/explainer-video/CHANGELOG.md
+++ b/plugins/explainer-video/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to the `explainer-video` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.2.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
+### Fixed
+
+- The `pydeps.py` helper is now passed to native Python as a Windows path (#6250).
+
 ## [0.2.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/explainer-video/hooks/exec-bash.mjs b/plugins/explainer-video/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/explainer-video/hooks/exec-bash.mjs
+++ b/plugins/explainer-video/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/explainer-video/hooks/hooks.json b/plugins/explainer-video/hooks/hooks.json
index d1a886998d..b781518f7d 100644
--- a/plugins/explainer-video/hooks/hooks.json
+++ b/plugins/explainer-video/hooks/hooks.json
@@ -17,6 +17,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/explainer-video/hooks/install-python-deps.sh b/plugins/explainer-video/hooks/install-python-deps.sh
index 9d6360783b..a5b43d4e1c 100755
--- a/plugins/explainer-video/hooks/install-python-deps.sh
+++ b/plugins/explainer-video/hooks/install-python-deps.sh
@@ -83,7 +83,30 @@ repair_line() {
   esac
 }
 
-if ! out="$("$py" "$ROOT/scripts/pydeps.py" install --data-dir "$data" </dev/null 2>&1)"; then
+# to_native <path> -> the path as a native Windows Python reads it. Under Git Bash or Cygwin a POSIX
+# path (/c/...) goes through cygpath -m: a session with MSYS path conversion switched off hands it
+# over as is, and Python resolves it against the current drive (C:\c\...). Fails rather than
+# return the unconverted path.
+to_native() {
+  case "${OSTYPE:-}" in
+  msys* | cygwin*)
+    [[ "$1" == /* ]] || {
+      printf '%s' "$1"
+      return 0
+    }
+    local converted
+    converted="$(cygpath -m "$1" 2>/dev/null)" && [[ -n "$converted" ]] && printf '%s' "$converted"
+    ;;
+  *) printf '%s' "$1" ;;
+  esac
+}
+
+if ! script="$(to_native "$ROOT/scripts/pydeps.py")" || ! data_dir="$(to_native "$data")"; then
+  notice "explainer-video: cygpath could not convert its pydeps.py or data directory path to Windows form, so ManimCE is not installed and /explainer-video:produce will stop. Check that cygpath runs in Git Bash and start a new session."
+  exit 0
+fi
+
+if ! out="$("$py" "$script" install --data-dir "$data_dir" </dev/null 2>&1)"; then
   if [[ "$out" == *Traceback* ]]; then
     last="${out//$'\r'/}"
     last="${last##*$'\n'}"
diff --git a/plugins/explainer-video/hooks/install-python-deps.test.sh b/plugins/explainer-video/hooks/install-python-deps.test.sh
index 8fc88528f7..e49af89353 100755
--- a/plugins/explainer-video/hooks/install-python-deps.test.sh
+++ b/plugins/explainer-video/hooks/install-python-deps.test.sh
@@ -169,6 +169,45 @@ else
   fail "no python: rc=$rc output=[$out]"
 fi
 
+# Native Windows Python under Git Bash or Cygwin: pydeps.py and a POSIX data directory reach it as drive-letter
+# paths even with MSYS path conversion switched off, and a cygpath that fails is a notice, never the unconverted
+# path. The stub python3 logs its arguments; the stub cygpath maps -m /dir to C:/dir, or fails.
+# native_hook <ostype> <cygpath body> -> runs the hook with MSYS_NO_PATHCONV=1 and a POSIX data directory; sets OUT,
+# RC and ARGV.
+# shellcheck disable=SC2016  # the stub bodies expand when the stubs run, not here
+native_hook() {
+  local stubs="$WORK/stubs-$1"
+  mkdir -p "$stubs"
+  printf '#!/bin/sh\n[ "$1" = -c ] && exit 0\nprintf "%%s|" "$@" >"%s/argv.log"\n' "$WORK" >"$stubs/python3"
+  printf '#!/bin/sh\n%s\n' "$2" >"$stubs/cygpath"
+  chmod +x "$stubs/python3" "$stubs/cygpath"
+  rm -f "$WORK/argv.log"
+  OUT="$(env PATH="$stubs:$tools" OSTYPE="$1" MSYS_NO_PATHCONV=1 CLAUDE_PLUGIN_DATA="$WORK/data-native" "$tools/bash" "$root/hooks/install-python-deps.sh" <<<'{}')"
+  RC=$?
+  ARGV="$(cat "$WORK/argv.log" 2>/dev/null)"
+}
+# shellcheck disable=SC2016  # the stub body expands when the stub runs, not here
+for ostype in msys cygwin; do
+  native_hook "$ostype" '[ "$1" = -m ] && printf "C:%s\n" "$2"'
+  if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "C:$root/scripts/pydeps.py|install|--data-dir|C:$WORK/data-native|" ]]; then
+    ok "OSTYPE=$ostype with path conversion off hands Python drive-letter pydeps.py and data directory paths"
+  else
+    fail "OSTYPE=$ostype conversion: rc=$RC argv=[$ARGV] output=[$OUT]"
+  fi
+done
+native_hook msys 'exit 1'
+if [[ "$RC" -eq 0 && -z "$ARGV" && "$OUT" == *'"systemMessage"'* && "$OUT" == *'cygpath could not convert'* ]]; then
+  ok "a failing cygpath is a notice and Python never gets the unconverted path"
+else
+  fail "failing cygpath: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+native_hook linux-gnu 'exit 1'
+if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "$root/scripts/pydeps.py|install|--data-dir|$WORK/data-native|" ]]; then
+  ok "outside Git Bash and Cygwin the paths reach Python unchanged"
+else
+  fail "linux paths: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+
 # Only the py launcher (a python.org install without "Add python.exe to PATH"): under Git Bash or Cygwin the
 # hook asks it only to list (py -0p) and starts pydeps.py with a listed python.exe, never through py, which
 # installs the latest Python on any launch command while none is installed; elsewhere `py` is not taken for Python.
diff --git a/plugins/go-format/.claude-plugin/plugin.json b/plugins/go-format/.claude-plugin/plugin.json
index 58f3d74277..a8099e2069 100644
--- a/plugins/go-format/.claude-plugin/plugin.json
+++ b/plugins/go-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "go-format",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Auto-fix Go formatting and import management on edit via goimports. Runs unconditionally (no consumer-config gate), skipping generated files.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/go-format/CHANGELOG.md b/plugins/go-format/CHANGELOG.md
index f22ec468a0..0352f0b551 100644
--- a/plugins/go-format/CHANGELOG.md
+++ b/plugins/go-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `go-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.5.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.5.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/go-format/hooks/exec-bash.mjs b/plugins/go-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/go-format/hooks/exec-bash.mjs
+++ b/plugins/go-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/go-format/hooks/hooks.json b/plugins/go-format/hooks/hooks.json
index 04f1a33cc3..68f3f1c7f8 100644
--- a/plugins/go-format/hooks/hooks.json
+++ b/plugins/go-format/hooks/hooks.json
@@ -21,6 +21,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -38,6 +39,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/guardrails/.claude-plugin/plugin.json b/plugins/guardrails/.claude-plugin/plugin.json
index 781ebf0c57..d67c603f6d 100644
--- a/plugins/guardrails/.claude-plugin/plugin.json
+++ b/plugins/guardrails/.claude-plugin/plugin.json
@@ -170,5 +170,5 @@
       "min": 1
     }
   },
-  "version": "0.47.8"
+  "version": "0.47.9"
 }
diff --git a/plugins/guardrails/CHANGELOG.md b/plugins/guardrails/CHANGELOG.md
index d39cc7fc2c..dc27b55721 100644
--- a/plugins/guardrails/CHANGELOG.md
+++ b/plugins/guardrails/CHANGELOG.md
@@ -3,6 +3,14 @@
 All notable changes to the `guardrails` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.47.9] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The verify rows start the launcher with `--skip-if-all-false` over the three verifier options, so an edit with all three verifiers off starts node only and no bash (#6252). A test fails if a PreToolUse or `block-*` guard row carries a skip flag.
+- The shared `exec-bash.mjs` launcher copy also gains `--skip-unless-stdin-contains`; no guardrails row uses it (#6253).
+
 ## [0.47.8] - 2026-10-04
 
 ### Changed
diff --git a/plugins/guardrails/README.md b/plugins/guardrails/README.md
index df70a3398e..f761fcad97 100644
--- a/plugins/guardrails/README.md
+++ b/plugins/guardrails/README.md
@@ -1264,6 +1264,12 @@ others.
 | workflow-resilience-check | `workflow_resilience_check_enabled` |
 | flag-commit-pr-skill-bypass | `flag_commit_pr_skill_bypass_enabled` |
 
+Hook cost of the three verifiers: their PostToolUse rows (`.md`, `.sh`, `.bash`, `.ps1`,
+`.psm1` edits) carry the launcher gate `--skip-if-all-false` over all three switches. With
+`cli_flag_verify_enabled`, `skill_reference_verify_enabled` and `stale_path_verify_enabled` all
+`false`, an edit starts node only, never bash. Any other value, one switch left on included, runs
+the row as before, and each verifier still checks its own switch.
+
 Set them interactively with `/plugin configure guardrails@<marketplace>`, or headless on the
 install command:
 
diff --git a/plugins/guardrails/hooks/exec-bash.mjs b/plugins/guardrails/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/guardrails/hooks/exec-bash.mjs
+++ b/plugins/guardrails/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/guardrails/hooks/exec-bash.test.sh b/plugins/guardrails/hooks/exec-bash.test.sh
index b9e7f69abd..8c88da7285 100755
--- a/plugins/guardrails/hooks/exec-bash.test.sh
+++ b/plugins/guardrails/hooks/exec-bash.test.sh
@@ -76,6 +76,13 @@ while IFS= read -r row; do
     workflow=$((workflow + 1))
   else
     second=$(jq -r '.args[1]' <<<"$row")
+    # The verify rows skip bash when all three verifiers are switched off.
+    if [[ "$second" == "--skip-if-all-false" ]]; then
+      names=$(jq -r '.args[2]' <<<"$row")
+      [[ "$names" == "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED" ]] ||
+        fail "verify gate names $names, not the three verifier switches"
+      second=$(jq -r '.args[3]' <<<"$row")
+    fi
     [[ "$second" == *"/hooks/run-guards.sh" ]] || fail "args[1] is not run-guards.sh: $second"
     dispatcher=$((dispatcher + 1))
   fi
@@ -83,6 +90,41 @@ done <<<"$rows"
 [[ "$dispatcher" -ge 8 ]] || fail "expected the dispatcher rows, found $dispatcher"
 [[ "$workflow" -eq 1 ]] || fail "expected one workflow row, found $workflow"
 
+# --- no launcher skip flag on a blocking row ----------------------------------
+# A --skip-* launcher flag decides in node, before any guard runs, that a row
+# has nothing to do. On a PreToolUse row, or a row that runs a block-* guard,
+# that would let a launcher edit switch a blocking guard off.
+skips_on_blocking() { # <hooks.json> -> one line per offending row
+  jq -r '.hooks | to_entries[] | .key as $event | .value[] | .hooks[]
+    | select(.args != null)
+    | select(any(.args[]; startswith("--skip-")))
+    | select($event == "PreToolUse" or any(.args[]; test("(^|/)block-[^/]*\\.sh$")))
+    | "\($event): \(.args | join(" "))"' "$1"
+}
+offenders=$(skips_on_blocking "$HOOKS_JSON") || fail "could not read $HOOKS_JSON"
+[[ -z "$offenders" ]] || fail "a blocking row carries a launcher skip flag: $offenders"
+
+bad_json="$TEST_TMPDIR/blocking-skip.json"
+cat >"$bad_json" <<'EOF'
+{"hooks": {
+  "PreToolUse": [{"matcher": "Bash", "hooks": [{"type": "command", "command": "node",
+    "args": ["${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs", "--skip-if-all-false", "BLOCK_NO_VERIFY_ENABLED",
+      "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh", "block-no-verify.sh"]}]}],
+  "PostToolUse": [{"matcher": "Write|Edit", "hooks": [
+    {"type": "command", "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs", "--skip-unless-stdin-contains", "x",
+        "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh", "block-credential-read.sh"]},
+    {"type": "command", "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs", "--skip-if-all-false", "CLI_FLAG_VERIFY_ENABLED",
+        "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh", "cli-flag-verify.sh"]}]}]
+}}
+EOF
+caught=$(skips_on_blocking "$bad_json") || fail "could not read the blocking-skip fixture"
+[[ "$(grep -c . <<<"$caught")" -eq 2 ]] || fail "expected 2 blocking rows with a skip flag, got: $caught"
+grep -q '^PreToolUse: .*block-no-verify\.sh$' <<<"$caught" || fail "PreToolUse skip row not caught: $caught"
+grep -q '^PostToolUse: .*block-credential-read\.sh$' <<<"$caught" || fail "block-* skip row not caught: $caught"
+grep -q 'cli-flag-verify' <<<"$caught" && fail "an advisory verify row was flagged: $caught"
+
 # --- SessionStart node notice: shell form, needs no node ---------------------
 # The row's behavior, with and without node and under PowerShell, is run by
 # scripts/node-notice-rows.test.sh; this pins that guardrails keeps it shell form.
diff --git a/plugins/guardrails/hooks/hooks.json b/plugins/guardrails/hooks/hooks.json
index ac94fcddef..3366cc5661 100644
--- a/plugins/guardrails/hooks/hooks.json
+++ b/plugins/guardrails/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -108,6 +109,8 @@
             "command": "node",
             "args": [
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
+              "--skip-if-all-false",
+              "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED",
               "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh",
               "cli-flag-verify.sh",
               "skill-reference-verify.sh",
@@ -122,6 +125,8 @@
             "command": "node",
             "args": [
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
+              "--skip-if-all-false",
+              "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED",
               "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh",
               "cli-flag-verify.sh",
               "skill-reference-verify.sh",
@@ -136,6 +141,8 @@
             "command": "node",
             "args": [
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
+              "--skip-if-all-false",
+              "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED",
               "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh",
               "cli-flag-verify.sh",
               "skill-reference-verify.sh",
@@ -150,6 +157,8 @@
             "command": "node",
             "args": [
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
+              "--skip-if-all-false",
+              "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED",
               "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh",
               "cli-flag-verify.sh",
               "skill-reference-verify.sh",
@@ -164,6 +173,8 @@
             "command": "node",
             "args": [
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
+              "--skip-if-all-false",
+              "CLI_FLAG_VERIFY_ENABLED,SKILL_REFERENCE_VERIFY_ENABLED,STALE_PATH_VERIFY_ENABLED",
               "${CLAUDE_PLUGIN_ROOT}/hooks/run-guards.sh",
               "cli-flag-verify.sh",
               "skill-reference-verify.sh",
diff --git a/plugins/harness-ops/.claude-plugin/plugin.json b/plugins/harness-ops/.claude-plugin/plugin.json
index 99b4b03c88..3c39536b4c 100644
--- a/plugins/harness-ops/.claude-plugin/plugin.json
+++ b/plugins/harness-ops/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "harness-ops",
-  "version": "3.8.4",
+  "version": "3.8.5",
   "description": "Claude Code operations: audit-skill-visibility (skills the listing budget hides), inventory (all commands, skills, agents, tools, plugins), audit-install-state (~/.claude), audit-performance (slowness), audit-native-overlap (skills duplicating built-ins), observability (telemetry), known-issues (Claude bugs, status), changelog, prerequisites, check, machine-profile, plugins (update the fleet), morning-brief, lanes (background loop sessions), setup. Plus opt-in hook event logs.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/harness-ops/CHANGELOG.md b/plugins/harness-ops/CHANGELOG.md
index 16a7106505..cbcae7cadb 100644
--- a/plugins/harness-ops/CHANGELOG.md
+++ b/plugins/harness-ops/CHANGELOG.md
@@ -3,6 +3,22 @@
 All notable changes to the `harness-ops` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [3.8.5] - 2026-10-04
+
+### Added
+
+- `/harness-ops:audit-performance` ranks dead-parent processes by CPU time in its kernel-leak census (#6249).
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
+### Fixed
+
+- A stale hook config now prints a notice that names it and suggests `/reload-plugins` (#6247).
+- The latency action names a route when it cannot evaluate (#6259).
+
 ## [3.8.4] - 2026-10-04
 
 ### Changed
diff --git a/plugins/harness-ops/README.md b/plugins/harness-ops/README.md
index f2a8d63852..bee73b903a 100644
--- a/plugins/harness-ops/README.md
+++ b/plugins/harness-ops/README.md
@@ -114,6 +114,19 @@ plugin, not in the plugin it might report on, deliberately: an in-plugin
 detector shares its plugin's registration form and dies with it, which is
 exactly how disk-hygiene's guard monitor missed the #1416 incident class.
 
+Each failure record is classed one of four ways, and the warning gives each
+class its own diagnosis and remedy:
+
+- **launch failure**: stderr carries an exec-failure signature; the hook never
+  ran.
+- **stale config**: exit 127 and the whole stderr is bash's missing-script line
+  (`bash: <path>: No such file or directory`). The session still runs hook
+  config it loaded before a plugin update or an in-place edit deleted that
+  script; the remedy is `/reload-plugins`, or a restart.
+- **ambiguous**: exit 126 or 127 with neither of the above, so the registered
+  command and the hook's own commands are both suspects.
+- **completed non-zero exit**: the hook ran and failed.
+
 Its budget share is stated as a **process count**, not a duration, and the host
 is the reason. The [hook-budget
 convention](../../docs/conventions/hook-budget/README.md) states each
diff --git a/plugins/harness-ops/hooks/exec-bash.mjs b/plugins/harness-ops/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/harness-ops/hooks/exec-bash.mjs
+++ b/plugins/harness-ops/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/harness-ops/hooks/hook-failure-audit.sh b/plugins/harness-ops/hooks/hook-failure-audit.sh
index 64e961c989..470392560d 100755
--- a/plugins/harness-ops/hooks/hook-failure-audit.sh
+++ b/plugins/harness-ops/hooks/hook-failure-audit.sh
@@ -14,7 +14,7 @@
 # kills a watched plugin's launch path does not take the detector with it. It
 # also covers the stale-session window no source-side gate can reach: hook
 # config is loaded at session start, so a session running when a fix lands on
-# disk keeps executing the dead config until restart — 22 further failures were
+# disk keeps executing the dead config until /reload-plugins or a restart; 22 further failures were
 # recorded in one live session AFTER the #2570 fix shipped (#2577).
 #
 # ADVISORY: never blocks, always exit 0. Registered on Stop, not
@@ -236,11 +236,32 @@ TAIL_BYTES="${HOOK_FAILURE_AUDIT_TAIL_BYTES:-2000000}"
 #   - launch failure        stderr carries an exec-failure signature. Signature
 #                           evidence decides this REGARDLESS of exit code.
 #   - completed non-zero    no signature, and exitCode is not 126 or 127.
+#   - stale config          no signature, exitCode 127, and the WHOLE stderr is
+#                           bash's missing-script-operand line: an optional
+#                           harness prefix, a shell token (`bash`, `sh`, or an
+#                           absolute path ending `/bash` or `/sh`), then
+#                           `<path>: No such file or directory`. Decided before
+#                           ambiguous. It is what a session prints when the
+#                           checkout behind a local-path marketplace deleted a
+#                           script the session's startup-loaded config still
+#                           names, and `/reload-plugins` is the remedy.
 #   - ambiguous             no signature, but exitCode is 126 or 127. Both
 #                           readings stay possible; the message says so plainly
 #                           and gives both remedies rather than picking one.
 # #2849's 126/127-OR-signature rule is too loose for the reason above.
 #
+# The attachment's `command` is the row's statusMessage whenever the row sets
+# one, which every row in this marketplace does, so the registered script is
+# usually not in the record at all. When `command` does look like a command line
+# (it names `${CLAUDE_PLUGIN_ROOT}` or a script file), the stale path's basename
+# must also be one of its tokens; basenames, because the same file appears as
+# `C:\...`, `C:/...`, mixed separators, or MSYS `/c/...`. A `line N:` segment
+# rules the class out: that is bash reporting a missing file from INSIDE a
+# script that did run. Accepted residual, resolved toward stale config: a
+# launched hook whose only stderr is a child `bash missing.sh` failure, and
+# which exits 127 with it, prints the same line and cannot be told apart when
+# `command` is a statusMessage.
+#
 # The signature set covers the exec-family wording and Claude Code's own
 # missing-executable wording (`executing hook command: Executable not found in
 # $PATH`, printed before any hook process exists; the launcher prefix keeps a launched
@@ -390,7 +411,19 @@ LINES=()
 # forgone saving is one fork on the warning path only: a turn with no failure
 # record exits above, before this line.
 SUMMARY=$(printf '%s' "$RECORDS" |
-  jq -cRs '[
+  jq -cRs '
+    def stale:
+      ((.stderr // "") | sub("[\\r\\n]+$"; "")) as $e
+      | (.command // "") as $c
+      | if .exitCode != 127 or ($e | test(": line [0-9]+: ")) then false
+        else ([$e | capture("^(?:Failed with non-blocking status code: )?(?:bash|sh|/[^:\\n]*/(?:bash|sh)): (?<p>[^\\n]+): No such file or directory$")?
+               | .p | split("/") | last | split("\\") | last] | first) as $b
+          | if $b == null or $b == "" then false
+            elif ($c | test("\\$\\{CLAUDE_PLUGIN_ROOT\\}|\\.(sh|bash|mjs|cjs|js|py|ps1)\\b")) # portability-ok: jq Oniguruma regex, not GNU grep or sed
+            then ($c | [splits("[\\s\"'"'"'/\\\\]+")] | any(. == $b)) # portability-ok: jq Oniguruma regex, not GNU grep or sed
+            else true end
+        end;
+    [
       split("\n")[] | fromjson?
       | select(.type? == "attachment") | .attachment
       | select(.type? == "hook_non_blocking_error")
@@ -400,6 +433,7 @@ SUMMARY=$(printf '%s' "$RECORDS" |
          class: (if ((.stderr // "")
                      | test("execvpe|execve\\(|exec format error|executing hook command: Executable not found in \\$PATH"; "i"))
                  then "launch"
+                 elif stale then "stale"
                  elif (.exitCode == 126 or .exitCode == 127) then "ambiguous"
                  else "completed" end),
          stderr: ((.stderr // "") | .[0:160])}
@@ -408,6 +442,7 @@ SUMMARY=$(printf '%s' "$RECORDS" |
     | map({hookName: .[0].hookName, command: .[0].command,
            count: length,
            launchCount: (map(select(.class == "launch")) | length),
+           staleCount: (map(select(.class == "stale")) | length),
            ambiguousCount: (map(select(.class == "ambiguous")) | length),
            completedCount: (map(select(.class == "completed")) | length),
            exitCode: last.exitCode, stderr: last.stderr})' 2>/dev/null)
@@ -466,6 +501,7 @@ DETAIL=$(jq -rn --argjson new "$NEW" --arg ph "$NO_STDERR_PLACEHOLDER" '
      else .stderr end) as $err |
     (if .exitCode == null then "?" else (.exitCode|tostring) end) as $ec |
     ([{n: .launchCount, label: "launch failure"},
+      {n: .staleCount, label: "stale config: registered script missing from disk"},
       {n: .ambiguousCount,
        label: "ambiguous: exit 126/127 with no exec-failure signature"},
       {n: .completedCount, label: "completed non-zero exit"}]
@@ -479,16 +515,17 @@ DETAIL=$(jq -rn --argjson new "$NEW" --arg ph "$NO_STDERR_PLACEHOLDER" '
 # value: a group whose only launch-failure record is not its last must still
 # raise the launch flag, and its own line above must still show the mix.
 #
-# All three flags come from ONE jq process over the same document rather than
-# three: a jq spawn is ~140 ms of fork() emulation on Windows Git Bash. `read`
-# assigns every name it is given even when the stream is short, so all three
+# All four flags come from ONE jq process over the same document rather than
+# four: a jq spawn is ~140 ms of fork() emulation on Windows Git Bash. `read`
+# assigns every name it is given even when the stream is short, so all four
 # stay defined under `set -u`. A Windows jq build ends the line with CRLF, and
 # the carriage return lands on the last name.
-read -r HAS_LAUNCH HAS_AMBIGUOUS HAS_COMPLETED < <(jq -rn --argjson new "$NEW" '
+read -r HAS_LAUNCH HAS_AMBIGUOUS HAS_COMPLETED HAS_STALE < <(jq -rn --argjson new "$NEW" '
   [([$new[] | .launchCount > 0]    | any),
    ([$new[] | .ambiguousCount > 0] | any),
-   ([$new[] | .completedCount > 0] | any)] | @tsv')
-HAS_COMPLETED="${HAS_COMPLETED%$'\r'}"
+   ([$new[] | .completedCount > 0] | any),
+   ([$new[] | .staleCount > 0]     | any)] | @tsv')
+HAS_STALE="${HAS_STALE%$'\r'}"
 
 # The diagnosis and the remedy are per-class, so several sentences can appear
 # when one warning batches records of different classes; the per-registration
@@ -502,6 +539,9 @@ MSG="harness-ops: ${TOTAL} hook failure record(s) in this session's transcript w
 if [[ "$HAS_LAUNCH" == "true" ]]; then
   MSG="${MSG} A hook that fails to launch enforces nothing — the tool calls it guards proceed as if approved (fail-open)."
 fi
+if [[ "$HAS_STALE" == "true" ]]; then
+  MSG="${MSG} A stale-config record means the hook's own script is missing from disk: this session is running hook config it loaded before the plugin changed, so that hook enforced nothing for the calls listed. Run /reload-plugins to load the current config, or restart the session."
+fi
 if [[ "$HAS_AMBIGUOUS" == "true" ]]; then
   MSG="${MSG} Exit 126 or 127 with no exec-failure signature in stderr is ambiguous — a shell reports those codes both for a registered command it could not execute at all and for a hook that ran and could not execute a command of its own, and the record cannot tell them apart. Both are possible: check that the registered command exists, is executable, and resolves on this platform, AND read the hook's own logic for a command it could not run."
 fi
@@ -509,8 +549,8 @@ if [[ "$HAS_COMPLETED" == "true" ]]; then
   MSG="${MSG} A hook that exited non-zero with no exec-failure evidence enforced nothing either, and Claude Code told nobody — but nothing here points at the launch path, so its own exit status and stderr above are where the failure is."
 fi
 MSG="${MSG} Confirm hook_failure_audit_enabled stays true via /plugin configure harness-ops@<marketplace> (default true)."
-if [[ "$HAS_LAUNCH" == "true" || "$HAS_AMBIGUOUS" == "true" ]]; then
-  MSG="${MSG} If a plugin update changed hook config on disk mid-session, this session still runs the config it loaded at startup — restart the session to load the fix."
+if [[ "$HAS_STALE" != "true" && ("$HAS_LAUNCH" == "true" || "$HAS_AMBIGUOUS" == "true") ]]; then
+  MSG="${MSG} If a plugin update or an in-place edit changed hook config on disk mid-session, this session still runs the config it loaded at startup. Run /reload-plugins to load the current config, or restart the session."
 fi
 
 hook::emit_system_message "$MSG"
diff --git a/plugins/harness-ops/hooks/hook-failure-audit.test.sh b/plugins/harness-ops/hooks/hook-failure-audit.test.sh
index 89bf809b0c..f7ecd47848 100755
--- a/plugins/harness-ops/hooks/hook-failure-audit.test.sh
+++ b/plugins/harness-ops/hooks/hook-failure-audit.test.sh
@@ -61,6 +61,8 @@ assert_contains "names the dead hook" "$OUT" "PreToolUse:Bash"
 assert_contains "systemMessage emitted" "$OUT" "systemMessage"
 assert_contains "explains fail-open" "$OUT" "fail-open"
 assert_contains "stale-session guidance" "$OUT" "restart"
+assert_contains "stale-session guidance names /reload-plugins before restart" "$OUT" \
+  "Run /reload-plugins to load the current config, or restart the session."
 
 # --- Structural matching: neither false-positive shape fires ----------------
 assert_absent "hook_success quoting an error does not fire" "$OUT" "PostToolUse:Edit"
@@ -122,6 +124,7 @@ assert_contains "completed record is still surfaced" "$OUT_DONE" "Stop:ran-and-f
 assert_contains "diagnosed as a completed non-zero exit" "$OUT_DONE" "completed non-zero exit"
 assert_absent "not described as a launch failure" "$OUT_DONE" "fails to launch"
 assert_absent "no restart-the-session remedy" "$OUT_DONE" "restart"
+assert_absent "no reload remedy for a hook that ran" "$OUT_DONE" "/reload-plugins"
 assert_absent "harness placeholder not attributed to the hook" "$OUT_DONE" "$HARNESS_NO_STDERR"
 assert_contains "no-stderr rendered as an explicit marker" "$OUT_DONE" "last stderr: (none — hook produced no stderr)"
 
@@ -198,6 +201,7 @@ assert_contains "bare exit 127 says both readings are possible" "$OUT_127" "Both
 assert_absent "bare exit 127 is not asserted to be a launch failure" "$OUT_127" "fails to launch"
 assert_absent "bare exit 127 is not asserted to have completed" "$OUT_127" "no exec-failure evidence"
 assert_contains "bare exit 127 still offers the restart remedy" "$OUT_127" "restart"
+assert_contains "bare exit 127 names /reload-plugins first" "$OUT_127" "Run /reload-plugins"
 assert_contains "bare exit 127 also points at the hook's own commands" "$OUT_127" \
   "read the hook's own logic"
 
@@ -210,6 +214,74 @@ assert_absent "bare exit 126 is not asserted to be a launch failure" "$OUT_126"
 assert_absent "bare exit 126 is not asserted to have completed" "$OUT_126" "no exec-failure evidence"
 assert_contains "bare exit 126 still offers the restart remedy" "$OUT_126" "restart"
 
+# STALE CONFIG: the session's startup-loaded config names a script the checkout
+# has since deleted, and bash reports its missing script operand at exit 127.
+# The first two stderr forms are copied from real records (context-guard
+# zone-gate.sh, source-control pr-ready-evidence-gate.sh); the backslash-only
+# and MSYS forms are synthetic. Backslashes are JSON-escaped here. Every
+# statusMessage-shaped command is a real row's statusMessage, which is what
+# the attachment's `command` holds when the row sets one.
+STALE_LABEL="stale config: registered script missing from disk"
+STATUS_MSG="Checking the context-zone gate..."
+PFX="Failed with non-blocking status code: "
+stale_case() { # <name> <command> <stderr>
+  local t="$TEST_TMPDIR/stale-$1.jsonl"
+  custom_record "PreToolUse:Edit" "$2" "$3" 127 40 >"$t"
+  run_hook "$t" "$TEST_TMPDIR/data-stale-$1"
+}
+assert_stale() { # <name> <output>
+  assert_contains "$1: classed stale config" "$2" "$STALE_LABEL"
+  assert_contains "$1: names /reload-plugins before restart" "$2" \
+    "Run /reload-plugins to load the current config, or restart the session."
+  assert_contains "$1: says the guard enforced nothing" "$2" "enforced nothing for the calls listed"
+  assert_absent "$1: not called ambiguous" "$2" "ambiguous"
+  assert_absent "$1: no false lead into the hook's own logic" "$2" "read the hook's own logic"
+  assert_absent "$1: remedy given once, not twice" "$2" "If a plugin update"
+}
+OUT_S=$(stale_case observed-mixed "$STATUS_MSG" \
+  "${PFX}/usr/bin/bash: C:\\\\code\\\\melodic\\\\claude-code-plugins\\\\plugins\\\\context-guard/hooks/zone-gate.sh: No such file or directory")
+assert_stale "observed mixed separators" "$OUT_S"
+OUT_S=$(stale_case observed-forward "Checking the ready-for-review flip against the mandatory pre-PR skill evidence..." \
+  "${PFX}bash: C:/code/melodic/claude-code-plugins/plugins/source-control/hooks/pr-ready-evidence-gate.sh: No such file or directory")
+assert_stale "observed forward-slash drive" "$OUT_S"
+OUT_S=$(stale_case backslash "$STATUS_MSG" \
+  "${PFX}bash: C:\\\\code\\\\plugins\\\\context-guard\\\\hooks\\\\zone-gate.sh: No such file or directory")
+assert_stale "backslash-only Windows path" "$OUT_S"
+OUT_S=$(stale_case msys "$STATUS_MSG" \
+  "${PFX}/usr/bin/bash: /c/code/plugins/context-guard/hooks/zone-gate.sh: No such file or directory")
+assert_stale "MSYS /c/ path" "$OUT_S"
+# shellcheck disable=SC2016 # literal ${CLAUDE_PLUGIN_ROOT} must not expand
+OUT_S=$(stale_case literal-root 'node ${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs ${CLAUDE_PLUGIN_ROOT}/hooks/zone-gate.sh' \
+  "${PFX}/usr/bin/bash: C:\\\\code\\\\plugins\\\\context-guard/hooks/zone-gate.sh: No such file or directory")
+assert_stale "command with literal CLAUDE_PLUGIN_ROOT" "$OUT_S"
+OUT_S=$(stale_case expanded-root 'node C:\\code\\plugins\\context-guard\\hooks\\exec-bash.mjs C:\\code\\plugins\\context-guard\\hooks\\zone-gate.sh' \
+  "${PFX}/usr/bin/bash: /c/code/plugins/context-guard/hooks/zone-gate.sh: No such file or directory")
+assert_stale "command with CLAUDE_PLUGIN_ROOT expanded" "$OUT_S"
+
+# STAY QUIET: shapes that must keep today's classification.
+# bash reporting a missing file from INSIDE a script that ran carries `line N:`.
+OUT_S=$(stale_case in-script "$STATUS_MSG" \
+  "${PFX}/c/code/plugins/x/hooks/my-hook.sh: line 12: /c/code/plugins/x/hooks/child.sh: No such file or directory")
+assert_contains "missing child inside a running hook stays ambiguous" "$OUT_S" \
+  "ambiguous: exit 126/127 with no exec-failure signature"
+assert_absent "missing child inside a running hook is not stale config" "$OUT_S" "$STALE_LABEL"
+OUT_S=$(stale_case bash-c-line "$STATUS_MSG" "${PFX}bash: line 1: helper.sh: No such file or directory")
+assert_absent "bash -c line-numbered error is not stale config" "$OUT_S" "$STALE_LABEL"
+# A command line that names a different script than the missing path.
+# shellcheck disable=SC2016 # literal ${CLAUDE_PLUGIN_ROOT} must not expand
+OUT_S=$(stale_case other-basename 'bash ${CLAUDE_PLUGIN_ROOT}/hooks/wrapper.sh' \
+  "${PFX}bash: C:/code/plugins/x/hooks/child-helper.sh: No such file or directory")
+assert_contains "missing path not in the registered command stays ambiguous" "$OUT_S" \
+  "ambiguous: exit 126/127 with no exec-failure signature"
+assert_absent "missing path not in the registered command is not stale config" "$OUT_S" "$STALE_LABEL"
+# The same line at exit 1 is not bash failing to open its script operand.
+T_S1="$TEST_TMPDIR/stale-exit1.jsonl"
+custom_record "PreToolUse:Edit" "$STATUS_MSG" \
+  "${PFX}bash: C:/code/plugins/x/hooks/zone-gate.sh: No such file or directory" 1 40 >"$T_S1"
+OUT_S=$(run_hook "$T_S1" "$TEST_TMPDIR/data-stale-exit1")
+assert_contains "missing-operand line at exit 1 stays completed" "$OUT_S" "completed non-zero exit"
+assert_absent "missing-operand line at exit 1 is not stale config" "$OUT_S" "$STALE_LABEL"
+
 # A hook that LAUNCHED and whose own subcommand was missing must NOT be called a
 # launch failure. cmd.exe's not-found phrasing is the Windows spelling of
 # "command not found", and a launched hook prints it about a command IT ran; the
diff --git a/plugins/harness-ops/hooks/hooks.json b/plugins/harness-ops/hooks/hooks.json
index 21d0653e19..c7b4758847 100644
--- a/plugins/harness-ops/hooks/hooks.json
+++ b/plugins/harness-ops/hooks/hooks.json
@@ -504,6 +504,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/harness-ops/skills/audit-performance/SKILL.md b/plugins/harness-ops/skills/audit-performance/SKILL.md
index 9e026c6744..6343375017 100644
--- a/plugins/harness-ops/skills/audit-performance/SKILL.md
+++ b/plugins/harness-ops/skills/audit-performance/SKILL.md
@@ -265,14 +265,21 @@ spawns. Read `fan_out` in this order:
    process with a live parent is working software and killing it breaks whatever owns it, so
    report `parent_alive` per candidate and treat `unknown` as unknown. `dead_parent_any_age`,
    beside that verdict, is a census and not a kill list: one row per name (`name`, `count`,
-   `youngest_h`, `oldest_h`) for a process in the orphan candidate set, or named `tail.exe`,
-   `grep.exe`, `sleep.exe`, or `cat.exe`, whose parent is gone or whose parent pid was
-   recycled, and which is older than 5 seconds. `count` is every such process of that name.
+   `youngest_h`, `oldest_h`, `cpu_seconds`) for a process in the orphan candidate set, or named
+   `tail.exe`, `grep.exe`, `sleep.exe`, `cat.exe`, `rm.exe`, or `du.exe`, whose parent is gone
+   or whose parent pid was recycled, and which is older than 5 seconds. `count` is every such
+   process of that name; `cpu_seconds` is their summed kernel plus user time, `null` when any
+   member's time is unreadable. `dead_parent_by_cpu` drops the name list: every dead-parent
+   process of any name under the same rules, ranked by CPU, top 10, each row `name`, `pid`,
+   `age_h`, `cpu_seconds`, and `cpu_share` (CPU seconds over age; above 1.0 means more than one
+   core). It is a ranking, not a kill list, and a high `cpu_share` there is the first thing to
+   report: a detached process burning CPU after its parent exited slows the whole machine at any
+   age, well inside the 24-hour orphan floor.
    A census process whose parent start time is unreadable is no row; it is counted in
    `dead_parent_any_age_unknown_count`, while the verdict's `unknown_count` holds only its
    own 24-hour candidates. The 24-hour orphan floor and the orphan candidate set are
-   unchanged, and a census row is not a process to kill. The census and its unknown count
-   are `null` off Windows, which is not measured rather than none found: Linux, macOS, and
+   unchanged, and a census row is not a process to kill. The census, its unknown count, and the
+   CPU ranking are `null` off Windows, which is not measured rather than none found: Linux, macOS, and
    WSL reparent an orphan to a live init or subreaper, so the process table cannot show its
    dead parent. The orphan verdict reads the same table, so off Windows (`orphans_note` says
    so) `orphan_count: 0` is not a negative to record, and a `live_parent` row whose parent is
diff --git a/plugins/harness-ops/skills/audit-performance/scripts/audit_performance.py b/plugins/harness-ops/skills/audit-performance/scripts/audit_performance.py
index d64984c318..b7745559ab 100755
--- a/plugins/harness-ops/skills/audit-performance/scripts/audit_performance.py
+++ b/plugins/harness-ops/skills/audit-performance/scripts/audit_performance.py
@@ -153,8 +153,13 @@
         "grep.exe",
         "sleep.exe",
         "cat.exe",
+        "rm.exe",
+        "du.exe",
     }
 )
+#: How many rows the dead-parent CPU ranking keeps. It needs no name list: any process whose
+#: parent is gone is ranked, so a detached-by-design process surfaces only when it burns CPU.
+DEAD_PARENT_BY_CPU_SIZE = 10
 
 #: Executable names a `claude` on PATH can carry. Windows resolves `.exe` and `.cmd` through
 #: PATHEXT, so a PATH scan that looks only for the bare name under-reports there.
@@ -885,10 +890,11 @@ class FILETIME(ctypes.Structure):
     query_limited_information = 0x1000
     epoch_offset_seconds = 11644473600  # 1601-01-01 to 1970-01-01
 
-    def creation_epoch(pid: int) -> float | None:
+    def process_times(pid: int) -> tuple[float | None, float | None]:
+        """Return (creation epoch, kernel plus user CPU seconds); None where unreadable."""
         handle = kernel32.OpenProcess(query_limited_information, False, pid)
         if not handle:
-            return None
+            return None, None
         try:
             created, exited, kernel, user = (
                 FILETIME(),
@@ -904,11 +910,16 @@ def creation_epoch(pid: int) -> float | None:
                 ctypes.byref(user),
             )
             if not ok:
-                return None
-            ticks = (created.dwHighDateTime << 32) | created.dwLowDateTime
-            if ticks == 0:
-                return None
-            return ticks / 1e7 - epoch_offset_seconds
+                return None, None
+
+            def ticks(filetime: FILETIME) -> int:
+                return (filetime.dwHighDateTime << 32) | filetime.dwLowDateTime
+
+            cpu_seconds = (ticks(kernel) + ticks(user)) / 1e7
+            created_ticks = ticks(created)
+            if created_ticks == 0:
+                return None, cpu_seconds
+            return created_ticks / 1e7 - epoch_offset_seconds, cpu_seconds
         finally:
             kernel32.CloseHandle(handle)
 
@@ -922,12 +933,14 @@ def creation_epoch(pid: int) -> float | None:
         more = kernel32.Process32FirstW(snapshot, ctypes.byref(entry))
         while more:
             pid = int(entry.th32ProcessID)
+            started, cpu_seconds = process_times(pid)
             rows.append(
                 {
                     "pid": pid,
                     "ppid": int(entry.th32ParentProcessID),
                     "name": entry.szExeFile,
-                    "started_epoch": creation_epoch(pid),
+                    "started_epoch": started,
+                    "cpu_seconds": cpu_seconds,
                 }
             )
             more = kernel32.Process32NextW(snapshot, ctypes.byref(entry))
@@ -983,7 +996,10 @@ def parse_etime(etime: str) -> float:
 
 
 def process_table() -> tuple[list[dict], str | None]:
-    """Return (records, error). Each record carries pid, ppid, name, started_epoch."""
+    """Return (records, error). Each record carries pid, ppid, name, started_epoch.
+
+    A Windows record also carries cpu_seconds (kernel plus user time), None when unreadable.
+    """
     try:
         rows = (
             _windows_process_table()
@@ -1000,6 +1016,64 @@ def is_claude_process(name: str) -> bool:
     return "claude" in lowered or lowered in ("node.exe", "node", "bun.exe", "bun")
 
 
+def _parent_state(record: dict, by_pid: dict[int, dict], started: float) -> str:
+    """Classify a record's parent as dead, recycled, unknown, or live."""
+    parent = by_pid.get(record["ppid"])
+    if parent is None:
+        return "dead"
+    parent_started = parent.get("started_epoch")
+    if parent_started is None:
+        return "unknown"
+    if parent_started > started:
+        # The PID was recycled: this "parent" started after its supposed child.
+        return "recycled"
+    return "live"
+
+
+def rank_dead_parent_by_cpu(
+    records: list[dict],
+    now_epoch: float,
+    by_pid: dict[int, dict],
+    size: int = DEAD_PARENT_BY_CPU_SIZE,
+) -> list[dict]:
+    """Rank every dead-parent process, any name, by CPU seconds. A ranking, not a kill list.
+
+    Same parent rules as the census: a recorded parent pid, a readable start time, an age
+    above the teardown guard, and a parent that is gone or whose pid was recycled. A process
+    whose CPU time is unreadable ranks after every known figure rather than as zero.
+    """
+    ranked: list[dict] = []
+    for record in records:
+        if record.get("ppid", 0) <= 0:
+            continue
+        started = record.get("started_epoch")
+        if started is None:
+            continue
+        age_seconds = now_epoch - started
+        if age_seconds <= DEAD_PARENT_CENSUS_MIN_AGE_SECONDS:
+            continue
+        if _parent_state(record, by_pid, started) not in {"dead", "recycled"}:
+            continue
+        cpu = record.get("cpu_seconds")
+        ranked.append(
+            {
+                "name": record["name"],
+                "pid": record["pid"],
+                "age_h": round(age_seconds / 3600.0, 1),
+                "cpu_seconds": None if cpu is None else round(cpu, 1),
+                "cpu_share": None if cpu is None else round(cpu / age_seconds, 3),
+            }
+        )
+    ranked.sort(
+        key=lambda row: (
+            row["cpu_seconds"] is None,
+            -(row["cpu_seconds"] or 0.0),
+            row["pid"],
+        )
+    )
+    return ranked[:size]
+
+
 def attribute_orphans(
     records: list[dict],
     now_epoch: float,
@@ -1026,10 +1100,14 @@ def attribute_orphans(
     verdict candidates. The orphan verdict, its age floor, and its candidate set
     are unchanged.
 
-    The census runs only on a Windows table, whose parent pid is the creator's
+    `dead_parent_by_cpu` drops the name list: every dead-parent process under the
+    census parent and age rules, ranked by CPU seconds. A detached-by-design process
+    stays out of the census and surfaces there only when it burns CPU.
+
+    The census and the ranking run only on a Windows table, whose parent pid is the creator's
     and stays so after the creator exits. POSIX reparents an orphan to init or
     the nearest child subreaper, so its ppid names a live adopter the table
-    cannot tell from a real parent: there the census is None, not [].
+    cannot tell from a real parent: there both are None, not [].
     The verdict reads the same table and is left as is, so off Windows
     `orphans_note` says it cannot see a reparented orphan; on Windows it is None.
     """
@@ -1038,7 +1116,7 @@ def attribute_orphans(
     orphans: list[dict] = []
     live_parent: list[dict] = []
     unknown: list[dict] = []
-    # name -> [count, youngest_hours, oldest_hours]. Counted in full before the
+    # name -> [count, youngest_hours, oldest_hours, cpu_seconds]. Counted in full before the
     # orphan sample cap below; this table is not a kill list.
     census_by_name: dict[str, list] = {}
     census_unknown = 0
@@ -1065,17 +1143,7 @@ def attribute_orphans(
         if not verdict_aged and not census_aged:
             continue
         parent = by_pid.get(record["ppid"])
-        if parent is None:
-            parent_state = "dead"
-        else:
-            parent_started = parent.get("started_epoch")
-            if parent_started is None:
-                parent_state = "unknown"
-            elif parent_started > started:
-                # The PID was recycled: this "parent" started after its supposed child.
-                parent_state = "recycled"
-            else:
-                parent_state = "live"
+        parent_state = _parent_state(record, by_pid, started)
         summary = {
             "name": record["name"],
             "pid": record["pid"],
@@ -1101,15 +1169,18 @@ def attribute_orphans(
                 summary["parent_name"] = parent["name"]
                 live_parent.append(summary)
         if census_aged and parent_state in {"dead", "recycled"}:
+            cpu = record.get("cpu_seconds")
             row = census_by_name.get(lowered)
             if row is None:
-                census_by_name[lowered] = [1, age_hours, age_hours]
+                census_by_name[lowered] = [1, age_hours, age_hours, cpu]
             else:
                 row[0] += 1
                 if age_hours < row[1]:
                     row[1] = age_hours
                 if age_hours > row[2]:
                     row[2] = age_hours
+                # One unreadable member makes the sum unknown, never an undercount.
+                row[3] = None if row[3] is None or cpu is None else row[3] + cpu
         elif census_aged and parent_state == "unknown":
             census_unknown += 1
     dead_parent_any_age = [
@@ -1118,15 +1189,17 @@ def attribute_orphans(
             "count": count,
             "youngest_h": round(youngest, 1),
             "oldest_h": round(oldest, 1),
+            "cpu_seconds": None if cpu is None else round(cpu, 1),
         }
-        for name, (count, youngest, oldest) in sorted(census_by_name.items())
+        for name, (count, youngest, oldest, cpu) in sorted(census_by_name.items())
     ]
     if creator_ppids:
         census_note = (
             "Census, not a kill list. Per-name counts of processes whose parent is gone "
             "or whose parent pid was recycled, at any age above 5 seconds of teardown. "
             "The name set is the orphan candidate set plus tail.exe, grep.exe, sleep.exe, "
-            "and cat.exe. A process whose parent start time is unreadable is not a row "
+            "cat.exe, rm.exe, and du.exe. cpu_seconds sums kernel plus user time across the "
+            "name and is null when any member's time is unreadable. A process whose parent start time is unreadable is not a row "
             "here; dead_parent_any_age_unknown_count counts every such census process, "
             "while the orphan verdict's unknown_count holds only its own 24-hour "
             "candidates. "
@@ -1171,6 +1244,22 @@ def attribute_orphans(
         "dead_parent_any_age": dead_parent_any_age if creator_ppids else None,
         "dead_parent_any_age_unknown_count": census_unknown if creator_ppids else None,
         "dead_parent_any_age_note": census_note,
+        "dead_parent_by_cpu": (
+            rank_dead_parent_by_cpu(records, now_epoch, by_pid)
+            if creator_ppids
+            else None
+        ),
+        "dead_parent_by_cpu_note": (
+            "Ranking, not a kill list. Every process of any name whose parent is gone or "
+            "whose parent pid was recycled, older than 5 seconds, ranked by cpu_seconds "
+            "(kernel plus user time), top 10. cpu_share is cpu_seconds over age; it can "
+            "exceed 1.0 for a process using more than one core. A high cpu_share on a "
+            "dead-parent process is the first thing to report. This engine reports and "
+            "never kills."
+            if creator_ppids
+            else "Ranking not measured on this platform, for the reparenting reason "
+            "dead_parent_any_age_note gives. This engine reports and never kills."
+        ),
         "note": (
             "Only a dead-parent process is an orphan. Live-parent processes of the same age "
             "are working software; killing them breaks whatever owns them. Scoped to the shells, "
diff --git a/plugins/harness-ops/skills/audit-performance/scripts/test_audit_performance.py b/plugins/harness-ops/skills/audit-performance/scripts/test_audit_performance.py
index c215660a94..7daa4aa2b9 100755
--- a/plugins/harness-ops/skills/audit-performance/scripts/test_audit_performance.py
+++ b/plugins/harness-ops/skills/audit-performance/scripts/test_audit_performance.py
@@ -21,6 +21,7 @@
 import struct
 import sys
 import tempfile
+import time
 import unittest
 from pathlib import Path
 from unittest import mock
@@ -1054,7 +1055,15 @@ def test_a_young_verdict_name_is_in_the_census_and_not_an_orphan(self):
         self.assertEqual(result["orphan_count"], 0)
         self.assertEqual(
             result["dead_parent_any_age"],
-            [{"name": "bash.exe", "count": 1, "youngest_h": 0.0, "oldest_h": 0.0}],
+            [
+                {
+                    "name": "bash.exe",
+                    "count": 1,
+                    "youngest_h": 0.0,
+                    "oldest_h": 0.0,
+                    "cpu_seconds": None,
+                }
+            ],
         )
 
     def test_a_name_outside_the_census_set_appears_in_neither(self):
@@ -1177,7 +1186,7 @@ def test_more_than_twenty_of_one_name_are_counted_before_any_truncation(self):
     def test_coreutils_names_stay_out_of_the_verdict_set(self):
         self.assertEqual(engine.ORPHAN_MIN_AGE_HOURS, 24.0)
         self.assertEqual(len(engine.ORPHAN_CANDIDATE_NAMES), 18)
-        extras = {"tail.exe", "grep.exe", "sleep.exe", "cat.exe"}
+        extras = {"tail.exe", "grep.exe", "sleep.exe", "cat.exe", "rm.exe", "du.exe"}
         self.assertEqual(extras, engine.DEAD_PARENT_CENSUS_EXTRA_NAMES)
         self.assertTrue(extras.isdisjoint(engine.ORPHAN_CANDIDATE_NAMES))
         result = self.attribute([], self.NOW)
@@ -1206,7 +1215,15 @@ def test_a_process_inside_the_teardown_guard_is_absent(self):
         self.assertEqual(result["unknown_count"], 0)
         self.assertEqual(
             result["dead_parent_any_age"],
-            [{"name": "sleep.exe", "count": 1, "youngest_h": 0.0, "oldest_h": 0.0}],
+            [
+                {
+                    "name": "sleep.exe",
+                    "count": 1,
+                    "youngest_h": 0.0,
+                    "oldest_h": 0.0,
+                    "cpu_seconds": None,
+                }
+            ],
         )
 
     def test_a_live_parent_keeps_a_census_name_out_of_the_census(self):
@@ -1235,6 +1252,159 @@ def test_the_engine_never_kills_or_signals_a_process(self):
         self.assertIn("not a kill list", result["dead_parent_any_age_note"])
 
 
+class TestDeadParentByCpu(unittest.TestCase):
+    """Every dead-parent process, any name, ranked by CPU seconds. Not a kill list."""
+
+    NOW = 1_700_000_000.0
+
+    def attribute(self, records: list[dict], platform: str = "win32") -> dict:
+        return engine.attribute_orphans(records, self.NOW, platform=platform)
+
+    def proc(self, pid: int, name: str, age: float | None, cpu: float | None) -> dict:
+        started = None if age is None else self.NOW - age
+        return {
+            "pid": pid,
+            "ppid": 999,
+            "name": name,
+            "started_epoch": started,
+            "cpu_seconds": cpu,
+        }
+
+    def table(self) -> list[dict]:
+        now = self.NOW
+        return [
+            # Dead parent, 60,000 s old, 30,000 CPU seconds: cpu_share 0.5.
+            {
+                "pid": 40,
+                "ppid": 900,
+                "name": "rm.exe",
+                "started_epoch": now - 60_000,
+                "cpu_seconds": 30_000.0,
+            },
+            # Dead parent, detached by design, 1 CPU second over 5 days.
+            {
+                "pid": 41,
+                "ppid": 901,
+                "name": "dotnet.exe",
+                "started_epoch": now - 5 * 86400,
+                "cpu_seconds": 1.0,
+            },
+            # Dead parent, 7,200 s old, 3,600 CPU seconds.
+            {
+                "pid": 42,
+                "ppid": 902,
+                "name": "du.exe",
+                "started_epoch": now - 7_200,
+                "cpu_seconds": 3_600.0,
+            },
+            # Live parent burning more CPU than anything above.
+            {
+                "pid": 43,
+                "ppid": 0,
+                "name": "code.exe",
+                "started_epoch": now - 86400,
+                "cpu_seconds": 90_000.0,
+            },
+            {
+                "pid": 44,
+                "ppid": 43,
+                "name": "busy.exe",
+                "started_epoch": now - 3600,
+                "cpu_seconds": 80_000.0,
+            },
+        ]
+
+    def test_a_cpu_heavy_dead_parent_rm_ranks_first_over_an_idle_dotnet(self):
+        ranked = self.attribute(self.table())["dead_parent_by_cpu"]
+        names = [row["name"] for row in ranked]
+        self.assertEqual(names, ["rm.exe", "du.exe", "dotnet.exe"])
+        self.assertEqual(
+            ranked[0],
+            {
+                "name": "rm.exe",
+                "pid": 40,
+                "age_h": 16.7,
+                "cpu_seconds": 30_000.0,
+                "cpu_share": 0.5,
+            },
+        )
+
+    def test_the_idle_dotnet_stays_out_of_the_verdict_and_the_census(self):
+        result = self.attribute(self.table())
+        self.assertNotIn(41, {row["pid"] for row in result["orphans"]})
+        self.assertNotIn(
+            "dotnet.exe", {row["name"] for row in result["dead_parent_any_age"]}
+        )
+
+    def test_dead_parent_rm_and_du_are_counted_in_the_census_with_cpu(self):
+        census = self.attribute(self.table())["dead_parent_any_age"]
+        rows = {row["name"]: row for row in census}
+        self.assertEqual(rows["rm.exe"]["count"], 1)
+        self.assertEqual(rows["rm.exe"]["cpu_seconds"], 30_000.0)
+        self.assertEqual(rows["du.exe"]["count"], 1)
+        self.assertEqual(rows["du.exe"]["cpu_seconds"], 3_600.0)
+
+    def test_census_cpu_sums_per_name_and_an_unreadable_member_makes_it_unknown(self):
+        records = [
+            self.proc(1, "rm.exe", 60, 2.0),
+            self.proc(2, "rm.exe", 60, 3.5),
+            self.proc(3, "du.exe", 60, 4.0),
+            self.proc(4, "du.exe", 60, None),
+        ]
+        census = self.attribute(records)["dead_parent_any_age"]
+        rows = {row["name"]: row for row in census}
+        self.assertEqual(rows["rm.exe"]["cpu_seconds"], 5.5)
+        self.assertIsNone(rows["du.exe"]["cpu_seconds"])
+
+    def test_a_live_parent_process_never_appears_in_the_ranking(self):
+        ranked = self.attribute(self.table())["dead_parent_by_cpu"]
+        pids = {row["pid"] for row in ranked}
+        self.assertNotIn(43, pids)
+        self.assertNotIn(44, pids)
+
+    def test_unreadable_cpu_ranks_last_as_unknown_not_zero(self):
+        records = [self.proc(1, "a.exe", 60, None), self.proc(2, "b.exe", 60, 0.0)]
+        ranked = self.attribute(records)["dead_parent_by_cpu"]
+        self.assertEqual([row["pid"] for row in ranked], [2, 1])
+        self.assertIsNone(ranked[1]["cpu_seconds"])
+        self.assertIsNone(ranked[1]["cpu_share"])
+
+    def test_teardown_guard_and_unreadable_start_keep_a_process_out(self):
+        no_parent = self.proc(3, "c.exe", 60, 9.0)
+        no_parent["ppid"] = 0
+        records = [
+            self.proc(1, "a.exe", 5.0, 4.0),
+            self.proc(2, "b.exe", None, 9.0),
+            no_parent,
+        ]
+        self.assertEqual(self.attribute(records)["dead_parent_by_cpu"], [])
+
+    def test_the_ranking_keeps_the_top_ten(self):
+        records = [self.proc(i, f"p{i}.exe", 3600, float(i)) for i in range(1, 13)]
+        ranked = self.attribute(records)["dead_parent_by_cpu"]
+        pids = [row["pid"] for row in ranked]
+        self.assertEqual(pids, [12, 11, 10, 9, 8, 7, 6, 5, 4, 3])
+
+    def test_on_a_posix_table_the_ranking_is_not_measured(self):
+        result = self.attribute(self.table(), platform="linux")
+        self.assertIsNone(result["dead_parent_by_cpu"])
+        self.assertIn("not measured", result["dead_parent_by_cpu_note"])
+        windows = self.attribute(self.table())
+        self.assertIn("not a kill list", windows["dead_parent_by_cpu_note"])
+        self.assertEqual(self.attribute([])["dead_parent_by_cpu"], [])
+
+    @unittest.skipUnless(
+        sys.platform == "win32", "reads the live Windows process table"
+    )
+    def test_the_windows_table_reads_this_process_cpu_time(self):
+        floor = time.process_time()
+        records, error = engine.process_table()
+        self.assertIsNone(error)
+        mine = next(r for r in records if r["pid"] == os.getpid())
+        self.assertIsNotNone(mine["cpu_seconds"])
+        self.assertGreaterEqual(mine["cpu_seconds"] + 0.05, floor)
+
+
 class TestDeadParentCensusNeedsCreatorParentPids(unittest.TestCase):
     """POSIX reparents an orphan, so its ppid names a live adopter, never the dead creator.
 
diff --git a/plugins/harness-ops/skills/observability/SKILL.md b/plugins/harness-ops/skills/observability/SKILL.md
index 3357ecf537..ea05715a2a 100644
--- a/plugins/harness-ops/skills/observability/SKILL.md
+++ b/plugins/harness-ops/skills/observability/SKILL.md
@@ -147,7 +147,7 @@ builder. Node missing: the markdown report stands and the dashboard is not built
 | Action | Args | Effect |
 |---|---|---|
 | `clean` | `[--keep-days N]` (default 30) `[--dry-run]` `[--quiet]` `[--hook-root REL]` `[--skill-usage-scope repo\|user\|data-dir]` `[--skill-usage-dir REL]` `[--keep-skill-usage-days N]` (default 365) | Prune the hook log root (the shared file line by line, session files untouched for the window whole, stale `prune-pending/` sets regardless of the logging switch), the retired shared file while it exists, and the OTEL store. See [context/read-routing.md](context/read-routing.md) "Retention" and `scripts/clean.sh`. Skill-usage pruning is **opt-in**: inert unless `--skill-usage-scope` is passed, and `data-dir` requires an explicit `--skill-usage-dir` rather than trusting `CLAUDE_PLUGIN_DATA` |
-| `latency` | `[--days N \| --since YYYY-MM-DD]` (default `--days 7`) `[--budget EVENT=MS]`... `[--min-fires N]` (20) `[--min-sessions N]` (5, minimum 3) | Read-only. Per lane and hook event from `hook_execution_complete` in the hot OTEL store: p50/p95 against a p95 budget, and a within-session slope that flags latency growing across a session. Fires `clean` has compacted to the cold tier are not included; a window reaching past the oldest hot fire prints a warning. Exit 0 none flagged, 1 flagged, 2 cannot evaluate. Takes about 60 s on a large store: run on demand or from a routine or loop, never a SessionStart hook. See `scripts/hook-latency.sh --help` |
+| `latency` | `[--days N \| --since YYYY-MM-DD]` (default `--days 7`) `[--budget EVENT=MS]`... `[--min-fires N]` (20) `[--min-sessions N]` (5, minimum 3) | Read-only. Per lane and hook event from `hook_execution_complete` in the hot OTEL store: p50/p95 against a p95 budget, and a within-session slope that flags latency growing across a session. Fires `clean` has compacted to the cold tier are not included; a window reaching past the oldest hot fire prints a warning. Exit 0 none flagged, 1 flagged, 2 cannot evaluate (no duckdb, no store, or no rows in the window); the exit-2 message names two routes: turning telemetry on per [context/operator-setup.md](context/operator-setup.md), and for Stop hooks the `stop_hook_summary` transcript records `/harness-ops:audit-performance` names. Takes about 60 s on a large store: run on demand or from a routine or loop, never a SessionStart hook. See `scripts/hook-latency.sh --help` |
 | `compare` | `<session-a> <session-b>` (two different `session.id` values, `^[A-Za-z0-9._-]+$`) | Read-only. One task run as two sessions, side by side from the hot OTEL store: `claude_code.token.usage` by type (`cacheCreation` its own column) split by model and effort (`unset` when the attribute is absent), per-type totals, and each session's `claude_code.cost.usage` reconciled against its `api_request` events with status `match`, `events short` or `events exceed metric`. The metric is the total of record. Costs are Claude Code's estimate: on a subscription they measure work, not a bill. Exit 0 rendered, 2 cannot evaluate: a session with no metric rows (aged to the cold tier, or `OTEL_METRICS_INCLUDE_SESSION_ID` off) or a non-delta metric ("cannot reconcile: cumulative metrics"). See `scripts/session-compare.sh --help` |
 
 `latency` telemetry record:
diff --git a/plugins/harness-ops/skills/observability/scripts/hook-latency.sh b/plugins/harness-ops/skills/observability/scripts/hook-latency.sh
index d88535c872..718587e338 100755
--- a/plugins/harness-ops/skills/observability/scripts/hook-latency.sh
+++ b/plugins/harness-ops/skills/observability/scripts/hook-latency.sh
@@ -18,18 +18,33 @@
 # a routine or loop, never from a SessionStart hook.
 #
 # Exit: 0 nothing flagged, 1 at least one row flagged, 2 cannot evaluate (no duckdb, no store,
-# or no hook_execution_complete rows in the window).
+# or no hook_execution_complete rows in the window). Those three exits name two routes forward:
+# turning telemetry on, and the stop_hook_summary transcript records for Stop hooks.
 
 set -uo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 OTEL_DIR="$SCRIPT_DIR/../otel"
 
-usage() { sed -n '2,21p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
+usage() { sed -n '2,22p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
 die() {
   printf 'hook-latency: %s\n' "$1" >&2
   exit 2
 }
+routes() {
+  cat >&2 <<'EOF'
+hook-latency: routes to hook latency:
+  1. Turn telemetry on: CLAUDE_CODE_ENABLE_TELEMETRY=1 with OTEL_LOGS_EXPORTER=otlp to the
+     collector at http://127.0.0.1:4318; see the observability skill's context/operator-setup.md.
+  2. Stop hooks, no telemetry needed: the stop_hook_summary records in session transcripts; see
+     /harness-ops:audit-performance, gotcha "Never time a hook by running it".
+EOF
+}
+cannot_evaluate() {
+  printf 'hook-latency: %s\n' "$1" >&2
+  routes
+  exit 2
+}
 
 # Judgment, derived from docs/conventions/hook-budget/README.md 'after at S=80 ms' table.
 budgets="Stop=2000,PostToolBatch=1500,UserPromptSubmit=1500,SubagentStop=1500,"
@@ -83,9 +98,9 @@ sql_path() { # native duckdb.exe cannot read MSYS paths; double quotes for a SQL
   printf '%s\n' "${p//\'/\'\'}"
 }
 
-command -v duckdb >/dev/null 2>&1 || die "duckdb not found"
+command -v duckdb >/dev/null 2>&1 || cannot_evaluate "duckdb not found"
 store="${CC_OTEL_STORE:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.claude/observability/otel}"
-[[ -f "$store/cc-logs.json" ]] || die "no logs store at $store/cc-logs.json"
+[[ -f "$store/cc-logs.json" ]] || cannot_evaluate "no logs store at $store/cc-logs.json"
 
 err="$(mktemp)"
 trap 'rm -f "$err"' EXIT
@@ -137,3 +152,6 @@ NR == 1 {
   printf fmt, (reason ? "!" : ""), $3, $4, $5, $6, $7, $8, b, $9, ($10 == "" ? "-" : $10), $11, reason
 }
 END { exit(empty ? 2 : flagged ? 1 : 0) }'
+rc=$?
+((rc == 2)) && routes
+exit "$rc"
diff --git a/plugins/harness-ops/skills/observability/scripts/hook-latency.test.sh b/plugins/harness-ops/skills/observability/scripts/hook-latency.test.sh
index 806aeb5cfe..b52d77b4e5 100755
--- a/plugins/harness-ops/skills/observability/scripts/hook-latency.test.sh
+++ b/plugins/harness-ops/skills/observability/scripts/hook-latency.test.sh
@@ -52,11 +52,19 @@ run() { # <store> <args...>
   rc=$?
 }
 flagged() { grep '^!' <<<"$out"; } # rows the script marked
+# A cannot-evaluate exit names both routes: the telemetry switch and the Stop-hook transcript route.
+assert_routes() { # <case label>
+  assert_contains "$1 names the telemetry-enable step" "$out" "CLAUDE_CODE_ENABLE_TELEMETRY=1"
+  assert_contains "$1 names the setup doc" "$out" "context/operator-setup.md"
+  assert_contains "$1 names the audit-performance skill" "$out" "/harness-ops:audit-performance"
+  assert_contains "$1 names the stop_hook_summary records" "$out" "stop_hook_summary"
+}
 
 out="$(bash "$SCRIPT" --help)"
 assert_contains "--help prints usage" "$out" "--min-sessions"
 run "$TMP" --budget nope
 assert_eq "bad --budget exits 2" 2 "$rc"
+assert_not_contains "a usage error names no telemetry route" "$out" "stop_hook_summary"
 run "$TMP" --min-sessions 2
 assert_eq "--min-sessions below 3 exits 2" 2 "$rc"
 
@@ -104,6 +112,7 @@ if command -v duckdb >/dev/null 2>&1; then
   run "$old" --days 1
   assert_eq "fires before --days are excluded" 2 "$rc"
   assert_contains "the exclusion says why" "$out" "no hook_execution_complete rows"
+  assert_routes "no rows in the window"
   run "$old" --since 2000-01-01
   assert_eq "--since before the fires includes them" 0 "$rc"
   assert_contains "a window older than the hot store warns about the cold tier" "$out" "cold tier"
@@ -119,6 +128,24 @@ fi
 
 run "$TMP/missing"
 assert_eq "missing store exits 2" 2 "$rc"
+if command -v duckdb >/dev/null 2>&1; then
+  assert_contains "missing store says why" "$out" "no logs store at"
+else
+  skip_case "duckdb not found — the duckdb check exits before the store check"
+fi
+assert_routes "missing store"
+
+# duckdb missing: PATH without every directory that holds a duckdb.
+nodb_path=""
+IFS=: read -ra path_dirs <<<"$PATH"
+for d in "${path_dirs[@]}"; do
+  [[ -e "$d/duckdb" || -e "$d/duckdb.exe" ]] || nodb_path+="$d:"
+done
+out="$(PATH="${nodb_path%:}" CC_OTEL_STORE="$TMP/missing" "$BASH" "$SCRIPT" 2>&1)"
+rc=$?
+assert_eq "missing duckdb exits 2" 2 "$rc"
+assert_contains "missing duckdb says why" "$out" "duckdb not found"
+assert_routes "missing duckdb"
 
 printf '\n%d case(s), %d failed\n' "$CASE_NUM" "$FAILED"
 ((FAILED == 0))
diff --git a/plugins/instruction-placement/.claude-plugin/plugin.json b/plugins/instruction-placement/.claude-plugin/plugin.json
index ecfc5faf6a..476910b973 100644
--- a/plugins/instruction-placement/.claude-plugin/plugin.json
+++ b/plugins/instruction-placement/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "instruction-placement",
-  "version": "0.21.9",
+  "version": "0.21.10",
   "description": "Routes agent instructions to the surface that loads them at the right time. audit finds conventions narrower than the always-loaded CLAUDE.md or AGENTS.md holding them, or stranded in docs Claude never loads, and proposes a destination with a validated paths glob; safety-class content is never demoted. realign applies moves item by item and regenerates an index. check verifies globs and index. migrate moves content to AGENTS.md with a CLAUDE.md shim. setup checks the index is readable.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/instruction-placement/CHANGELOG.md b/plugins/instruction-placement/CHANGELOG.md
index 1da5e3f2eb..bcb3b47f81 100644
--- a/plugins/instruction-placement/CHANGELOG.md
+++ b/plugins/instruction-placement/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `instruction-placement` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.21.10] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.21.9] - 2026-10-04
 
 ### Changed
diff --git a/plugins/instruction-placement/hooks/exec-bash.mjs b/plugins/instruction-placement/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/instruction-placement/hooks/exec-bash.mjs
+++ b/plugins/instruction-placement/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/instruction-placement/hooks/hooks.json b/plugins/instruction-placement/hooks/hooks.json
index 3e6fae8790..83ef39ab35 100644
--- a/plugins/instruction-placement/hooks/hooks.json
+++ b/plugins/instruction-placement/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/markdown-format/.claude-plugin/plugin.json b/plugins/markdown-format/.claude-plugin/plugin.json
index c99b437459..09d61dac34 100644
--- a/plugins/markdown-format/.claude-plugin/plugin.json
+++ b/plugins/markdown-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "markdown-format",
-  "version": "0.12.7",
+  "version": "0.12.8",
   "description": "Auto-format and lint Markdown on edit via markdownlint-cli2, only in repos that carry their own markdownlint config.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/markdown-format/CHANGELOG.md b/plugins/markdown-format/CHANGELOG.md
index c115a86948..3f366d81ab 100644
--- a/plugins/markdown-format/CHANGELOG.md
+++ b/plugins/markdown-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `markdown-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.12.8] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.12.7] - 2026-10-04
 
 ### Changed
diff --git a/plugins/markdown-format/hooks/exec-bash.mjs b/plugins/markdown-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/markdown-format/hooks/exec-bash.mjs
+++ b/plugins/markdown-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/markdown-format/hooks/hooks.json b/plugins/markdown-format/hooks/hooks.json
index e6fde05173..46f445d1ab 100644
--- a/plugins/markdown-format/hooks/hooks.json
+++ b/plugins/markdown-format/hooks/hooks.json
@@ -32,6 +32,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -49,6 +50,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/multi-agent/.claude-plugin/plugin.json b/plugins/multi-agent/.claude-plugin/plugin.json
index daf250a984..b2d9571bd0 100644
--- a/plugins/multi-agent/.claude-plugin/plugin.json
+++ b/plugins/multi-agent/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "multi-agent",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Workflow and model-routing guidance for multi-agent work: assess (workflow, subagent or single context), route (the role map a workflow script reads from args, keeping fan-out stages off a frontier model), audit-defaults (rechecks bundled defaults against upstream, or sweeps the repo's model and workflow guidance, via a read-only drift-audit workflow), check (whether node resolves and the fetch gate is registered), and setup (writes a user, team or local layer after a preview and a yes).",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/multi-agent/CHANGELOG.md b/plugins/multi-agent/CHANGELOG.md
index bd1fff6f55..1869cf1c58 100644
--- a/plugins/multi-agent/CHANGELOG.md
+++ b/plugins/multi-agent/CHANGELOG.md
@@ -3,6 +3,12 @@
 All notable changes to the `multi-agent` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.4.6] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+
 ## [0.4.5] - 2026-10-04
 
 ### Changed
diff --git a/plugins/multi-agent/hooks/hooks.json b/plugins/multi-agent/hooks/hooks.json
index da72c03a0a..a2f884478e 100644
--- a/plugins/multi-agent/hooks/hooks.json
+++ b/plugins/multi-agent/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/powershell-format/.claude-plugin/plugin.json b/plugins/powershell-format/.claude-plugin/plugin.json
index cb407453da..7c563fecf9 100644
--- a/plugins/powershell-format/.claude-plugin/plugin.json
+++ b/plugins/powershell-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "powershell-format",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "Auto-format and lint PowerShell on edit via PSScriptAnalyzer, only when a PSScriptAnalyzerSettings.psd1 governs the repo, using the consuming repo's own analyzer settings.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/powershell-format/CHANGELOG.md b/plugins/powershell-format/CHANGELOG.md
index 6f335b773f..1ecd31714c 100644
--- a/plugins/powershell-format/CHANGELOG.md
+++ b/plugins/powershell-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `powershell-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.10.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.10.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/powershell-format/hooks/exec-bash.mjs b/plugins/powershell-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/powershell-format/hooks/exec-bash.mjs
+++ b/plugins/powershell-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/powershell-format/hooks/hooks.json b/plugins/powershell-format/hooks/hooks.json
index 6dd2407126..6be234eb3d 100644
--- a/plugins/powershell-format/hooks/hooks.json
+++ b/plugins/powershell-format/hooks/hooks.json
@@ -43,6 +43,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -60,6 +61,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/rate-limit-guard/.claude-plugin/plugin.json b/plugins/rate-limit-guard/.claude-plugin/plugin.json
index dfa001d296..1e9640e4de 100644
--- a/plugins/rate-limit-guard/.claude-plugin/plugin.json
+++ b/plugins/rate-limit-guard/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "rate-limit-guard",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "Shared rate-limit guard for loop lanes and Claude: a hooks module writes the subscription rate-limit windows to a fixed machine-scope file and tells Claude where they stand at boundaries, a StopFailure hook records rate-limit stops reactively, and a reader contract fixes how consuming sessions pause and resume.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/rate-limit-guard/CHANGELOG.md b/plugins/rate-limit-guard/CHANGELOG.md
index e3daec7c8d..ec957b7057 100644
--- a/plugins/rate-limit-guard/CHANGELOG.md
+++ b/plugins/rate-limit-guard/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `rate-limit-guard` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.15.2] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.15.1] - 2026-10-04
 
 ### Changed
diff --git a/plugins/rate-limit-guard/hooks/exec-bash.mjs b/plugins/rate-limit-guard/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/rate-limit-guard/hooks/exec-bash.mjs
+++ b/plugins/rate-limit-guard/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/rate-limit-guard/hooks/hooks.json b/plugins/rate-limit-guard/hooks/hooks.json
index 54d500e87c..3ad390c0fd 100644
--- a/plugins/rate-limit-guard/hooks/hooks.json
+++ b/plugins/rate-limit-guard/hooks/hooks.json
@@ -4,6 +4,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/repo-hygiene/.claude-plugin/plugin.json b/plugins/repo-hygiene/.claude-plugin/plugin.json
index b609b375f9..42cb8d796e 100644
--- a/plugins/repo-hygiene/.claude-plugin/plugin.json
+++ b/plugins/repo-hygiene/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "repo-hygiene",
-  "version": "0.19.9",
+  "version": "0.19.10",
   "description": "Repo hygiene action-router: /repo-hygiene:clean sweeps reclaimable caches, build artifacts, and stale git metadata, and can realign the working tree to a fresh-pull state, dry-run-first, with destructive tiers gated behind explicit confirmation and a session-scoped destructive-command guard. Ecosystem targets are detected at runtime; secrets, runtime dependencies, and skill data are preserved by default.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/repo-hygiene/CHANGELOG.md b/plugins/repo-hygiene/CHANGELOG.md
index 14b25a583a..a7f934c912 100644
--- a/plugins/repo-hygiene/CHANGELOG.md
+++ b/plugins/repo-hygiene/CHANGELOG.md
@@ -3,6 +3,12 @@
 All notable changes to the `repo-hygiene` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.19.10] - 2026-10-04
+
+### Changed
+
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.19.9] - 2026-10-04
 
 ### Changed
diff --git a/plugins/repo-hygiene/hooks/exec-bash.mjs b/plugins/repo-hygiene/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/repo-hygiene/hooks/exec-bash.mjs
+++ b/plugins/repo-hygiene/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/ruff-format/.claude-plugin/plugin.json b/plugins/ruff-format/.claude-plugin/plugin.json
index c05bc66bb8..8ac8caa092 100644
--- a/plugins/ruff-format/.claude-plugin/plugin.json
+++ b/plugins/ruff-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "ruff-format",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Auto-format and lint Python on edit via Ruff, only when a Ruff config governs the repo, using the consuming repo's own Ruff config.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/ruff-format/CHANGELOG.md b/plugins/ruff-format/CHANGELOG.md
index 50e55e59c2..f071ea4557 100644
--- a/plugins/ruff-format/CHANGELOG.md
+++ b/plugins/ruff-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `ruff-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.9.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.9.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/ruff-format/hooks/exec-bash.mjs b/plugins/ruff-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/ruff-format/hooks/exec-bash.mjs
+++ b/plugins/ruff-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/ruff-format/hooks/hooks.json b/plugins/ruff-format/hooks/hooks.json
index f823be8378..859e290351 100644
--- a/plugins/ruff-format/hooks/hooks.json
+++ b/plugins/ruff-format/hooks/hooks.json
@@ -32,6 +32,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -49,6 +50,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/session-flow/.claude-plugin/plugin.json b/plugins/session-flow/.claude-plugin/plugin.json
index f224537761..27a2487845 100644
--- a/plugins/session-flow/.claude-plugin/plugin.json
+++ b/plugins/session-flow/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "session-flow",
-  "version": "0.49.0",
+  "version": "0.49.1",
   "description": "Session lifecycle: workflow (next stage), handoff (save-point, resume prompt), continue-in-background, keep-going (resume after interruption or stall), find-handoff (recover a lost handoff), clean-stop (durable stopping point), retro and running-retro (retrospectives), audit-sessions, orient (where the session stands), orchestrate (delegation imperatives), reanchor (verify assumptions), reconcile (retire finished work), show-options (ranked skill menu), tidy-work (.work tiers), check, setup.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/session-flow/CHANGELOG.md b/plugins/session-flow/CHANGELOG.md
index 0489a614bb..0173d8640e 100644
--- a/plugins/session-flow/CHANGELOG.md
+++ b/plugins/session-flow/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog: session-flow plugin
 
+## [0.49.1] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+- `/session-flow:audit-sessions` re-collects the transcript store only when the collector inputs have changed (#6257).
+
 ## [0.49.0] - 2026-10-04
 
 ### Changed
diff --git a/plugins/session-flow/hooks/exec-bash.mjs b/plugins/session-flow/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/session-flow/hooks/exec-bash.mjs
+++ b/plugins/session-flow/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/session-flow/hooks/hooks.json b/plugins/session-flow/hooks/hooks.json
index e4d0073c73..7a8a4d9a05 100644
--- a/plugins/session-flow/hooks/hooks.json
+++ b/plugins/session-flow/hooks/hooks.json
@@ -17,6 +17,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/session-flow/skills/audit-sessions/SKILL.md b/plugins/session-flow/skills/audit-sessions/SKILL.md
index 3f4881ff54..9526d95824 100644
--- a/plugins/session-flow/skills/audit-sessions/SKILL.md
+++ b/plugins/session-flow/skills/audit-sessions/SKILL.md
@@ -67,11 +67,21 @@ the scripts' own defaults differ (collect keeps records forever).
   --retention-days "$RETENTION" --excerpt-chars "$EXCERPT_CHARS" --excerpt-words "$EXCERPT_WORDS"
 ```
 
-Collect is incremental: it skips sessions whose transcript is unchanged, re-ingests them when the
-excerpt options or plugin version changed, and drops records older than the retention window. The first run on a machine reads every transcript (about 70 s for 2.6 GB
-of transcripts, measured 2026-10-02 on Claude Code 2.1.287; recheck when a first run on a machine
-of similar size exceeds 300 s), so give that call a Bash timeout of 600000 ms or run it in the
-background. Later runs take under a second when nothing changed.
+Collect is incremental: it skips sessions whose transcript is unchanged and drops records older
+than the retention window. A plugin version change alone re-reads nothing. It re-reads every
+transcript (a full re-read) on:
+
+- the first run on a machine;
+- the first run after the collector's code or redaction rules change (the files hashed into
+  `collector_digest`, listed in `reference/store-layout.md`);
+- a changed excerpt option;
+- redaction starting or stopping failing closed;
+- `--force`.
+
+A full re-read takes about 70 s for 2.6 GB of transcripts (measured 2026-10-02 on Claude Code
+2.1.287; recheck when a first run on a machine of similar size exceeds 300 s), so give any run that
+may be one a Bash timeout of 600000 ms or run it in the background. Other runs take under a second
+when nothing changed.
 
 Exit 2 means the data directory or the projects root is unusable: report the summary and stop.
 Exit 1 is a partial ingest or degraded redaction: report it and continue.
diff --git a/plugins/session-flow/skills/audit-sessions/reference/store-layout.md b/plugins/session-flow/skills/audit-sessions/reference/store-layout.md
index 0f719c4c4e..a3f078b584 100644
--- a/plugins/session-flow/skills/audit-sessions/reference/store-layout.md
+++ b/plugins/session-flow/skills/audit-sessions/reference/store-layout.md
@@ -20,8 +20,8 @@ D/audit-sessions/
   itself is not stored because it encodes the working directory unredacted.
 - **One JSON file per session, replaced atomically.** Re-collecting a session rewrites its file, so
   a repeated run never double-counts. Collect skips a session whose transcript fingerprint is
-  unchanged, unless its record was written by another plugin version, under other excerpt
-  settings, or while redaction was failing closed and now is not (or the reverse); `--force`
+  unchanged, unless its record was written by a collector with another `collector_digest`, under
+  other excerpt settings, or while redaction was failing closed and now is not (or the reverse); `--force`
   re-ingests it regardless. Lowering `audit_sessions_excerpt_chars` to 0 therefore removes stored
   excerpts, titles and agent names on the next collect.
 - **Transcript text kept.** A record stores these strings from the transcript, each redacted before
@@ -70,7 +70,12 @@ D/audit-sessions/
 
 ## Schema versioning
 
-- Records carry `"schema": "session-record/v1"` and the plugin version that wrote them.
+- Records carry `"schema": "session-record/v1"`, the plugin version that wrote them
+  (`collector_version`, provenance only) and `collector_digest`: SHA-256 over the files that shape
+  a record, CRLF read as LF. Those files are `collect.py`, `census.py` and `redact.py`,
+  `vendor/gitleaks/gitleaks-rules.json`, and the plugin's `scripts/transcript_reader.py` and
+  `lib/state-key.sh` (`COLLECTOR_INPUTS` in `collect.py`). A record without the digest is
+  re-ingested once.
 - New fields are added within v1, and readers treat a missing field as null.
 - A breaking change moves the store to `store/v2/` and ships a v1-to-v2 migrator in `collect.py`.
   The store cannot be rebuilt from transcripts after Claude Code has swept them.
diff --git a/plugins/session-flow/skills/audit-sessions/scripts/collect.py b/plugins/session-flow/skills/audit-sessions/scripts/collect.py
index f3ba3fa5b9..0fddfb5316 100755
--- a/plugins/session-flow/skills/audit-sessions/scripts/collect.py
+++ b/plugins/session-flow/skills/audit-sessions/scripts/collect.py
@@ -11,9 +11,9 @@
 under `D/audit-sessions/store/v1/`, the machine-wide store `sweep.py` reads; a transcript Claude
 Code set aside (`<session>.orphaned-*.jsonl`) is skipped and counted, not ingested, and a record an
 earlier collector stored for one is deleted. A session whose
-fingerprint matches its stored record is skipped, unless that record was written by another
-collector version, under other excerpt limits, or with redaction failing closed where it now
-works or the reverse. With a retention window, records of sessions
+fingerprint matches its stored record is skipped, unless that record was written by a collector
+whose code or rules differ (the COLLECTOR_INPUTS digest), under other excerpt limits, or with
+redaction failing closed where it now works or the reverse. With a retention window, records of sessions
 that ended before it are pruned and such sessions are not ingested. Typed turns of at most
 `--excerpt-words` words right after an assistant message keep an excerpt, redacted by redact.py
 and then cut to `--excerpt-chars`; when redaction fails closed no excerpt is stored and the run
@@ -58,6 +58,16 @@
 DRIFT_SCHEMA = "audit-sessions.drift/v1"
 RECORD_SCHEMA = "session-record/v1"
 STATE_KEY = PLUGIN_ROOT / "lib" / "state-key.sh"
+# Every file that shapes a stored record, relative to PLUGIN_ROOT: a change to any of them
+# re-ingests every session, and a change elsewhere in the plugin (its version) does not.
+COLLECTOR_INPUTS = (
+    "skills/audit-sessions/scripts/collect.py",
+    "skills/audit-sessions/scripts/census.py",
+    "skills/audit-sessions/scripts/redact.py",
+    "scripts/transcript_reader.py",
+    "skills/audit-sessions/vendor/gitleaks/gitleaks-rules.json",
+    "lib/state-key.sh",
+)
 HEAD_BYTES = 4096
 
 COMMAND_RE = re.compile(r"<command-name>/?([^<\s]+)</command-name>")
@@ -130,6 +140,18 @@ def collector_version() -> str:
     return manifest.get("version", "unknown")
 
 
+def collector_digest() -> str:
+    """SHA-256 over COLLECTOR_INPUTS in order, CRLF read as LF so a checkout's line endings do not count."""
+    digest = hashlib.sha256()
+    for relative in COLLECTOR_INPUTS:
+        try:
+            data = (PLUGIN_ROOT / relative).read_bytes().replace(b"\r\n", b"\n")
+        except OSError:
+            data = b"<missing>"
+        digest.update(relative.encode("utf-8") + b"\0" + hashlib.sha256(data).digest())
+    return digest.hexdigest()
+
+
 def store_dir(data_dir: Path) -> Path:
     return data_dir / "audit-sessions" / "store" / "v1" / "sessions"
 
@@ -620,6 +642,7 @@ def build_record(
     fp: dict,
     *,
     version: str,
+    digest: str,
     redactor: redact.Redactor,
     identity: RepoIdentity,
     excerpt_chars: int,
@@ -642,6 +665,7 @@ def build_record(
     return {
         "schema": RECORD_SCHEMA,
         "collector_version": version,
+        "collector_digest": digest,
         "excerpt_limits": {"chars": excerpt_chars, "words": excerpt_words},
         "ingested_at": _iso(time.time()),
         "session_id": main.stem,
@@ -739,7 +763,7 @@ def build_record(
 def stored_policy(record: dict) -> tuple:
     """The settings besides the transcript that shaped a record's stored text; None where a field is missing."""
     redaction = _obj(record.get("redaction"))
-    return record.get("collector_version"), record.get("excerpt_limits"), redaction.get("excerpts_suppressed")
+    return record.get("collector_digest"), record.get("excerpt_limits"), redaction.get("excerpts_suppressed")
 
 
 def load_store(store: Path) -> dict[Path, tuple[dict | None, tuple, float | None]]:
@@ -778,11 +802,12 @@ def cmd_collect(args: argparse.Namespace) -> int:
     cutoff = time.time() - args.retention_days * 86400 if args.retention_days else None
     wanted = set(args.session or ())
     version = collector_version()
+    digest = collector_digest()
     redactor = redact.load_redactor()
     identity = RepoIdentity()
     index = load_store(store)
     # A record stored under other settings is re-ingested, so a lowered excerpt limit reaches old records.
-    policy = (version, {"chars": args.excerpt_chars, "words": args.excerpt_words}, redactor.fail_closed)
+    policy = (digest, {"chars": args.excerpt_chars, "words": args.excerpt_words}, redactor.fail_closed)
     scanned = ingested = skipped = expired = orphaned = purged = too_long = 0
     failed: list[dict] = []
     unknown_types: Counter = Counter()
@@ -821,6 +846,7 @@ def cmd_collect(args: argparse.Namespace) -> int:
                 subagents,
                 fp,
                 version=version,
+                digest=digest,
                 redactor=redactor,
                 identity=identity,
                 excerpt_chars=args.excerpt_chars,
diff --git a/plugins/session-flow/skills/audit-sessions/scripts/tests/test_collect.py b/plugins/session-flow/skills/audit-sessions/scripts/tests/test_collect.py
index 3d094785d3..3004463465 100644
--- a/plugins/session-flow/skills/audit-sessions/scripts/tests/test_collect.py
+++ b/plugins/session-flow/skills/audit-sessions/scripts/tests/test_collect.py
@@ -271,7 +271,7 @@ def test_changed_excerpt_words_reingests(data_dir, multi):
 @pytest.mark.parametrize(
     "edit",
     [
-        pytest.param(lambda rec: rec.update(collector_version="0.0.1"), id="other-collector-version"),
+        pytest.param(lambda rec: rec.update(collector_digest="0" * 64), id="other-collector-digest"),
         pytest.param(lambda rec: rec.pop("excerpt_limits", None), id="written-before-excerpt-limits"),
     ],
 )
@@ -288,6 +288,185 @@ def test_record_from_another_collection_policy_is_reingested(data_dir, multi, ed
     assert "excerpt_limits" in records(data_dir)["sess-a2"]
 
 
+def test_record_without_digest_is_reingested_once(data_dir, multi):
+    root, _ = multi
+    assert collect(data_dir, root).returncode == 0
+    store = data_dir / "audit-sessions" / "store" / "v1" / "sessions"
+    (path,) = store.glob("p-*/sess-a2.json")
+    rec = json.loads(path.read_text(encoding="utf-8"))
+    del rec["collector_digest"]
+    path.write_text(json.dumps(rec), encoding="utf-8")
+    data = envelope(collect(data_dir, root))["data"]
+    assert (data["ingested"], data["skipped_unchanged"]) == (1, 2)
+    data = envelope(collect(data_dir, root))["data"]
+    assert (data["ingested"], data["skipped_unchanged"]) == (0, 3)
+    rec = records(data_dir)["sess-a2"]
+    assert rec["collector_version"] and len(rec["collector_digest"]) == 64
+
+
+def test_new_transcript_is_ingested_and_the_rest_skipped(data_dir, multi):
+    root, _ = multi
+    assert collect(data_dir, root).returncode == 0
+    shutil.copy(root / "proj-b" / "sess-b1.jsonl", root / "proj-b" / "sess-b2.jsonl")
+    data = envelope(collect(data_dir, root))["data"]
+    assert (data["ingested"], data["skipped_unchanged"], data["store_records"]) == (1, 3, 4)
+
+
+def test_skipping_run_leaves_the_store_a_forced_run_would_write(data_dir, multi):
+    root, _ = multi
+    assert collect(data_dir, root).returncode == 0
+    assert envelope(collect(data_dir, root))["data"]["skipped_unchanged"] == 3
+    skipped = records(data_dir)
+    assert envelope(collect(data_dir, root, "--force"))["data"]["ingested"] == 3
+    forced = records(data_dir)
+    for rec in (*skipped.values(), *forced.values()):
+        rec.pop("ingested_at")
+    assert skipped == forced
+
+
+# --- the collector digest: what forces a full re-ingest ---
+
+# The files that decide what a record holds, relative to the plugin root, as the requirement lists them.
+HASHED_INPUTS = (
+    "skills/audit-sessions/scripts/collect.py",
+    "skills/audit-sessions/scripts/census.py",
+    "skills/audit-sessions/scripts/redact.py",
+    "scripts/transcript_reader.py",
+    "skills/audit-sessions/vendor/gitleaks/gitleaks-rules.json",
+    "lib/state-key.sh",
+)
+PLUGIN_ROOT = SCRIPTS.parents[2]
+
+
+@pytest.fixture
+def plugin_copy(tmp_path):
+    """A copy of the plugin files collect.py runs or reads, laid out as in the plugin."""
+    dest = tmp_path / "plugin" / "session-flow"
+    for relative in (*HASHED_INPUTS, ".claude-plugin/plugin.json"):
+        (dest / relative).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(PLUGIN_ROOT / relative, dest / relative)
+    return dest
+
+
+def collect_with(plugin: Path, data_dir: Path, root: Path, *extra: str) -> dict:
+    script = plugin / "skills" / "audit-sessions" / "scripts" / "collect.py"
+    args = [sys.executable, str(script), "collect", "--data-dir", str(data_dir), "--projects-root", str(root), *extra]
+    result = subprocess.run(args, capture_output=True, text=True, encoding="utf-8", timeout=60)
+    assert result.returncode == 0, result.stderr
+    return envelope(result)["data"]
+
+
+def counts(data: dict) -> tuple[int, int]:
+    return data["ingested"], data["skipped_unchanged"]
+
+
+def test_collector_inputs_are_the_listed_files():
+    import collect as collector
+
+    assert collector.COLLECTOR_INPUTS == HASHED_INPUTS
+
+
+@pytest.mark.parametrize("relative", HASHED_INPUTS)
+def test_change_to_a_collector_input_reingests_every_session(data_dir, multi, plugin_copy, relative):
+    root, _ = multi
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (3, 0)
+    with (plugin_copy / relative).open("ab") as handle:
+        handle.write(b"\n")
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (3, 0)
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (0, 3)
+
+
+def test_plugin_version_change_alone_skips_every_session(data_dir, multi, plugin_copy):
+    root, _ = multi
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (3, 0)
+    manifest_path = plugin_copy / ".claude-plugin" / "plugin.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["version"] = "999.0.0"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (0, 3)
+    # Skipped records keep the version that wrote them; it is provenance, not policy.
+    assert records(data_dir)["sess-a1"]["collector_version"] != "999.0.0"
+    assert counts(collect_with(plugin_copy, data_dir, root, "--force")) == (3, 0)
+    assert records(data_dir)["sess-a1"]["collector_version"] == "999.0.0"
+
+
+def test_line_ending_change_alone_skips_every_session(data_dir, multi, plugin_copy):
+    root, _ = multi
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (3, 0)
+    script = plugin_copy / "skills" / "audit-sessions" / "scripts" / "collect.py"
+    lf = script.read_bytes().replace(b"\r\n", b"\n")
+    script.write_bytes(lf.replace(b"\n", b"\r\n"))
+    assert counts(collect_with(plugin_copy, data_dir, root)) == (0, 3)
+
+
+AUDIT_DRIVER = """\
+import json, os, runpy, sys
+script, out = sys.argv[1], sys.argv[2]
+opened, commands = set(), []
+def hook(event, args):
+    if event == "open" and isinstance(args[0], (str, bytes, os.PathLike)):
+        opened.add(os.fsdecode(args[0]))
+    elif event == "subprocess.Popen":
+        argv = args[1]
+        commands.append(argv if isinstance(argv, str) else " ".join(map(os.fsdecode, argv)))
+sys.addaudithook(hook)
+sys.path.insert(0, os.path.dirname(script))
+sys.argv = [script, *sys.argv[3:]]
+try:
+    runpy.run_path(script, run_name="__main__")
+except SystemExit:
+    pass
+opened.update(m.__file__ for m in list(sys.modules.values()) if getattr(m, "__file__", None))
+with open(out, "w", encoding="utf-8") as handle:
+    json.dump({"opened": sorted(opened), "commands": commands}, handle)
+"""
+
+
+def unhashed_plugin_files(plugin: Path, data_dir: Path, root: Path, tmp_path: Path) -> set[str]:
+    """Plugin files a collect run imports, opens or executes that are not hashed (plugin.json is provenance)."""
+    driver, out = tmp_path / "audit_driver.py", tmp_path / "touched.json"
+    driver.write_text(AUDIT_DRIVER, encoding="utf-8")
+    plugin = plugin.resolve()
+    script = plugin / "skills" / "audit-sessions" / "scripts" / "collect.py"
+    args = [sys.executable, str(driver), str(script), str(out), "collect", "--data-dir", str(data_dir),
+            "--projects-root", str(root)]
+    result = subprocess.run(args, capture_output=True, text=True, encoding="utf-8", timeout=60)
+    assert result.returncode == 0, result.stderr
+    assert envelope(result)["data"]["ingested"] == 3
+    trace = json.loads(out.read_text(encoding="utf-8"))
+    commands = os.path.normcase(" ".join(trace["commands"]))
+    base = os.path.normcase(str(plugin)) + os.sep
+    touched = {os.path.normcase(str(p)) for p in plugin.rglob("*") if p.is_file() and os.path.normcase(str(p)) in commands}
+    touched.update(os.path.normcase(str(Path(name).resolve())) for name in trace["opened"])
+    relative = {Path(p[len(base):]).as_posix() for p in touched if p.startswith(base) and "__pycache__" not in p}
+    return relative - {casefold(p) for p in (*HASHED_INPUTS, ".claude-plugin/plugin.json")}
+
+
+def casefold(relative: str) -> str:
+    """A relative path as `unhashed_plugin_files` reports it: posix separators, platform case folding."""
+    return Path(os.path.normcase(relative)).as_posix()
+
+
+def test_every_plugin_file_collect_reads_is_hashed(data_dir, multi, tmp_path):
+    root, _ = multi
+    assert unhashed_plugin_files(PLUGIN_ROOT, data_dir, root, tmp_path) == set()
+
+
+def test_unhashed_import_or_read_is_caught(data_dir, multi, plugin_copy, tmp_path):
+    root, _ = multi
+    scripts = plugin_copy / "skills" / "audit-sessions" / "scripts"
+    (scripts / "extra.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (plugin_copy / "lib" / "rules.txt").write_text("x\n", encoding="utf-8")
+    collect_py = scripts / "collect.py"
+    source = collect_py.read_text(encoding="utf-8")
+    hook = 'import extra  # noqa\n(PLUGIN_ROOT / "lib" / "rules.txt").read_text()\nSCHEMA = '
+    collect_py.write_text(source.replace("SCHEMA = ", hook, 1), encoding="utf-8")
+    assert unhashed_plugin_files(plugin_copy, data_dir, root, tmp_path) == {
+        casefold("skills/audit-sessions/scripts/extra.py"),
+        casefold("lib/rules.txt"),
+    }
+
+
 def test_session_and_since_filters(data_dir, multi):
     root, _ = multi
     data = envelope(collect(data_dir, root, "--session", "sess-b1"))["data"]
diff --git a/plugins/skill-quality/.claude-plugin/plugin.json b/plugins/skill-quality/.claude-plugin/plugin.json
index 1a2afd1f28..f14ff80578 100644
--- a/plugins/skill-quality/.claude-plugin/plugin.json
+++ b/plugins/skill-quality/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "skill-quality",
-  "version": "0.28.3",
+  "version": "0.28.4",
   "description": "Skill-authoring QA tooling (skill-quality:check): a static contract checker running twenty-six deterministic checks over a Claude Code skill (frontmatter, invocation mode, description, listing cap, trigger keywords, line caps, broken refs, markdownlint, gotchas, evals), a shared skill-listing budget reporter, an evals.json schema with an eval-quality lint, and a measure-invocation harness that scores description auto-invocation probes on train and validation splits.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/skill-quality/CHANGELOG.md b/plugins/skill-quality/CHANGELOG.md
index 75516f39fe..95728a7efc 100644
--- a/plugins/skill-quality/CHANGELOG.md
+++ b/plugins/skill-quality/CHANGELOG.md
@@ -3,6 +3,12 @@
 All notable changes to the `skill-quality` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.28.4] - 2026-10-04
+
+### Fixed
+
+- `/skill-quality:check listing-budget` reports the configured listing budget when run with `--from-settings` (#6261).
+
 ## [0.28.3] - 2026-10-04
 
 ### Changed
diff --git a/plugins/skill-quality/scripts/check-listing-budget.sh b/plugins/skill-quality/scripts/check-listing-budget.sh
index 826c5022aa..81996344c1 100755
--- a/plugins/skill-quality/scripts/check-listing-budget.sh
+++ b/plugins/skill-quality/scripts/check-listing-budget.sh
@@ -38,12 +38,26 @@
 # The aggregate budget is inherently a MACHINE-DEPENDENT estimate: it scales
 # with the live model's context window and the resolved
 # skillListingBudgetFraction, which a consumer's settings.json can override.
-# This script therefore never asserts a live value it cannot observe — it
-# reports against a documented, overridable default and always exits 0
-# (advisory only, never blocking CI or a pre-commit hook). `/doctor` is the
-# live, authoritative source for the resolved value and biggest contributors
-# on a given machine and model; this script is the static, reproducible
-# proxy that runs without a live session.
+# Two modes, and the script always exits 0 on a report (advisory only, never
+# blocking CI or a pre-commit hook):
+#   - Default-consumer mode (no flag): reads no settings and no
+#     SLASH_COMMAND_TOOL_CHAR_BUDGET, and reports against the documented
+#     default, so the same tree gives the same report on any machine. This is
+#     what CI measures.
+#   - Configured-machine mode (--from-settings): reports the budget THIS
+#     machine resolves. SLASH_COMMAND_TOOL_CHAR_BUDGET, when set in the
+#     environment, is the budget. Otherwise skillListingBudgetFraction is read
+#     from the first settings file that sets it, in precedence order: project
+#     .claude/settings.local.json, project .claude/settings.json (project =
+#     CLAUDE_PROJECT_DIR, else the git root), then
+#     ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json. Managed policy and a
+#     settings `env` block are NOT read; the report says so.
+# The context window is per model and not on disk, so unless
+# CHECK_SKILL_LISTING_CONTEXT_TOKENS pins one, a resolved fraction is reported
+# as a band: the budget at a 200000-token and a 1000000-token window, with a
+# verdict per row. `/doctor` is the live, authoritative source for the
+# resolved value and biggest contributors on a given machine and model; this
+# script is the static, reproducible proxy that runs without a live session.
 #
 # The default budget (8000 chars) is the harness's own documented fallback —
 # SLASH_COMMAND_TOOL_CHAR_BUDGET's schema description: "The budget scales
@@ -64,8 +78,23 @@
 # re-derives the matching constant here and in check-skill.sh; each fleet
 # audit re-runs this record.
 #
+# Record for the --from-settings inputs. Claim: the settings file scopes and
+# their order (managed, command line, project local, shared project, user),
+# skillListingBudgetFraction being settable in any file, CLAUDE_CONFIG_DIR
+# relocating ~/.claude, and SLASH_COMMAND_TOOL_CHAR_BUDGET setting a fixed
+# character count. That the env var outranks the fraction is inferred from
+# the docs calling it an override; no page states the order. The 200000 and
+# 1000000 band windows and 4 chars/token are this script's assumptions, not
+# documented values. Basis: https://code.claude.com/docs/en/settings
+# (settings precedence), https://code.claude.com/docs/en/settings-reference
+# (skillListingBudgetFraction), https://code.claude.com/docs/en/env-vars
+# (CLAUDE_CONFIG_DIR, SLASH_COMMAND_TOOL_CHAR_BUDGET),
+# https://code.claude.com/docs/en/skills (skill descriptions are cut short).
+# As of 2026-10-04. Recheck trigger: any of those pages changing a scope, its
+# order, the env var's meaning, or the budget's basis.
+#
 # Usage:
-#   check-listing-budget.sh [<skills-root> ...]
+#   check-listing-budget.sh [--from-settings] [<skills-root> ...]
 #   check-listing-budget.sh --help
 #
 # No args: resolves ONE root via the same convention ladder as check-skill.sh
@@ -99,7 +128,10 @@
 #                                          for a 1M-context model)
 #   CHECK_SKILL_LISTING_BUDGET_FRACTION - default 0.01 (skillListingBudgetFraction's
 #                                          documented default) — set to match
-#                                          a machine's configured value
+#                                          a machine's configured value; it
+#                                          outranks settings files, and set
+#                                          without a window it reports the
+#                                          200000/1000000-token band
 #   CHECK_SKILL_LISTING_CHARS_PER_TOKEN - default 4 — set only if a more
 #                                          precise ratio is known
 #   CHECK_SKILL_LISTING_MAX_DESC_CHARS  - per-entry truncation cap applied
@@ -131,10 +163,21 @@ usage() {
   awk 'NR > 1 && !/^#/ { exit } NR > 1 { sub(/^# ?/, ""); print }' "${BASH_SOURCE[0]}"
 }
 
-if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
-  usage
-  exit 0
-fi
+FROM_SETTINGS=0
+while [[ "${1:-}" == -* ]]; do
+  case "$1" in
+  --help | -h)
+    usage
+    exit 0
+    ;;
+  --from-settings) FROM_SETTINGS=1 ;;
+  *)
+    printf 'Error: unknown option: %s (run with --help)\n' "$1" >&2
+    exit 2
+    ;;
+  esac
+  shift
+done
 
 # Git is optional. Explicit skill-root args (and CHECK_SKILL_SKILLS_ROOT /
 # CLAUDE_PROJECT_DIR) work against plain directory trees such as marketplace
@@ -182,46 +225,106 @@ require_positive_number CHECK_SKILL_LISTING_MAX_DESC_CHARS "$MAX_DESC_CHARS" int
 MAX_DESC_CHARS="$(to_decimal "$MAX_DESC_CHARS")"
 JOINER_CHARS=3 # the literal " - " the harness inserts between description and when_to_use
 
-# Precedence matches the documented contract above: a fixed aggregate budget
-# SKIPS the token/fraction reconstruction. Checking it first is what makes that
-# sentence true.
+# Every budget the report compares against, one row each: a single row, or a
+# band of two when a fraction is known but the window is not. BUDGET_IS_DEFAULT
+# keeps the word "configured" out of the summary when nothing was configured.
+BUDGETS=()
+SOURCES=()
+BUDGET_IS_DEFAULT=0
+FRACTION=""
+FRACTION_SOURCE=""
+
+# Append TOKENS x CHARS_PER_TOKEN x FRACTION as one budget row.
+add_reconstructed_row() {
+  local tokens="$1" chars
+  if ! chars="$(awk -v t="$tokens" -v c="$CHARS_PER_TOKEN" -v f="$FRACTION" \
+    'BEGIN { printf "%d", t * c * f }' 2>/dev/null)" || [[ -z "$chars" ]] || ((chars <= 0)); then
+    printf 'Error: could not compute a budget from %s tokens x %s chars/token x %s\n' \
+      "$tokens" "$CHARS_PER_TOKEN" "$FRACTION" >&2
+    exit 2
+  fi
+  BUDGETS+=("$chars")
+  SOURCES+=("reconstructed: $tokens tokens x $CHARS_PER_TOKEN chars/token x $FRACTION")
+}
+
+# The first settings file, in precedence order, that sets the fraction to a
+# number. One jq process over every existing file, not one per file.
+read_settings_fraction() {
+  local project_dir="${CLAUDE_PROJECT_DIR:-}" config_dir="${CLAUDE_CONFIG_DIR:-}" f hit
+  local candidates=() existing=()
+  [[ -z "$project_dir" && "$HAVE_GIT" == 1 ]] && project_dir="$REPO_ROOT"
+  [[ -n "$project_dir" ]] && candidates+=("$project_dir/.claude/settings.local.json" "$project_dir/.claude/settings.json")
+  [[ -z "$config_dir" && -n "${HOME:-}" ]] && config_dir="$HOME/.claude"
+  [[ -n "$config_dir" ]] && candidates+=("$config_dir/settings.json")
+  for f in "${candidates[@]}"; do
+    [[ -f "$f" ]] && existing+=("$f")
+  done
+  FRACTION="0.01"
+  FRACTION_SOURCE="documented default (no settings file read sets skillListingBudgetFraction)"
+  ((${#existing[@]} > 0)) || return 0
+  if ! command -v jq >/dev/null 2>&1; then
+    printf 'Error: --from-settings needs jq to read %s\n' "${existing[*]}" >&2
+    exit 2
+  fi
+  if ! hit="$(jq -r 'objects | select((.skillListingBudgetFraction | type) == "number")
+      | "\(input_filename)\t\(.skillListingBudgetFraction)"' "${existing[@]}" | tr -d '\r')"; then
+    printf 'Error: could not parse settings JSON among: %s\n' "${existing[*]}" >&2
+    exit 2
+  fi
+  hit="${hit%%$'\n'*}"
+  [[ -n "$hit" ]] || return 0
+  FRACTION="${hit##*$'\t'}"
+  FRACTION_SOURCE="settings:${hit%$'\t'*}"
+  require_positive_number "skillListingBudgetFraction in ${hit%$'\t'*}" "$FRACTION" num
+}
+
+# Precedence: a fixed aggregate budget SKIPS the token/fraction reconstruction,
+# so it is checked first. In --from-settings mode SLASH_COMMAND_TOOL_CHAR_BUDGET
+# is the next fixed budget. Otherwise the fraction (override, then settings in
+# --from-settings mode) is reconstructed at the pinned window, or as a band.
 if [[ -n "${CHECK_SKILL_LISTING_BUDGET_CHARS:-}" ]]; then
-  BUDGET_CHARS="$CHECK_SKILL_LISTING_BUDGET_CHARS"
-  require_positive_number CHECK_SKILL_LISTING_BUDGET_CHARS "$BUDGET_CHARS" int
-  BUDGET_CHARS="$(to_decimal "$BUDGET_CHARS")"
-  BUDGET_SOURCE="override (CHECK_SKILL_LISTING_BUDGET_CHARS)"
+  require_positive_number CHECK_SKILL_LISTING_BUDGET_CHARS "$CHECK_SKILL_LISTING_BUDGET_CHARS" int
+  BUDGETS+=("$(to_decimal "$CHECK_SKILL_LISTING_BUDGET_CHARS")")
+  SOURCES+=("override (CHECK_SKILL_LISTING_BUDGET_CHARS)")
   if [[ -n "${CHECK_SKILL_LISTING_CONTEXT_TOKENS:-}" ]]; then
     printf 'Note: CHECK_SKILL_LISTING_BUDGET_CHARS takes precedence; ignoring CHECK_SKILL_LISTING_CONTEXT_TOKENS=%s\n' \
       "$CHECK_SKILL_LISTING_CONTEXT_TOKENS" >&2
   fi
-elif [[ -n "${CHECK_SKILL_LISTING_CONTEXT_TOKENS:-}" ]]; then
-  CONTEXT_TOKENS="$CHECK_SKILL_LISTING_CONTEXT_TOKENS"
+elif ((FROM_SETTINGS)) && [[ -n "${SLASH_COMMAND_TOOL_CHAR_BUDGET:-}" ]]; then
+  require_positive_number SLASH_COMMAND_TOOL_CHAR_BUDGET "$SLASH_COMMAND_TOOL_CHAR_BUDGET" int
+  BUDGETS+=("$(to_decimal "$SLASH_COMMAND_TOOL_CHAR_BUDGET")")
+  SOURCES+=("env:SLASH_COMMAND_TOOL_CHAR_BUDGET")
+else
   CHARS_PER_TOKEN="${CHECK_SKILL_LISTING_CHARS_PER_TOKEN:-4}"
-  FRACTION="${CHECK_SKILL_LISTING_BUDGET_FRACTION:-0.01}"
-  require_positive_number CHECK_SKILL_LISTING_CONTEXT_TOKENS "$CONTEXT_TOKENS" int
-  CONTEXT_TOKENS="$(to_decimal "$CONTEXT_TOKENS")"
-  require_positive_number CHECK_SKILL_LISTING_CHARS_PER_TOKEN "$CHARS_PER_TOKEN" num
-  require_positive_number CHECK_SKILL_LISTING_BUDGET_FRACTION "$FRACTION" num
-  if ! BUDGET_CHARS="$(awk -v t="$CONTEXT_TOKENS" -v c="$CHARS_PER_TOKEN" -v f="$FRACTION" \
-    'BEGIN { printf "%d", t * c * f }' 2>/dev/null)" || [[ -z "$BUDGET_CHARS" ]] || ((BUDGET_CHARS <= 0)); then
-    printf 'Error: could not compute a budget from CHECK_SKILL_LISTING_CONTEXT_TOKENS=%s CHECK_SKILL_LISTING_CHARS_PER_TOKEN=%s CHECK_SKILL_LISTING_BUDGET_FRACTION=%s\n' \
-      "$CONTEXT_TOKENS" "$CHARS_PER_TOKEN" "$FRACTION" >&2
-    exit 2
+  if [[ -n "${CHECK_SKILL_LISTING_BUDGET_FRACTION:-}" ]]; then
+    FRACTION="$CHECK_SKILL_LISTING_BUDGET_FRACTION"
+    FRACTION_SOURCE="override (CHECK_SKILL_LISTING_BUDGET_FRACTION)"
+    require_positive_number CHECK_SKILL_LISTING_BUDGET_FRACTION "$FRACTION" num
+  elif ((FROM_SETTINGS)); then
+    read_settings_fraction
+    [[ "$FRACTION_SOURCE" == documented* ]] && BUDGET_IS_DEFAULT=1
+  fi
+  if [[ -n "${CHECK_SKILL_LISTING_CONTEXT_TOKENS:-}" ]]; then
+    require_positive_number CHECK_SKILL_LISTING_CONTEXT_TOKENS "$CHECK_SKILL_LISTING_CONTEXT_TOKENS" int
+    require_positive_number CHECK_SKILL_LISTING_CHARS_PER_TOKEN "$CHARS_PER_TOKEN" num
+    [[ -n "$FRACTION" ]] || FRACTION="0.01"
+    BUDGET_IS_DEFAULT=0
+    add_reconstructed_row "$(to_decimal "$CHECK_SKILL_LISTING_CONTEXT_TOKENS")"
+  elif [[ -n "$FRACTION" ]]; then
+    require_positive_number CHECK_SKILL_LISTING_CHARS_PER_TOKEN "$CHARS_PER_TOKEN" num
+    add_reconstructed_row 200000
+    add_reconstructed_row 1000000
+  else
+    BUDGETS+=(8000)
+    SOURCES+=("documented default (SLASH_COMMAND_TOOL_CHAR_BUDGET fallback)")
+    BUDGET_IS_DEFAULT=1
   fi
-  BUDGET_SOURCE="reconstructed: $CONTEXT_TOKENS tokens x $CHARS_PER_TOKEN chars/token x $FRACTION"
-else
-  BUDGET_CHARS=8000
-  BUDGET_SOURCE="documented default (SLASH_COMMAND_TOOL_CHAR_BUDGET fallback)"
 fi
 
 # --- Resolve the roots to scan ----------------------------------------------
 
 ROOTS=()
 EXPLICIT_ROOTS=0
-if [[ "${1:-}" == -* ]]; then
-  printf 'Error: unknown option: %s (run with --help)\n' "$1" >&2
-  exit 2
-fi
 if (($# > 0)); then
   ROOTS=("$@")
   EXPLICIT_ROOTS=1
@@ -475,22 +578,55 @@ fi
 
 printf 'Shared listing-budget estimate over %d listing-eligible skill(s) across %d root(s):\n' "$ENTRY_COUNT" "$FOUND_ROOTS"
 printf '  aggregate: %d chars\n' "$TOTAL"
-printf '  budget:    %d chars (%s)\n' "$BUDGET_CHARS" "$BUDGET_SOURCE"
+BAND=0
+((${#BUDGETS[@]} > 1)) && BAND=1
+if ((BAND || FROM_SETTINGS)) && [[ -n "$FRACTION_SOURCE" ]]; then
+  printf '  fraction:  %s (%s)\n' "$FRACTION" "$FRACTION_SOURCE"
+fi
+if ((FROM_SETTINGS)); then
+  printf '  note:      managed policy and settings env blocks are not read; /doctor shows the resolved budget\n'
+fi
+# Rows are ascending, so the first is the smallest budget.
+BUDGET_CHARS="${BUDGETS[0]}"
+OVER_ROWS=0
+for i in "${!BUDGETS[@]}"; do
+  if ((BAND)); then
+    verdict="OK"
+    if ((TOTAL > BUDGETS[i])); then
+      verdict="WARN, over by $((TOTAL - BUDGETS[i])) chars"
+    fi
+    printf '  budget:    %d chars (%s): %s\n' "${BUDGETS[i]}" "${SOURCES[i]}" "$verdict"
+  else
+    printf '  budget:    %d chars (%s)\n' "${BUDGETS[i]}" "${SOURCES[i]}"
+  fi
+  ((TOTAL > BUDGETS[i])) && OVER_ROWS=$((OVER_ROWS + 1))
+done
+BASIS="configured"
+((BUDGET_IS_DEFAULT)) && BASIS="documented default"
+BUDGET_NOUN="the budget"
+((BAND)) && BUDGET_NOUN="the smallest budget"
 
 if ((TOTAL > BUDGET_CHARS)); then
   OVERFLOW=$((TOTAL - BUDGET_CHARS))
   MULT="$(awk -v t="$TOTAL" -v b="$BUDGET_CHARS" 'BEGIN { printf "%.1f", t / b }' 2>/dev/null || echo '?')"
-  printf 'WARN: aggregate exceeds the budget by %d chars (~%sx over) — Claude Code drops the\n' "$OVERFLOW" "$MULT"
+  printf 'WARN: aggregate exceeds %s by %d chars (~%sx over) — Claude Code drops the\n' "$BUDGET_NOUN" "$OVERFLOW" "$MULT"
   printf '      least-invoked skills'"'"' descriptions to name-only when this happens live.\n'
   printf '      Biggest contributors (entry chars, skill, root):\n'
   sort -t $'\t' -k1,1nr "$CONTRIB_FILE" | head -10 | while IFS=$'\t' read -r len name root; do
     printf '        %6d  %s  (%s)\n' "$len" "$name" "$root"
   done
-  printf '\nCHECK-LISTING-BUDGET: WARN — aggregate %d/%d chars over budget by %s at the configured budget.\n' \
-    "$TOTAL" "$BUDGET_CHARS" "$OVERFLOW"
+  if ((BAND)); then
+    printf '\nCHECK-LISTING-BUDGET: WARN — aggregate %d chars over %d of %d budgets at the %s fraction %s (smallest %d chars, over by %d).\n' \
+      "$TOTAL" "$OVER_ROWS" "${#BUDGETS[@]}" "$BASIS" "$FRACTION" "$BUDGET_CHARS" "$OVERFLOW"
+  else
+    printf '\nCHECK-LISTING-BUDGET: WARN — aggregate %d/%d chars over budget by %s at the %s budget.\n' \
+      "$TOTAL" "$BUDGET_CHARS" "$OVERFLOW" "$BASIS"
+  fi
   printf 'This is an estimate against a configurable default, not a live measurement — run\n'
   # shellcheck disable=SC2016  # single quotes deliberate: the backticks are literal, not shell expansion
   printf '`/doctor` in a live session for the authoritative resolved cost and contributors.\n'
+elif ((BAND)); then
+  printf 'CHECK-LISTING-BUDGET: OK — aggregate %d chars within every budget (smallest %d chars).\n' "$TOTAL" "$BUDGET_CHARS"
 else
   printf 'CHECK-LISTING-BUDGET: OK — aggregate %d/%d chars within budget.\n' "$TOTAL" "$BUDGET_CHARS"
 fi
diff --git a/plugins/skill-quality/scripts/check-listing-budget.test.sh b/plugins/skill-quality/scripts/check-listing-budget.test.sh
index cd67f5f099..9997b460cd 100755
--- a/plugins/skill-quality/scripts/check-listing-budget.test.sh
+++ b/plugins/skill-quality/scripts/check-listing-budget.test.sh
@@ -20,6 +20,14 @@ trap 'rm -rf "$TMP"' EXIT
 
 export GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null
 unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE GIT_COMMON_DIR GIT_PREFIX GIT_CONFIG 2>/dev/null || true
+# Never read the developer's real settings or inherit a budget override: every
+# settings file the reporter can see is a fixture under $TMP.
+unset SLASH_COMMAND_TOOL_CHAR_BUDGET CLAUDE_PROJECT_DIR CHECK_SKILL_SKILLS_ROOT \
+  CHECK_SKILL_LISTING_BUDGET_CHARS CHECK_SKILL_LISTING_CONTEXT_TOKENS \
+  CHECK_SKILL_LISTING_BUDGET_FRACTION CHECK_SKILL_LISTING_CHARS_PER_TOKEN \
+  CHECK_SKILL_LISTING_MAX_DESC_CHARS 2>/dev/null || true
+export HOME="$TMP/home"
+export CLAUDE_CONFIG_DIR="$TMP/home/.claude"
 git -C "$TMP" init -q
 git -C "$TMP" config user.email test@example.com
 git -C "$TMP" config user.name test
@@ -518,6 +526,141 @@ else
   fail "non-git CHECK_SKILL_SKILLS_ROOT should report OK (rc=$rc): $out"
 fi
 
+# --- Budget resolution from settings (--from-settings) ------------------------
+#
+# BIG_ROOT holds 27 skills whose 1600-char descriptions the per-entry cap trims
+# to 1536 each: 27 x 1536 = 41472 chars. At skillListingBudgetFraction 0.05 the
+# band is 200000 x 4 x 0.05 = 40000 (over by 1472) and 1000000 x 4 x 0.05 =
+# 200000 (within), so the two rows must carry different verdicts.
+BIG_ROOT="$TMP/big/skills"
+long_desc="$(printf '%1600s' '' | tr ' ' 'x')"
+for i in $(seq 1 27); do
+  make_skill "$BIG_ROOT" "big-$i" "$long_desc"
+done
+write_fraction() {
+  mkdir -p "$(dirname "$1")"
+  printf '{"skillListingBudgetFraction": %s}\n' "$2" >"$1"
+}
+# run_cfg <project-dir> <config-dir> [args...]: each case gets its own fixture
+# project and config dirs, so no case sees another's settings files. Source
+# paths are matched by their tail: a native Windows jq reports a C:/ spelling.
+run_cfg() {
+  local proj="$1" cfg="$2"
+  shift 2
+  (cd "$TMP" && CLAUDE_PROJECT_DIR="$proj" CLAUDE_CONFIG_DIR="$cfg" bash "$SUT" "$@")
+}
+
+# 21. A user-scope fraction of 0.05 names its file and reports both window rows.
+CFG21="$TMP/s21/config"
+write_fraction "$CFG21/settings.json" 0.05
+out="$(run_cfg "$TMP/s21/project" "$CFG21" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -q 'fraction:  0\.05 (settings:.*/s21/config/settings\.json)' <<<"$out" &&
+  grep -qF 'budget:    40000 chars (reconstructed: 200000 tokens x 4 chars/token x 0.05): WARN, over by 1472 chars' <<<"$out" &&
+  grep -qF 'budget:    200000 chars (reconstructed: 1000000 tokens x 4 chars/token x 0.05): OK' <<<"$out" &&
+  grep -q 'over 1 of 2 budgets at the configured fraction 0.05' <<<"$out"; then
+  pass "--from-settings reads a user-scope fraction and reports a verdict per window"
+else
+  fail "--from-settings should report 40000 (WARN) and 200000 (OK) from the user settings file (rc=$rc): $out"
+fi
+
+# 22. Precedence: project local beats shared project beats user.
+P22="$TMP/s22/project"
+CFG22="$TMP/s22/config"
+write_fraction "$P22/.claude/settings.local.json" 0.03
+write_fraction "$P22/.claude/settings.json" 0.02
+write_fraction "$CFG22/settings.json" 0.05
+out="$(run_cfg "$P22" "$CFG22" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -q 'fraction:  0\.03 (settings:.*/s22/project/\.claude/settings\.local\.json)' <<<"$out" &&
+  grep -qF 'budget:    24000 chars' <<<"$out" &&
+  grep -qF 'budget:    120000 chars' <<<"$out"; then
+  pass "--from-settings takes the project-local fraction over project and user"
+else
+  fail "project settings.local.json should win (0.03 -> 24000/120000) (rc=$rc): $out"
+fi
+rm "$P22/.claude/settings.local.json"
+out="$(run_cfg "$P22" "$CFG22" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -q 'fraction:  0\.02 (settings:.*/s22/project/\.claude/settings\.json)' <<<"$out" &&
+  grep -qF 'budget:    16000 chars' <<<"$out" &&
+  grep -qF 'budget:    80000 chars' <<<"$out"; then
+  pass "--from-settings takes the shared project fraction over the user one"
+else
+  fail "project settings.json should beat user settings (0.02 -> 16000/80000) (rc=$rc): $out"
+fi
+
+# 23. SLASH_COMMAND_TOOL_CHAR_BUDGET is the budget regardless of settings.
+out="$(cd "$TMP" && CLAUDE_PROJECT_DIR="$P22" CLAUDE_CONFIG_DIR="$CFG22" \
+  SLASH_COMMAND_TOOL_CHAR_BUDGET=12345 bash "$SUT" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -qF 'budget:    12345 chars (env:SLASH_COMMAND_TOOL_CHAR_BUDGET)' <<<"$out" &&
+  [[ "$(grep -c 'budget:    ' <<<"$out")" -eq 1 ]]; then
+  pass "SLASH_COMMAND_TOOL_CHAR_BUDGET fixes the budget over the settings fraction"
+else
+  fail "SLASH_COMMAND_TOOL_CHAR_BUDGET=12345 should be the only budget row (rc=$rc): $out"
+fi
+
+# 24. Without the flag (the default consumer CI measures) settings and the env
+#     budget are ignored, and the summary does not call the default configured.
+out="$(cd "$TMP" && CLAUDE_PROJECT_DIR="$P22" CLAUDE_CONFIG_DIR="$CFG22" \
+  SLASH_COMMAND_TOOL_CHAR_BUDGET=12345 bash "$SUT" "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -qF 'budget:    8000 chars (documented default (SLASH_COMMAND_TOOL_CHAR_BUDGET fallback))' <<<"$out" &&
+  grep -q 'over budget by 33472 at the documented default budget' <<<"$out" &&
+  ! grep -q 'configured' <<<"$out" &&
+  ! grep -q 'fraction:' <<<"$out"; then
+  pass "default-consumer mode ignores settings and env, and never says configured"
+else
+  fail "no flag should report the 8000 default, over by 33472, without 'configured' (rc=$rc): $out"
+fi
+
+# 25. CHECK_SKILL_LISTING_BUDGET_FRACTION alone is applied as the band, not
+#     silently dropped in favor of the 8000 default.
+out="$(CHECK_SKILL_LISTING_BUDGET_FRACTION=0.05 run "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -qF 'fraction:  0.05 (override (CHECK_SKILL_LISTING_BUDGET_FRACTION))' <<<"$out" &&
+  grep -qF 'budget:    40000 chars' <<<"$out" &&
+  grep -qF 'budget:    200000 chars' <<<"$out" &&
+  ! grep -qF 'budget:    8000 chars' <<<"$out"; then
+  pass "a fraction override without a window reports the 200k/1M band"
+else
+  fail "CHECK_SKILL_LISTING_BUDGET_FRACTION alone should give 40000/200000 (rc=$rc): $out"
+fi
+
+# 26. --from-settings with no settings file falls back to the documented 0.01:
+#     8000 and 40000, both exceeded by 41472, and labeled the default.
+out="$(run_cfg "$TMP/s26/project" "$TMP/s26/config" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 0 ]] &&
+  grep -q 'fraction:  0.01 (documented default' <<<"$out" &&
+  grep -qF 'budget:    8000 chars' <<<"$out" &&
+  grep -qF 'budget:    40000 chars' <<<"$out" &&
+  grep -q 'over 2 of 2 budgets at the documented default fraction 0.01' <<<"$out" &&
+  ! grep -q 'configured' <<<"$out"; then
+  pass "--from-settings with no settings reports the documented-default band"
+else
+  fail "no settings file should give the 0.01 band 8000/40000 labeled default (rc=$rc): $out"
+fi
+
+# 27. Malformed settings JSON is an environment error, not a silent default.
+CFG27="$TMP/s27/config"
+mkdir -p "$CFG27"
+printf '{"skillListingBudgetFraction": \n' >"$CFG27/settings.json"
+out="$(run_cfg "$TMP/s27/project" "$CFG27" --from-settings "$BIG_ROOT" 2>&1)"
+rc=$?
+if [[ $rc -eq 2 ]] && grep -q 'could not parse settings JSON' <<<"$out"; then
+  pass "malformed settings JSON exits 2"
+else
+  fail "malformed settings JSON should exit 2 (rc=$rc): $out"
+fi
+
 # An option-shaped argument is reported as an unknown option, not a missing root.
 out="$(run --bogus 2>&1)"
 rc=$?
diff --git a/plugins/skill-quality/skills/check/SKILL.md b/plugins/skill-quality/skills/check/SKILL.md
index e82e084c95..b5e67c5df2 100644
--- a/plugins/skill-quality/skills/check/SKILL.md
+++ b/plugins/skill-quality/skills/check/SKILL.md
@@ -164,17 +164,21 @@ baseline arm: `/evals:design` says when one is required, and `/evals:plugin-eval
 
 1. Resolve the root(s): explicit `<root> ...` arguments if given; otherwise the same
    skills-root resolution as `check` (above).
-2. Run:
+2. Run, with `--from-settings` so the budget is the one this machine resolves rather than the
+   documented default:
 
    ```shell
-   bash "${CLAUDE_PLUGIN_ROOT}/scripts/check-listing-budget.sh" [<root> ...]
+   bash "${CLAUDE_PLUGIN_ROOT}/scripts/check-listing-budget.sh" --from-settings [<root> ...]
    ```
 
-3. Report the printed aggregate, the budget it was compared against (and whether that budget is the
-   documented default, a fixed override, or a reconstructed one, and the script labels which), and the
-   biggest contributors when it overflows. The action is complete when the report names all three
-   of those elements; the script exiting 0 alone is not the done-condition (it is advisory and
-   always exits 0 on a successful run).
+   Drop the flag only when the user asks what a default consumer sees; that is the form CI runs.
+3. Report the printed aggregate, every budget row it was compared against with its verdict (one
+   row, or a band of context-window sizes when no window is pinned), the source the script labels
+   for the budget or fraction (a settings file, `SLASH_COMMAND_TOOL_CHAR_BUDGET`, an override, or
+   the documented default), and the biggest contributors when it overflows. Say that managed
+   policy is not read. The action is complete when the report names all of those elements; the
+   script exiting 0 alone is not the done-condition (it is advisory and always exits 0 on a
+   successful run). `--help` lists the settings scopes it reads and their order.
 
 This is a **different, cross-skill limit** from `check`'s per-skill entry cap (`description` +
 `when_to_use` <= 1536 chars, the documented default of `skillListingMaxDescChars` per
@@ -182,9 +186,12 @@ This is a **different, cross-skill limit** from `check`'s per-skill entry cap (`
 trigger: that page or the settings page moving either default re-derives this sentence and the
 scripts' constants): the shared budget every loaded skill draws from together
 (`skillListingBudgetFraction`, default 1% of the model's context window).
-The script exits 0 regardless of overflow, because the live budget depends on the model's context window and a
-consumer's own settings, neither of which this static check can observe. Point `/doctor` at the live
-session for the authoritative resolved cost.
+The script exits 0 regardless of overflow, because the live budget depends on the model's context
+window, which no file records, and on managed policy, which it does not read. Point `/doctor` at the
+live session for the authoritative resolved cost. The budget's basis, its default fraction, and the
+environment override are on <https://code.claude.com/docs/en/skills#skill-descriptions-are-cut-short>
+and <https://code.claude.com/docs/en/settings-reference#skilllistingbudgetfraction>, verified
+2026-10-04; recheck trigger: either section changing the basis, the default, or the override.
 
 **Only listing-eligible skills count.** A skill with `disable-model-invocation: true` has its
 description kept out of the model-visible listing entirely, so it spends none of the shared budget
diff --git a/plugins/source-control/.claude-plugin/plugin.json b/plugins/source-control/.claude-plugin/plugin.json
index 8727eecda0..5375ca0ecb 100644
--- a/plugins/source-control/.claude-plugin/plugin.json
+++ b/plugins/source-control/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "source-control",
-  "version": "0.79.16",
+  "version": "0.79.17",
   "description": "Git and GitHub delivery: /commit (convention-checked subject, Co-authored-by trailer, surgical staging), /pull-request (prep, create, CI monitoring, review triage, merge, CI logs), /babysit-prs (safe-by-default PR fleet loop, opt-in worker and autopilot tiers), /babysit-loop (merge lane; merge is human until the repo adopts it), /worktree, /resolve-conflicts (intent-first), /check, and /setup (layered source-control.md convention config; Conventional Commits by default).",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/source-control/CHANGELOG.md b/plugins/source-control/CHANGELOG.md
index 5b756454e2..1fbed71a29 100644
--- a/plugins/source-control/CHANGELOG.md
+++ b/plugins/source-control/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `source-control` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.79.17] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.79.16] - 2026-10-04
 
 ### Changed
diff --git a/plugins/source-control/hooks/exec-bash.mjs b/plugins/source-control/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/source-control/hooks/exec-bash.mjs
+++ b/plugins/source-control/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/source-control/hooks/hooks.json b/plugins/source-control/hooks/hooks.json
index 7432a5aced..80298c5690 100644
--- a/plugins/source-control/hooks/hooks.json
+++ b/plugins/source-control/hooks/hooks.json
@@ -3,6 +3,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/speech/.claude-plugin/plugin.json b/plugins/speech/.claude-plugin/plugin.json
index 3820779a25..d669e43c0a 100644
--- a/plugins/speech/.claude-plugin/plugin.json
+++ b/plugins/speech/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "speech",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Text-to-speech narration. The narrate skill turns a script into narration.wav plus words.json, a start and end time for every word. The default kokoro backend runs Kokoro-82M locally with onnxruntime. The optional elevenlabs backend sends the text to the third-party ElevenLabs API (ELEVENLABS_API_KEY) after showing a cost estimate; an organization can forbid it. You install espeak-ng (GPL-3.0). A hook installs the Python packages; setup downloads the models; check reports missing prerequisites.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/speech/CHANGELOG.md b/plugins/speech/CHANGELOG.md
index bc312bf7a9..08454378bb 100644
--- a/plugins/speech/CHANGELOG.md
+++ b/plugins/speech/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to the `speech` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.2.6] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
+### Fixed
+
+- The `pydeps.py` helper is now passed to native Python as a Windows path (#6250).
+
 ## [0.2.5] - 2026-10-04
 
 ### Changed
diff --git a/plugins/speech/hooks/exec-bash.mjs b/plugins/speech/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/speech/hooks/exec-bash.mjs
+++ b/plugins/speech/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/speech/hooks/hooks.json b/plugins/speech/hooks/hooks.json
index 61c2e987ae..ac4ba648ac 100644
--- a/plugins/speech/hooks/hooks.json
+++ b/plugins/speech/hooks/hooks.json
@@ -17,6 +17,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/speech/hooks/install-python-deps.sh b/plugins/speech/hooks/install-python-deps.sh
index 626097d12d..de18359f51 100755
--- a/plugins/speech/hooks/install-python-deps.sh
+++ b/plugins/speech/hooks/install-python-deps.sh
@@ -35,7 +35,30 @@ if [[ -z "$py" ]]; then
   exit 0
 fi
 
-if ! out="$("$py" "$ROOT/scripts/pydeps.py" install --data-dir "$data" </dev/null 2>&1)"; then
+# to_native <path> -> the path as a native Windows Python reads it. Under Git Bash or Cygwin a POSIX
+# path (/c/...) goes through cygpath -m: a session with MSYS path conversion switched off hands it
+# over as is, and Python resolves it against the current drive (C:\c\...). Fails rather than
+# return the unconverted path.
+to_native() {
+  case "${OSTYPE:-}" in
+  msys* | cygwin*)
+    [[ "$1" == /* ]] || {
+      printf '%s' "$1"
+      return 0
+    }
+    local converted
+    converted="$(cygpath -m "$1" 2>/dev/null)" && [[ -n "$converted" ]] && printf '%s' "$converted"
+    ;;
+  *) printf '%s' "$1" ;;
+  esac
+}
+
+if ! script="$(to_native "$ROOT/scripts/pydeps.py")" || ! data_dir="$(to_native "$data")"; then
+  notice "speech: cygpath could not convert its pydeps.py or data directory path to Windows form, so its Python packages are not installed and /speech:narrate will stop. Check that cygpath runs in Git Bash and start a new session."
+  exit 0
+fi
+
+if ! out="$("$py" "$script" install --data-dir "$data_dir" </dev/null 2>&1)"; then
   notice "speech: its Python packages could not be installed, so /speech:narrate will stop until they are. $out"
 fi
 exit 0
diff --git a/plugins/speech/hooks/install-python-deps.test.sh b/plugins/speech/hooks/install-python-deps.test.sh
index fcbb2fb3b0..8c2799fca3 100755
--- a/plugins/speech/hooks/install-python-deps.test.sh
+++ b/plugins/speech/hooks/install-python-deps.test.sh
@@ -131,6 +131,45 @@ else
   fail "no python: rc=$rc output=[$out]"
 fi
 
+# Native Windows Python under Git Bash or Cygwin: pydeps.py and a POSIX data directory reach it as drive-letter
+# paths even with MSYS path conversion switched off, and a cygpath that fails is a notice, never the unconverted
+# path. The stub python3 logs its arguments; the stub cygpath maps -m /dir to C:/dir, or fails.
+# native_hook <ostype> <cygpath body> -> runs the hook with MSYS_NO_PATHCONV=1 and a POSIX data directory; sets OUT,
+# RC and ARGV.
+# shellcheck disable=SC2016  # the stub bodies expand when the stubs run, not here
+native_hook() {
+  local stubs="$WORK/stubs-$1"
+  mkdir -p "$stubs"
+  printf '#!/bin/sh\n[ "$1" = -c ] && exit 0\nprintf "%%s|" "$@" >"%s/argv.log"\n' "$WORK" >"$stubs/python3"
+  printf '#!/bin/sh\n%s\n' "$2" >"$stubs/cygpath"
+  chmod +x "$stubs/python3" "$stubs/cygpath"
+  rm -f "$WORK/argv.log"
+  OUT="$(env PATH="$stubs:$tools" OSTYPE="$1" MSYS_NO_PATHCONV=1 CLAUDE_PLUGIN_DATA="$WORK/data-native" "$tools/bash" "$root/hooks/install-python-deps.sh" <<<'{}')"
+  RC=$?
+  ARGV="$(cat "$WORK/argv.log" 2>/dev/null)"
+}
+# shellcheck disable=SC2016  # the stub body expands when the stub runs, not here
+for ostype in msys cygwin; do
+  native_hook "$ostype" '[ "$1" = -m ] && printf "C:%s\n" "$2"'
+  if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "C:$root/scripts/pydeps.py|install|--data-dir|C:$WORK/data-native|" ]]; then
+    ok "OSTYPE=$ostype with path conversion off hands Python drive-letter pydeps.py and data directory paths"
+  else
+    fail "OSTYPE=$ostype conversion: rc=$RC argv=[$ARGV] output=[$OUT]"
+  fi
+done
+native_hook msys 'exit 1'
+if [[ "$RC" -eq 0 && -z "$ARGV" && "$OUT" == *'"systemMessage"'* && "$OUT" == *'cygpath could not convert'* ]]; then
+  ok "a failing cygpath is a notice and Python never gets the unconverted path"
+else
+  fail "failing cygpath: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+native_hook linux-gnu 'exit 1'
+if [[ "$RC" -eq 0 && -z "$OUT" && "$ARGV" == "$root/scripts/pydeps.py|install|--data-dir|$WORK/data-native|" ]]; then
+  ok "outside Git Bash and Cygwin the paths reach Python unchanged"
+else
+  fail "linux paths: rc=$RC argv=[$ARGV] output=[$OUT]"
+fi
+
 echo "---"
 echo "passed: $PASS, failed: $FAIL"
 [[ "$FAIL" -eq 0 ]]
diff --git a/plugins/testing/.claude-plugin/plugin.json b/plugins/testing/.claude-plugin/plugin.json
index 1bd7a2bc24..49f8a54e75 100644
--- a/plugins/testing/.claude-plugin/plugin.json
+++ b/plugins/testing/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "testing",
-  "version": "0.22.12",
+  "version": "0.22.13",
   "description": "Test-stage discipline: /testing:plan (coverage gaps, test plans), /testing:write (TDD authoring), /testing:run-e2e (live E2E and smoke checks), /testing:diagnose (failing-test root cause, with a fix-until-green workflow across files), /testing:audit (can't-fail test audit with a fail-closed gate), /testing:cleanup (rewrite, quarantine, or delete low-value tests behind a mutation gate), /testing:setup, and opt-in hooks that scan test files Claude writes and flag edits that weaken tests.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/testing/CHANGELOG.md b/plugins/testing/CHANGELOG.md
index 80a3e2ea62..08f1781898 100644
--- a/plugins/testing/CHANGELOG.md
+++ b/plugins/testing/CHANGELOG.md
@@ -3,6 +3,19 @@
 All notable changes to the `testing` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.22.13] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The `test-scan-bash` row starts the launcher with `--skip-unless-stdin-contains bashEditDiff`, so a Bash payload with no change diff starts node only (#6253). The shared `exec-bash.mjs` launcher copy also gains `--skip-if-all-false`, which no testing row uses (#6252).
+
+### Fixed
+
+- The `test-judge.test.sh` link fixtures now run only when a real native symlink can be made, so cleanup of a self-nesting tree can no longer spin (#6248).
+- The link cases fail, not skip, when the native-link probe fails in CI (#6248).
+- The judge test helper runs `jq` with MSYS path conversion off on each call, so the Stop path hashes the project key the recorder wrote on Windows (#6266).
+
 ## [0.22.12] - 2026-10-04
 
 ### Changed
diff --git a/plugins/testing/hooks/exec-bash.mjs b/plugins/testing/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/testing/hooks/exec-bash.mjs
+++ b/plugins/testing/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/testing/hooks/hooks.json b/plugins/testing/hooks/hooks.json
index aabf446c06..46ae4cc214 100644
--- a/plugins/testing/hooks/hooks.json
+++ b/plugins/testing/hooks/hooks.json
@@ -1064,6 +1064,8 @@
               "${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs",
               "--require-true",
               "TEST_GUARDS_ENABLED",
+              "--skip-unless-stdin-contains",
+              "bashEditDiff",
               "${CLAUDE_PLUGIN_ROOT}/hooks/test-scan-bash.sh"
             ],
             "timeout": 10,
@@ -1676,6 +1678,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/plugins/testing/hooks/judge-test-helpers.sh b/plugins/testing/hooks/judge-test-helpers.sh
index 4c65547bb4..0a9fbaa790 100644
--- a/plugins/testing/hooks/judge-test-helpers.sh
+++ b/plugins/testing/hooks/judge-test-helpers.sh
@@ -30,9 +30,41 @@ finish() {
 }
 
 TMP="$(mktemp -d)"
-# Only the suite's own shell cleans up: a forked child that gets a signal before its
-# exec still holds this trap.
-trap '[[ "$BASHPID" == "$$" ]] && { jobs -p | xargs -r kill 2>/dev/null; rm -rf "$TMP"; }' EXIT
+# Every cleanup below kills and deletes by $TMP, so it must be a real directory
+# under the temp root before anything else runs.
+SYS_TMP="${TMPDIR:-/tmp}"
+SYS_TMP="${SYS_TMP%/}"
+if [[ -z "$TMP" || ! -d "$TMP" || "$TMP" != "$SYS_TMP"/?* ]]; then
+  echo "abort: mktemp gave '$TMP', not a directory under $SYS_TMP" >&2
+  exit 1
+fi
+# tmp_kill <signal> <text>: signal every process whose command line holds
+# <text>, a path under $TMP; anything else, or no $TMP, signals nothing. Git
+# Bash ships no pkill, but its /proc carries each command line.
+tmp_kill() {
+  [[ -n "$TMP" && -d "$TMP" && "$2" == "$TMP"/* ]] || return 0
+  if command -v pkill >/dev/null; then
+    pkill "-$1" -f "$2"
+    return 0
+  fi
+  local f p
+  while IFS= read -r f; do
+    p="${f#/proc/}"
+    p="${p%/cmdline}"
+    [[ "$p" == "$$" ]] || kill "-$1" "$p" 2>/dev/null
+  done < <(grep -lF -- "$2" /proc/[0-9]*/cmdline 2>/dev/null)
+  return 0
+}
+# Only the suite's own shell cleans up: a forked child that gets a signal before
+# its exec still holds this trap. It ends every process still naming $TMP, then
+# deletes under a time bound and names what it left rather than spinning on it.
+trap '[[ "$BASHPID" == "$$" && -n "$TMP" && -d "$TMP" ]] && {
+  jobs -p | xargs -r kill 2>/dev/null
+  tmp_kill TERM "$TMP/"
+  sleep 0.5
+  tmp_kill KILL "$TMP/"
+  timeout 60 rm -rf -- "$TMP" || echo "cleanup: $TMP was not removed within 60 s; left in place" >&2
+}' EXIT
 REPO="$TMP/repo"
 mkdir -p "$REPO/src" "$TMP/bin" "$TMP/stub"
 git -C "$REPO" init -q -b feat/judge-test
@@ -182,8 +214,11 @@ blocks() {
 }
 
 # payload <sid> <id> <file> [extra jq object]: a hook payload.
+# Git Bash rewrites a POSIX-looking argument to Windows form for a native jq, so
+# the paths are passed unconverted: the hooks key a project by the same
+# (cwd, transcript directory) spelling PKEY hashed.
 payload() {
-  jq -cn --arg s "$1" --arg u "$2" --arg f "$3" --arg t "$TDIR/$1.jsonl" --arg c "$REPO" --argjson x "${4:-{\}}" \
+  MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*' jq -cn --arg s "$1" --arg u "$2" --arg f "$3" --arg t "$TDIR/$1.jsonl" --arg c "$REPO" --argjson x "${4:-{\}}" \
     '{hook_event_name: "PostToolUse", tool_name: "Edit", session_id: $s, tool_use_id: $u, transcript_path: $t,
       cwd: $c, tool_input: {file_path: $f}, stop_hook_active: false} + $x'
 }
diff --git a/plugins/testing/hooks/test-judge.test.sh b/plugins/testing/hooks/test-judge.test.sh
index 59597bca3c..ea678f6e21 100755
--- a/plugins/testing/hooks/test-judge.test.sh
+++ b/plugins/testing/hooks/test-judge.test.sh
@@ -6,6 +6,79 @@
 
 # shellcheck source=judge-test-helpers.sh
 source "$(dirname "${BASH_SOURCE[0]}")/judge-test-helpers.sh"
+# With no $TMP the cleanup's pattern would be "/", in every command line:
+# tmp_kill must then signal nothing. kill and pkill are stubs that record calls.
+tk="$(
+  kill() { echo kill; }
+  pkill() { echo pkill; }
+  TMP="" tmp_kill TERM /
+  echo "rc=$?"
+)"
+check "tmp_kill with no TMP signals nothing" '[[ "$tk" == "rc=0" ]]'
+tk="$(
+  kill() { echo kill; }
+  pkill() { echo pkill; }
+  tmp_kill TERM /
+  echo "rc=$?"
+)"
+check "tmp_kill with a pattern outside TMP signals nothing" '[[ "$tk" == "rc=0" ]]'
+tk="$(
+  pkill() { echo "pkill $*"; }
+  tmp_kill TERM "$TMP/x"
+)"
+check "tmp_kill with a pattern under TMP signals it" '[[ "$tk" == "pkill -TERM -f $TMP/x" ]]'
+# A plain `ln -s` on Git Bash copies its target, and a copy of an ancestor
+# nests inside itself without end. Every fixture link is asked for as a native
+# symlink, which fails rather than copies, and confirmed with -L. A host that
+# cannot make one skips each link case instead of asserting against a copy.
+SKIPS=0
+make_link() { MSYS=winsymlinks:nativestrict ln -s "$1" "$2" 2>/dev/null && [[ -L "$2" ]]; }
+export -f make_link
+mkdir -p "$TMP/linkprobe/t"
+LINKS=""
+make_link t "$TMP/linkprobe/l" && LINKS=1
+# link_miss_fatal: whether a failed link probe fails the run. Only a Windows
+# host outside CI may lack native symlinks; anywhere else a broken probe would
+# turn every link case into a quiet SKIP.
+link_miss_fatal() { [[ -n "${CI:-}" || ! "${OSTYPE:-}" =~ ^(msys|cygwin|win32) ]]; }
+# links <case> [<target> <link>]...: make each fixture link for <case>; a
+# Windows host without native symlinks SKIPs the case, and a link that fails
+# here, or a failed probe anywhere else, fails it.
+links() {
+  local c="$1"
+  shift
+  if [[ -z "$LINKS" ]]; then
+    if link_miss_fatal; then
+      fail "$c (the native-link probe failed on a host that must make links)"
+      return 1
+    fi
+    echo "SKIP: $c (no native symlinks, no coverage here, not a pass)"
+    SKIPS=$((SKIPS + 1))
+    return 1
+  fi
+  while (($#)); do
+    make_link "$1" "$2" || {
+      fail "$c (could not create the fixture link $2)"
+      return 1
+    }
+    shift 2
+  done
+}
+# A failed probe fails each case in CI or off Windows and skips it only on a
+# local Windows host. fail is a stub, so nothing here counts as a real failure.
+lk="$(
+  LINKS=""
+  fail() { printf 'F '; }
+  CI=1 OSTYPE=msys links c
+  CI="" OSTYPE=linux-gnu links c
+  skip="$(CI="" OSTYPE=msys links c)"
+  [[ "$skip" == SKIP:* ]] && printf 'S ' || printf 'X '
+)"
+check "a failed link probe fails in CI and off Windows, and skips on local Windows" '[[ "$lk" == "F F S " ]]'
+# too_deep <dir> <levels>: the first directory more than <levels> below <dir>.
+# find follows no link and stops one level past the bound, so a tree that
+# copied into itself is reported, never walked.
+too_deep() { find "$1" -mindepth "$(($2 + 1))" -maxdepth "$(($2 + 1))" -type d -print -quit 2>/dev/null; }
 HOOK="$HOOK_DIR/test-judge.sh"
 BG="$HOOK_DIR/test-judge-bg.sh"
 export CLAUDE_CODE_SESSION_ATTENDED=1
@@ -22,7 +95,7 @@ stop_jobs() {
   for p in "$DATA/pending/$PKEY/$1"/*; do
     [[ -f "$p" ]] && kill -TERM -- "-$(cut -d' ' -f1 "$p" | head -1)" 2>/dev/null
   done
-  pkill -f "$TMP/judge-stub.sh"
+  tmp_kill TERM "$TMP/judge-stub.sh"
   sleep 0.3
 }
 bg() { payload "$1" "$2" "$3" | bash "$BG"; }
@@ -192,7 +265,7 @@ STUB_SLEEP=2 stop s7
 # The job dies with its judge, as at `-p` teardown.
 p="$(find "$DATA/pending/$PKEY/s7" -type f | head -1)"
 kill "$(cut -d' ' -f1 "$p" | head -1)" 2>/dev/null
-pkill -f "$TMP/judge-stub.sh"
+tmp_kill TERM "$TMP/judge-stub.sh"
 sleep 0.3
 stub_reset
 stop s7
@@ -269,7 +342,7 @@ check "its key gets a pending/ marker and a live background job" '[[ -n "$p" ]]
 assert_not_contains "the message does not call this Stop's own late run still judging" "$(field .systemMessage)" "still judging"
 assert_contains "the message names the key as not judged in time" "$(field .systemMessage)" "termdeaf.test.ts: termdeaf"
 stop_jobs s8c
-pkill -f "$TMP/term-stub.sh"
+tmp_kill TERM "$TMP/term-stub.sh"
 wait
 
 # Two failed attempts: "judge not run", and no third attempt.
@@ -709,26 +782,31 @@ sec_stop() {
 mkdir -p "$TMP/out1" "$TMP/out3" "$TMP/out4"
 rm -rf "$REPO/.work"
 mkdir -p "$REPO/.work"
-ln -s "$TMP/out1" "$REPO/.work/reviews"
-sec_stop sec1 sec1.test.ts
-check "a reviews/ symlink out of the checkout: nothing is written through it" \
-  '[[ -z "$(ls -A "$TMP/out1")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+c="a reviews/ symlink out of the checkout: nothing is written through it"
+if links "$c" "$TMP/out1" "$REPO/.work/reviews"; then
+  sec_stop sec1 sec1.test.ts
+  check "$c" '[[ -z "$(ls -A "$TMP/out1")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+fi
 rm -rf "$REPO/.work"
 mkdir -p "$REPO/.work"
-ln -s "$TMP/planted" "$REPO/.work/.gitignore"
-sec_stop sec2 sec2.test.ts
-check "a dangling .gitignore symlink: no file appears at its target" '[[ ! -e "$TMP/planted" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+c="a dangling .gitignore symlink: no file appears at its target"
+if links "$c" "$TMP/planted" "$REPO/.work/.gitignore"; then
+  sec_stop sec2 sec2.test.ts
+  check "$c" '[[ ! -e "$TMP/planted" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+fi
 rm -rf "$REPO/.work"
 mkdir -p "$REPO/.work/reviews"
-ln -s "$TMP/out3" "$REPO/.work/reviews/feat-judge-test"
-sec_stop sec3 sec3.test.ts
-check "a <branch> symlink out of the checkout: nothing is written through it" \
-  '[[ -z "$(ls -A "$TMP/out3")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+c="a <branch> symlink out of the checkout: nothing is written through it"
+if links "$c" "$TMP/out3" "$REPO/.work/reviews/feat-judge-test"; then
+  sec_stop sec3 sec3.test.ts
+  check "$c" '[[ -z "$(ls -A "$TMP/out3")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+fi
 rm -rf "$REPO/.work"
-ln -s "$TMP/out4" "$REPO/.work"
-sec_stop sec4 sec4.test.ts
-check "a .work symlink out of the checkout: nothing is written through it" \
-  '[[ -z "$(ls -A "$TMP/out4")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+c="a .work symlink out of the checkout: nothing is written through it"
+if links "$c" "$TMP/out4" "$REPO/.work"; then
+  sec_stop sec4 sec4.test.ts
+  check "$c" '[[ -z "$(ls -A "$TMP/out4")" && "$SF" == "$DATA/findings/"* && -f "$SF" ]]'
+fi
 rm -f "$REPO/.work"
 # 2. Judge text in the findings file cannot forge headings or close the diff
 # fence, and a verdict that failed validation shows only why.
@@ -896,19 +974,22 @@ newrepo() { # newrepo <dir>
 }
 SEC="$TMP/sec"
 newrepo "$SEC/a/reviews"
-ln -s .. "$SEC/a/reviews/.work"
-check "a memory root linked out of the checkout (.work -> .., in a checkout named reviews): no .gitignore outside" \
-  '[[ "$(fdir "$SEC/a/reviews" main)" == "$DATA/findings" && ! -e "$SEC/a/.gitignore" ]]'
+c="a memory root linked out of the checkout (.work -> .., in a checkout named reviews): no .gitignore outside"
+if links "$c" .. "$SEC/a/reviews/.work"; then
+  check "$c" '[[ "$(fdir "$SEC/a/reviews" main)" == "$DATA/findings" && ! -e "$SEC/a/.gitignore" ]]'
+fi
 mkdir -p "$SEC/b/sib" "$SEC/b/victim/inner"
 newrepo "$SEC/b/victim"
-ln -s ../sib "$SEC/b/victim/.work"
-ln -s ../victim/inner "$SEC/b/sib/reviews"
-check "a memory root in a sibling whose reviews/ links back in: no .gitignore in the sibling" \
-  '[[ "$(fdir "$SEC/b/victim" main)" == "$DATA/findings" && ! -e "$SEC/b/sib/.gitignore" ]]'
+c="a memory root in a sibling whose reviews/ links back in: no .gitignore in the sibling"
+if links "$c" ../sib "$SEC/b/victim/.work" ../victim/inner "$SEC/b/sib/reviews"; then
+  check "$c" '[[ "$(fdir "$SEC/b/victim" main)" == "$DATA/findings" && ! -e "$SEC/b/sib/.gitignore" ]]'
+fi
 newrepo "$SEC/c"
 mkdir -p "$SEC/c/real"
-ln -s real "$SEC/c/.work"
-check ".work linked to a directory inside the checkout still works" '[[ "$(fdir "$SEC/c" main)" == "$SEC/c/.work/reviews/main" && -f "$SEC/c/real/.gitignore" ]]'
+c=".work linked to a directory inside the checkout still works"
+if links "$c" real "$SEC/c/.work"; then
+  check "$c" '[[ "$(fdir "$SEC/c" main)" == "$SEC/c/.work/reviews/main" && -f "$SEC/c/real/.gitignore" ]]'
+fi
 newrepo "$SEC/e"
 mkdir -p "$SEC/e/.work"
 mkfifo "$SEC/e/.work/.gitignore"
@@ -916,8 +997,10 @@ check "a FIFO at .gitignore: returns at once, nothing written, the plugin data d
 newrepo "$SEC/f"
 mkdir -p "$SEC/f/.work" "$SEC/fout"
 mkfifo "$SEC/fout/fifo"
-ln -s "$SEC/fout/fifo" "$SEC/f/.work/.gitignore"
-check "a link to a FIFO at .gitignore: returns at once, nothing written" '[[ "$(fdir "$SEC/f" main)" == "$DATA/findings" ]]'
+c="a link to a FIFO at .gitignore: returns at once, nothing written"
+if links "$c" "$SEC/fout/fifo" "$SEC/f/.work/.gitignore"; then
+  check "$c" '[[ "$(fdir "$SEC/f" main)" == "$DATA/findings" ]]'
+fi
 # A findings name taken by a link to a FIFO is skipped, not written through.
 newrepo "$SEC/g"
 git -C "$SEC/g" checkout -q -b main 2>/dev/null
@@ -925,27 +1008,34 @@ mkdir -p "$SEC/g/.work/reviews/main"
 printf '*\n' >"$SEC/g/.work/.gitignore"
 mkfifo "$SEC/fout/fifo2"
 now="$(date +%s)"
+gl=()
 for s in 0 1 2 3 4 5 6 7 8 9; do
-  ln -s "$SEC/fout/fifo2" "$SEC/g/.work/reviews/main/$(jq -rn --argjson t "$((now + s))" '$t | strftime("%Y%m%dT%H%M%SZ")')-test-judge.md"
+  gl+=("$SEC/fout/fifo2" "$SEC/g/.work/reviews/main/$(jq -rn --argjson t "$((now + s))" '$t | strftime("%Y%m%dT%H%M%SZ")')-test-judge.md")
 done
-jq -cn --arg f "$SEC/g/t.test.ts" --arg r "$SEC/g" '{file: $f, repo: $r, name: "t", ordinal: 1, start: 1, end: 1, verdict: "PASS",
-  evidence: ["x"], source: "s", diff: "", reason: "", model: "m", effort: "e"}' >"$TMP/g-verdict.json"
-gout="$(timeout 5 env HOOK_DIR="$HOOK_DIR" DATA="$DATA" GV="$TMP/g-verdict.json" R="$SEC/g" bash -c "$(declare -f lib); lib linux-gnu 'RELAY=\"\$(<\"\$GV\")\"\$'\"'\"'\\n'\"'\"'; RELAY_REPOS=(\"\$R\"); judge::findings; printf %s \"\$FINDINGS\"'")"
-check "a findings name taken by a link to a FIFO is skipped: no hang, written under the next name" \
-  '[[ "$gout" == "$SEC/g/.work/reviews/main/"*-test-judge-2.md && -f "$gout" && ! -L "$gout" ]]'
+c="a findings name taken by a link to a FIFO is skipped: no hang, written under the next name"
+if links "$c" "${gl[@]}"; then
+  jq -cn --arg f "$SEC/g/t.test.ts" --arg r "$SEC/g" '{file: $f, repo: $r, name: "t", ordinal: 1, start: 1, end: 1, verdict: "PASS",
+    evidence: ["x"], source: "s", diff: "", reason: "", model: "m", effort: "e"}' >"$TMP/g-verdict.json"
+  gout="$(timeout 5 env HOOK_DIR="$HOOK_DIR" DATA="$DATA" GV="$TMP/g-verdict.json" R="$SEC/g" bash -c "$(declare -f lib); lib linux-gnu 'RELAY=\"\$(<\"\$GV\")\"\$'\"'\"'\\n'\"'\"'; RELAY_REPOS=(\"\$R\"); judge::findings; printf %s \"\$FINDINGS\"'")"
+  check "$c" '[[ "$gout" == "$SEC/g/.work/reviews/main/"*-test-judge-2.md && -f "$gout" && ! -L "$gout" ]]'
+fi
 # The directory is checked again just before the file takes its name: one
-# swapped for a link out after the first check is not written through.
-newrepo "$SEC/h"
-git -C "$SEC/h" checkout -q -b main 2>/dev/null
-mkdir -p "$SEC/hout"
-jq -cn --arg f "$SEC/h/t.test.ts" --arg r "$SEC/h" '{file: $f, repo: $r, name: "t", ordinal: 1, start: 1, end: 1, verdict: "PASS",
-  evidence: ["x"], source: "s", diff: "", reason: "", model: "m", effort: "e"}' >"$TMP/h-verdict.json"
-hout="$(timeout 5 env HOOK_DIR="$HOOK_DIR" DATA="$DATA" HV="$TMP/h-verdict.json" R="$SEC/h" O="$SEC/hout" bash -c "$(declare -f lib); lib linux-gnu '
+# swapped for a link out after the first check is not written through. A swap
+# whose link could not be made leaves a marker beside hout, so the case cannot
+# pass without the swap.
+c="a findings directory swapped for a link out after the check: nothing lands outside"
+if links "$c"; then
+  newrepo "$SEC/h"
+  git -C "$SEC/h" checkout -q -b main 2>/dev/null
+  mkdir -p "$SEC/hout"
+  jq -cn --arg f "$SEC/h/t.test.ts" --arg r "$SEC/h" '{file: $f, repo: $r, name: "t", ordinal: 1, start: 1, end: 1, verdict: "PASS",
+    evidence: ["x"], source: "s", diff: "", reason: "", model: "m", effort: "e"}' >"$TMP/h-verdict.json"
+  hout="$(timeout 5 env HOOK_DIR="$HOOK_DIR" DATA="$DATA" HV="$TMP/h-verdict.json" R="$SEC/h" O="$SEC/hout" bash -c "$(declare -f lib); lib linux-gnu '
   eval \"\$(declare -f judge::findings_dir | sed \"1s/judge::findings_dir/orig_fd/\")\"
-  judge::findings_dir() { orig_fd \"\$@\"; rm -rf \"\$R/.work/reviews/main\"; ln -s \"\$O\" \"\$R/.work/reviews/main\"; }
+  judge::findings_dir() { orig_fd \"\$@\"; rm -rf \"\$R/.work/reviews/main\"; make_link \"\$O\" \"\$R/.work/reviews/main\" || : >\"\$O.linkfail\"; }
   RELAY=\"\$(<\"\$HV\")\"\$'\"'\"'\\n'\"'\"'; RELAY_REPOS=(\"\$R\"); judge::findings; printf %s \"\$FINDINGS\"'")"
-check "a findings directory swapped for a link out after the check: nothing lands outside" \
-  '[[ -z "$(ls -A "$SEC/hout")" && "$hout" == "$DATA/findings/"* && -f "$hout" ]]'
+  check "$c" '[[ ! -e "$SEC/hout.linkfail" && -z "$(ls -A "$SEC/hout")" && "$hout" == "$DATA/findings/"* && -f "$hout" ]]'
+fi
 # The branch in the frontmatter parses back to itself: quoted exactly when its
 # plain YAML form would misparse (the predicate testing:audit shares), so
 # a"b#c stays plain and #x, which plain would read as a comment, is quoted.
@@ -958,6 +1048,12 @@ check "a branch named a\"b#c is a plain scalar, as YAML reads it back" '[[ "$(se
 git -C "$SEC/i" checkout -q -b '#x'
 iout="$(timeout 5 env HOOK_DIR="$HOOK_DIR" DATA="$DATA" IV="$TMP/i-verdict.json" R="$SEC/i" bash -c "$(declare -f lib); lib linux-gnu 'RELAY=\"\$(<\"\$IV\")\"\$'\"'\"'\\n'\"'\"'; RELAY_REPOS=(\"\$R\"); judge::findings; printf %s \"\$FINDINGS\"'")"
 check "a branch named #x is quoted, or YAML would read a comment" '[[ "$(sed -n 4p "$iout")" == "branch: \"#x\"" ]]'
+# No fixture copied into itself: a link copied in place of a link nests past
+# the 8 levels any fixture under sec/ needs.
+mkdir -p "$TMP/deep/1/2/3/4/5/6/7/8/9/10/11/12"
+check "the depth check reports a 12-deep chain" '[[ "$(too_deep "$TMP/deep" 8)" == "$TMP/deep/1/2/3/4/5/6/7/8/9" ]]'
+rm -rf "$TMP/deep"
+check "no fixture under sec/ nests more than 8 levels deep" '[[ -d "$SEC/i/.git" && -z "$(too_deep "$SEC" 8)" ]]'
 
 # 5. Numeric settings are numbers, never arithmetic run on the environment.
 transcript sec7 claude-sonnet-5
@@ -969,4 +1065,5 @@ out="$(payload sec7 stop "" '{"hook_event_name": "Stop"}' | TEST_JUDGE_TIMEOUT='
 check "a timeout or debounce value is not evaluated as arithmetic" '[[ ! -e "$TMP/pwned5" && ! -e "$TMP/pwned5b" && "$(field .decision)" != block && "$(field .systemMessage)" == *"reviewed 1 test "* ]]'
 
 check "no real claude was ever called" '[[ ! -e "$TMP/real-claude-called" ]]'
+echo "$SKIPS skipped (no native symlinks)"
 finish
diff --git a/plugins/testing/scripts/gen-hook-filters.sh b/plugins/testing/scripts/gen-hook-filters.sh
index 1fb992a869..158c74c389 100755
--- a/plugins/testing/scripts/gen-hook-filters.sh
+++ b/plugins/testing/scripts/gen-hook-filters.sh
@@ -14,6 +14,9 @@
 # PostToolUse also gets one Bash row with no `if`: a Bash `if` matches
 # the command string, not the files the call changed (probes.md), so
 # test-scan-bash.sh filters the payload's changed files by the same globs.
+# Its launcher flag --skip-unless-stdin-contains bashEditDiff skips the bash
+# start on a payload with no Bash change diff, the case the script itself
+# exits on first; the row is advisory, so the flag's fail-open stall is safe.
 # The judge has no Bash row: test-scan records a Bash-written test file like
 # any other write, and the Stop hook judges what no background job did.
 #
@@ -39,20 +42,22 @@ globs="$(awk -f "$AUDIT/scripts/adapter-load.awk" "$AUDIT"/adapters/*.yaml |
 # `if` rows as test-scan (no timeout: Claude Code enforces none on an async
 # command hook); Stop's 240 s sits above the hook's own 180 s bound.
 json="$(jq -R . <<<"$globs" | jq -s '. as $globs |
-  def cmd($gates; $script): {
+  def cmd($gates; $flags; $script): {
     type: "command",
     command: "node",
-    args: (["${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs"] + ($gates | map("--require-true", .))
+    args: (["${CLAUDE_PLUGIN_ROOT}/hooks/exec-bash.mjs"] + ($gates | map("--require-true", .)) + $flags
       + ["${CLAUDE_PLUGIN_ROOT}/hooks/\($script)"])
   };
+  def cmd($gates; $script): cmd($gates; []; $script);
   def rows($script; $extra): [{
     matcher: "Write|Edit",
     hooks: [$globs[] as $g | ("Write", "Edit") | {if: "\(.)(\($g))"} as $if
       | cmd(["TEST_GUARDS_ENABLED"] + (if $extra.async then ["TEST_JUDGE_ENABLED"] else [] end); $script) + $if + $extra]
   }];
   def judge($script; $extra): [{hooks: [cmd(["TEST_GUARDS_ENABLED", "TEST_JUDGE_ENABLED"]; $script) + $extra]}];
-  # The node-notice row runs without node, so it is shell form; the prerequisites convention owns it.
-  def notice: [{hooks: [{type: "command",
+  # The node-notice row runs without node, so it is shell form; the prerequisites convention owns it,
+  # including the matcher that skips compaction.
+  def notice: [{matcher: "startup|resume|clear|fork", hooks: [{type: "command",
     command: "sh \"${CLAUDE_PLUGIN_ROOT}/lib/prerequisites.sh\" node-notice /testing:check; ${PPID:+exit}; powershell -NoProfile -ExecutionPolicy Bypass -File \"${CLAUDE_PLUGIN_ROOT}/lib/prerequisites.ps1\" node-notice /testing:check",
     timeout: 10, statusMessage: "Checking that node is on PATH..."}]}];
   {
@@ -60,7 +65,7 @@ json="$(jq -R . <<<"$globs" | jq -s '. as $globs |
     hooks: {
       PreToolUse: rows("test-weaken.sh"; {timeout: 10, statusMessage: "Checking the edit for removed assertions or skipped tests..."}),
       PostToolUse: (rows("test-scan.sh"; {timeout: 10, statusMessage: "Scanning the test file for tests that cannot fail..."})
-        + [{matcher: "Bash", hooks: [cmd(["TEST_GUARDS_ENABLED"]; "test-scan-bash.sh")
+        + [{matcher: "Bash", hooks: [cmd(["TEST_GUARDS_ENABLED"]; ["--skip-unless-stdin-contains", "bashEditDiff"]; "test-scan-bash.sh")
             + {timeout: 10, statusMessage: "Scanning test files the command changed..."}]}]
         + rows("test-judge-bg.sh"; {async: true})),
       Stop: judge("test-judge.sh"; {timeout: 240, statusMessage: "Collecting the test judge'"'"'s verdicts..."}),
diff --git a/plugins/typos-format/.claude-plugin/plugin.json b/plugins/typos-format/.claude-plugin/plugin.json
index 948ce9a892..7052b9ed4d 100644
--- a/plugins/typos-format/.claude-plugin/plugin.json
+++ b/plugins/typos-format/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "typos-format",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Spell-check on edit via typos-cli, unconditionally. Report-only by default, honoring the consuming repo's own typos configuration when one is present.",
   "author": {
     "name": "Melodic Software",
diff --git a/plugins/typos-format/CHANGELOG.md b/plugins/typos-format/CHANGELOG.md
index a7f38dc252..168be95553 100644
--- a/plugins/typos-format/CHANGELOG.md
+++ b/plugins/typos-format/CHANGELOG.md
@@ -3,6 +3,13 @@
 All notable changes to the `typos-format` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.9.7] - 2026-10-04
+
+### Changed
+
+- The SessionStart node-notice and formatter probe rows now match `startup|resume|clear|fork`, so a compaction no longer starts them; the session and its notice latches survive a compaction, so a re-fire printed nothing (#6251).
+- The shared `exec-bash.mjs` launcher copy gains the `--skip-if-all-false` and `--skip-unless-stdin-contains` flags; no row in this plugin uses them (#6252, #6253).
+
 ## [0.9.6] - 2026-10-04
 
 ### Changed
diff --git a/plugins/typos-format/hooks/exec-bash.mjs b/plugins/typos-format/hooks/exec-bash.mjs
index 75c44e37ca..460066f915 100755
--- a/plugins/typos-format/hooks/exec-bash.mjs
+++ b/plugins/typos-format/hooks/exec-bash.mjs
@@ -3,16 +3,37 @@
 // edit the canonical source, then rerun the script.
 // Exec-form entry for a bash-scripted hook (#3686).
 //
-// hooks.json spells `"command": "node"` and puts this file, then an
-// optional option gate, then the shell script and that script's own
-// arguments, in `args`. `--require-true NAME` exits 0 unless
-// CLAUDE_PLUGIN_OPTION_NAME is exactly `true`. `--run-if-unset-or-true NAME`
-// exits 0 only when that variable is set to something other than `true`.
-// A closed gate does not resolve or spawn bash. Bare `bash`
-// is not a legal exec-form command: on Windows it resolves to the WSL
-// relay and a failed hook launch does not block. This process finds a
-// real bash and spawns it with the script path as argv, stdin inherited,
-// and the child's exit code forwarded. `shell` is not used.
+// hooks.json spells `"command": "node"` and puts this file, then optional
+// launch flags, then the shell script and that script's own arguments, in
+// `args`. Each flag takes one value and sits before the script. Every flag
+// must pass (AND); a failed one exits 0 without resolving or spawning bash.
+//
+//   --require-true NAME          run only when CLAUDE_PLUGIN_OPTION_NAME is
+//                                exactly `true` (a default-off option).
+//   --run-if-unset-or-true NAME  run unless that variable is set to something
+//                                other than `true` (a default-on option).
+//   --skip-if-all-false A,B,...  skip only when every named variable is
+//                                exactly `false`. Unset, empty, `true` or any
+//                                other value runs, so a row whose script holds
+//                                several default-on switches skips only when
+//                                all of them are provably off.
+//   --skip-unless-stdin-contains TEXT
+//                                buffer stdin; skip when the payload lacks
+//                                TEXT, else write the same bytes to the script.
+//
+// Option flags are decided first, before stdin is touched. A stdin flag reads
+// stdin to EOF with an idle bound (2 s, or the stdin_read_timeout option read
+// the way hook-utils.sh reads it), and a stall exits 0 without running the
+// script. That fails OPEN, so a stdin flag is for advisory rows only: the
+// shared library treats a stalled payload as fail-closed for a blocking guard,
+// which must not use the flag as written. A row without a stdin flag keeps
+// stdin inherited.
+//
+// Bare `bash` is not a legal exec-form command: on Windows it resolves to the
+// WSL relay and a failed hook launch does not block. This process finds a
+// real bash and spawns it with the script path as argv, stdin inherited (or
+// written from the buffer), and the child's exit code forwarded. `shell` is
+// not used.
 //
 // On Windows the candidates, in order, are CLAUDE_CODE_GIT_BASH_PATH
 // (accepted only when the file is named bash.exe, sh.exe, bash, or sh),
@@ -69,41 +90,132 @@ function firstExisting(candidates, platform, exists) {
   return null;
 }
 
+const OPTION_NAME = /^[A-Z0-9_]+$/;
+const ONE_NAME = "needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)";
+const NAME_LIST = "needs a comma-separated list of CLAUDE_PLUGIN_OPTION_ suffixes (A-Z, digits, underscore)";
+
+function oneName(value) {
+  return value && !value.startsWith("-") && OPTION_NAME.test(value) ? [value] : null;
+}
+
+function nameList(value) {
+  if (!value || value.startsWith("-")) return null;
+  const names = value.split(",");
+  return names.every((name) => OPTION_NAME.test(name)) ? names : null;
+}
+
+function literal(value) {
+  return value ? value : null;
+}
+
+const optionValues = (names, env) => names.map((name) => env[`CLAUDE_PLUGIN_OPTION_${name}`]);
+const unsetOrTrue = (v) => v === undefined || v === "" || v === "true";
+
+// The launch flags. An `env` flag reads only CLAUDE_PLUGIN_OPTION_* values and
+// is decided before stdin is touched; a `stdin` flag reads the buffered
+// payload. `parse` returns the flag's value or null for a usage error; `open`
+// says whether the script runs.
+const FLAGS = {
+  "--require-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => optionValues(names, env)[0] === "true",
+  },
+  "--run-if-unset-or-true": {
+    phase: "env",
+    parse: oneName,
+    problem: ONE_NAME,
+    open: (names, env) => unsetOrTrue(optionValues(names, env)[0]),
+  },
+  "--skip-if-all-false": {
+    phase: "env",
+    parse: nameList,
+    problem: NAME_LIST,
+    open: (names, env) => !optionValues(names, env).every((v) => v === "false"),
+  },
+  // Advisory rows only: never put this on a blocking guard row. A stdin stall
+  // exits 0 without running the script, so a guard behind it would fail open.
+  "--skip-unless-stdin-contains": {
+    phase: "stdin",
+    parse: literal,
+    problem: "needs non-empty text to look for in stdin",
+    open: (text, input) => input.includes(text),
+  },
+};
+
+const USAGE = `usage: node exec-bash.mjs [${Object.keys(FLAGS)
+  .map((flag) => `${flag} V`)
+  .join(" | ")}]... <script> [args...]`;
+
 export function parseLaunchArgs(argv) {
   const gates = [];
   let i = 0;
-  while (i < argv.length) {
+  while (i < argv.length && Object.hasOwn(FLAGS, argv[i])) {
     const flag = argv[i];
-    if (flag !== "--require-true" && flag !== "--run-if-unset-or-true") break;
-    const name = argv[i + 1];
-    if (!name || name.startsWith("-") || !/^[A-Z0-9_]+$/.test(name)) {
-      return { error: `usage: ${flag} needs the CLAUDE_PLUGIN_OPTION_ suffix (A-Z, digits, underscore)` };
-    }
-    gates.push({ flag, name });
+    const value = FLAGS[flag].parse(argv[i + 1]);
+    if (value === null) return { error: `usage: ${flag} ${FLAGS[flag].problem}` };
+    gates.push({ flag, value });
     i += 2;
   }
   const script = argv[i];
-  if (!script) {
-    return {
-      error: "usage: node exec-bash.mjs [--require-true NAME | --run-if-unset-or-true NAME] <script> [args...]",
-    };
-  }
+  if (!script) return { error: USAGE };
   return { gates, script, args: argv.slice(i + 1) };
 }
 
-// A closed gate exits 0 before bash is resolved. --require-true matches a
-// default-off option (unset is off). --run-if-unset-or-true matches a
-// default-on option (only an explicit non-true value skips).
+function gatesOpen(gates, phase, subject) {
+  return gates.every((gate) => FLAGS[gate.flag].phase !== phase || FLAGS[gate.flag].open(gate.value, subject));
+}
+
+// The option flags. A closed gate exits 0 before stdin is read or bash is
+// resolved.
 export function optionGateOpen(gates, env) {
-  for (const gate of gates) {
-    const value = env[`CLAUDE_PLUGIN_OPTION_${gate.name}`];
-    if (gate.flag === "--require-true") {
-      if (value !== "true") return false;
-    } else if (value !== undefined && value !== "" && value !== "true") {
-      return false;
-    }
-  }
-  return true;
+  return gatesOpen(gates, "env", env);
+}
+
+export function needsStdin(gates) {
+  return gates.some((gate) => FLAGS[gate.flag].phase === "stdin");
+}
+
+// The stdin flags, over the buffered payload (a Buffer).
+export function stdinGateOpen(gates, input) {
+  return gatesOpen(gates, "stdin", input);
+}
+
+// The idle bound hook::resolve_read_timeout_to applies: the stdin_read_timeout
+// option in seconds when it is a positive decimal of at least 10 microseconds,
+// else 2 s.
+export function stdinIdleMs(env) {
+  const raw = env.CLAUDE_PLUGIN_OPTION_STDIN_READ_TIMEOUT ?? "";
+  const seconds = /^[0-9]+(\.[0-9]+)?$/.test(raw) ? Number(raw) : 0;
+  return seconds >= 0.00001 ? seconds * 1000 : 2000;
+}
+
+// Read the stream to EOF. Resolves the bytes, or null when no byte arrives for
+// idleMs (a stall). A read error ends the read with what arrived.
+export function readStdin(idleMs, stream = process.stdin) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let timer;
+    const done = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        stream.destroy();
+        done(null);
+      }, idleMs);
+    };
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      arm();
+    });
+    stream.on("end", () => done(Buffer.concat(chunks)));
+    stream.on("error", () => done(Buffer.concat(chunks)));
+    arm();
+  });
 }
 
 function pathCandidates(env, platform) {
@@ -171,19 +283,29 @@ function fail(line) {
   process.exit(1);
 }
 
-function main() {
+async function main() {
   const parsed = parseLaunchArgs(process.argv.slice(2));
   if (parsed.error) fail(failureLine("usage", { detail: parsed.error }));
   if (!optionGateOpen(parsed.gates, process.env)) process.exit(0);
+  let input = null;
+  if (needsStdin(parsed.gates)) {
+    input = await readStdin(stdinIdleMs(process.env));
+    if (input === null || !stdinGateOpen(parsed.gates, input)) process.exit(0);
+  }
   const { platform } = process;
   const bash = resolveBash(process.env, platform, isFile);
   const ctx = { script: parsed.script, bash, platform };
   if (!bash) fail(failureLine("no-bash", ctx));
   const child = spawn(bash, [parsed.script, ...parsed.args], {
-    stdio: "inherit",
+    stdio: input !== null ? ["pipe", "inherit", "inherit"] : "inherit",
     windowsHide: true,
     shell: false,
   });
+  if (input !== null) {
+    // A script that exits without reading closes the pipe; that is not a failure.
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  }
   const forward = (signal) => {
     if (!child.killed) child.kill(signal);
   };
diff --git a/plugins/typos-format/hooks/hooks.json b/plugins/typos-format/hooks/hooks.json
index 26b9956b28..0909b43d4f 100644
--- a/plugins/typos-format/hooks/hooks.json
+++ b/plugins/typos-format/hooks/hooks.json
@@ -22,6 +22,7 @@
     ],
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
@@ -39,6 +40,7 @@
         ]
       },
       {
+        "matcher": "startup|resume|clear|fork",
         "hooks": [
           {
             "type": "command",
diff --git a/scripts/node-notice-rows.test.sh b/scripts/node-notice-rows.test.sh
index 414303b956..6c26f75fb4 100755
--- a/scripts/node-notice-rows.test.sh
+++ b/scripts/node-notice-rows.test.sh
@@ -17,18 +17,24 @@ ROOT="$(cd "$SELF_DIR/.." && pwd)"
 . "$SELF_DIR/lib/test-harness.sh"
 
 MARKER='prerequisites.sh" node-notice'
+# Every SessionStart source but compact (https://code.claude.com/docs/en/hooks, SessionStart
+# matcher table, as of 2026-10-04): the notice and probe latches outlive a compaction, so a
+# re-fire there prints nothing and only starts processes.
+MATCHER='startup|resume|clear|fork'
 
 # --- fleet shape ----------------------------------------------------------------
 rows_checked=0
 for hooks in "$ROOT"/plugins/*/hooks/hooks.json; do
   plugin="$(basename "$(dirname "$(dirname "$hooks")")")"
-  mapfile -t rows < <(jq -r '[.hooks.SessionStart[]?.hooks[]? | select((.command // "") | contains("prerequisites.sh")) | .command] | .[]' "$hooks")
+  mapfile -t rows < <(jq -r '[.hooks.SessionStart[]? | . as $g | .hooks[]? | select((.command // "") | contains("prerequisites.sh")) | "\($g.matcher // "")\t\(.command)"] | .[]' "$hooks")
   if ((${#rows[@]} != 1)); then
     bad "$plugin: want exactly one node-notice SessionStart row" "found ${#rows[@]}"
     continue
   fi
   rows_checked=$((rows_checked + 1))
-  row="${rows[0]}"
+  matcher="${rows[0]%%$'\t'*}"
+  row="${rows[0]#*$'\t'}"
+  [[ "$matcher" == "$MATCHER" ]] || bad "$plugin: the node-notice row's group matcher is not $MATCHER" "matcher=$matcher"
   [[ "$row" == *"$MARKER"* ]] || bad "$plugin: the row does not call prerequisites.sh node-notice" "$row"
   skill=check
   [[ -d "$ROOT/plugins/$plugin/skills/check-prerequisites" ]] && skill=check-prerequisites
@@ -56,6 +62,22 @@ else
   bad "too few plugins carry the row" "$rows_checked"
 fi
 
+# --- the probe rows: the same matcher -------------------------------------------
+probes=0
+for hooks in "$ROOT"/plugins/*/hooks/hooks.json; do
+  plugin="$(basename "$(dirname "$(dirname "$hooks")")")"
+  while IFS= read -r matcher; do
+    probes=$((probes + 1))
+    matcher="${matcher%$'\r'}"
+    [[ "$matcher" == "$MATCHER" ]] || bad "$plugin: the prerequisites.mjs probe row's group matcher is not $MATCHER" "matcher=$matcher"
+  done < <(jq -r '.hooks.SessionStart[]? | . as $g | .hooks[]? | select(((.args // [])[0] // "" | endswith("/lib/prerequisites.mjs")) and (.args[1] == "probe")) | $g.matcher // ""' "$hooks")
+done
+if ((probes >= 8)); then
+  ok "$probes SessionStart probe rows checked for the $MATCHER matcher"
+else
+  bad "too few SessionStart probe rows found" "$probes"
+fi
+
 # --- the row, run with node absent ------------------------------------------------
 WORK="$(mktemp -d)"
 trap 'rm -rf "$WORK"' EXIT