diff --git a/apps/supervisor/README.md b/apps/supervisor/README.md
index 326a6fd..020e29c 100644
--- a/apps/supervisor/README.md
+++ b/apps/supervisor/README.md
@@ -81,11 +81,13 @@ The KISS watcher script runs one deterministic supervisor invocation per child o
 node scripts/ickb-supervisor-loop.mjs --max-runs 1 --stable-limit 2 --backoff-seconds 0 -- --scenario standard-cycle --max-cycles 1
 ```
 
-Loop-owned options go before `--`; supervisor options go after `--`. If using `pnpm live:supervisor:loop`, keep loop-owned options before the first `--` so they are not passed through to the supervisor. The loop stops on supervisor nonzero exit, incident artifacts listed in `summary.json`, tx-creating outcomes or tx hashes for tx-creating outcomes, a new outcome after the first run, repeated no-progress signatures, or `--max-runs`.
+Loop-owned options go before `--`; supervisor options go after `--`. If using `pnpm live:supervisor:loop`, keep loop-owned options before the first `--` so they are not passed through to the supervisor. The loop stops on supervisor nonzero exit, incident artifacts listed in `summary.json`, tx-creating outcomes or tx hashes for tx-creating outcomes, a new outcome after the first run, repeated no-progress signatures, or `--max-runs`. `-- --help` and `-- -h` are child help passthroughs: the delegated help is printed and the wrapper exits with the child status.
 
 The external loop also has a loop-owned `--child-timeout-seconds` guard for the supervisor child process. Keep it long enough for the whole delegated supervisor run, including actor preflights and actor commands, not just one `--command-timeout-seconds` window. The dynamic loop defaults this guard to the supervisor-loop default so the supervisor keeps ownership of killing funded actor process groups on command timeout.
 
-For continuous tester-bot matching, use `node scripts/ickb-supervisor-dynamic-loop.mjs` or `pnpm live:supervisor:dynamic-loop`. This remains outside `apps/supervisor`: it reads tester preflight balance summaries, chooses a currently fundable tester scenario, and delegates each bounded chunk to `scripts/ickb-supervisor-loop.mjs`. When `--target-outcome tester_fresh_order_skip` is passed through, supervisor auto-planning can choose `tester-fresh-skip-two-pass`; the dynamic loop itself only chooses fundable tester stimuli.
+For continuous tester-bot matching, use `node scripts/ickb-supervisor-dynamic-loop.mjs` or `pnpm live:supervisor:dynamic-loop`. This remains outside `apps/supervisor`: it reads tester preflight balance summaries, chooses a currently fundable tester scenario, and delegates each bounded chunk to `scripts/ickb-supervisor-loop.mjs`. When `--target-outcome tester_fresh_order_skip` is passed through, supervisor auto-planning can choose `tester-fresh-skip-two-pass`; the dynamic loop itself only chooses fundable tester stimuli. The dynamic loop also treats `-- --help` and `-- -h` as child help passthroughs and exits with the delegated status.
+
+Loop and dynamic-loop exit codes are operator-visible control flow: tx/new-outcome stops exit `0`, incidents exit `2`, `max_runs` and `stable_no_progress` inspection stops exit `3`, and child nonzero statuses are preserved.
 
 Dynamic loop sessions are live-validation artifacts, separate from production bot-only logs. They default to ignored `log/validation/dynamic-<time>-<pid>/`; override the root with `--log-root <path>` or pin one run with `--session-root <path>`. The session root must be exactly `<log-root>/validation/<session>`, stay under the resolved log root, avoid symlinked parents, and not already exist. The dynamic loop derives its chunk timeout from the delegated supervisor-loop child timeout, chunk run count, and chunk backoff unless `--chunk-timeout-seconds` is explicitly set high enough, so an outer chunk timeout does not kill the supervisor-loop process before it can enforce its child cleanup boundary.
 
diff --git a/apps/supervisor/src/index.test.ts b/apps/supervisor/src/index.test.ts
index 8a7cf49..ffe57a8 100644
--- a/apps/supervisor/src/index.test.ts
+++ b/apps/supervisor/src/index.test.ts
@@ -1496,6 +1496,7 @@ describe("classification", () => {
       outcome: "bot_match_committed",
       terminal: false,
       actions: { matchedOrders: 1, deposits: 0 },
+      txHashes: [txHash("44")],
     });
   });
 
@@ -1516,6 +1517,7 @@ describe("classification", () => {
     expect(classifyActorResult("bot", commandResult("bot", stdout))).toMatchObject({
       outcome: "terminal_chain_rejection",
       terminal: true,
+      txHashes: [txHash("46")],
     });
   });
 
@@ -1726,6 +1728,87 @@ describe("classification", () => {
     });
   });
 
+  it("preserves accepted tx hashes in generic early classifications", () => {
+    expect(classifyActorResult("tester", {
+      ...commandResult("tester", JSON.stringify({ txHash: txHash("50") })),
+      timedOut: true,
+    })).toMatchObject({
+      outcome: "command_timeout",
+      txHashes: [txHash("50")],
+    });
+    expect(classifyActorResult("bot", {
+      ...commandResult("bot", JSON.stringify(botEvent("bot.transaction.committed", { txHash: txHash("51") }))),
+      spawnError: "ENOENT",
+      status: null,
+    })).toMatchObject({
+      outcome: "nonzero_exit",
+      txHashes: [txHash("51")],
+    });
+    expect(classifyActorResult("bot", {
+      ...commandResult("bot", JSON.stringify(botEvent("bot.transaction.committed", { txHash: txHash("52") }))),
+      stdoutTruncated: true,
+    })).toMatchObject({
+      outcome: "malformed_evidence",
+      txHashes: [txHash("52")],
+    });
+    expect(classifyActorResult("tester", commandResult("tester", [
+      JSON.stringify({ txHash: txHash("53") }),
+      "{not-json}",
+    ].join("\n")))).toMatchObject({
+      outcome: "malformed_evidence",
+      txHashes: [txHash("53")],
+    });
+  });
+
+  it("preserves accepted preflight tx hashes in generic early classifications", () => {
+    expect(classifyActorResult("preflight", {
+      ...commandResult("preflight", JSON.stringify({ txHash: txHash("54"), bounded: true, maxIterations: 1 }, null, 2)),
+      timedOut: true,
+    })).toMatchObject({
+      outcome: "command_timeout",
+      txHashes: [txHash("54")],
+    });
+  });
+
+  it("does not preserve conflicted tx hashes in generic early classifications", () => {
+    expect(classifyActorResult("tester", {
+      ...commandResult("tester", JSON.stringify({ txHash: txHash("56"), error: { txHash: txHash("57") } })),
+      timedOut: true,
+    })).toMatchObject({
+      outcome: "command_timeout",
+      txHashes: [],
+    });
+  });
+
+  it("rejects bot post-broadcast failures with mismatched tx hash evidence", () => {
+    const stdout = JSON.stringify(botEvent("bot.transaction.failed", {
+      outcome: "post_broadcast_unresolved",
+      txHash: txHash("58"),
+      error: { txHash: txHash("59") },
+    }));
+
+    expect(classifyActorResult("bot", commandResult("bot", stdout))).toMatchObject({
+      outcome: "malformed_evidence",
+      terminal: true,
+      reason: "bot post-broadcast transaction failure evidence contained mismatched tx hashes",
+      txHashes: [],
+    });
+  });
+
+  it("rejects tester skips with mismatched tx hash evidence", () => {
+    const stdout = JSON.stringify({
+      txHash: txHash("5a"),
+      skip: { reason: "fresh-matchable-order", txHash: txHash("5b") },
+    });
+
+    expect(classifyActorResult("tester", commandResult("tester", stdout))).toMatchObject({
+      outcome: "malformed_evidence",
+      terminal: true,
+      reason: "tester skip evidence contained mismatched tx hashes",
+      txHashes: [],
+    });
+  });
+
   it("keeps tester confirmation timeouts classified by safety evidence despite exit code 2", () => {
     const result = {
       ...commandResult("tester", JSON.stringify({
@@ -1747,6 +1830,49 @@ describe("classification", () => {
     });
   });
 
+  it("counts matching top-level and nested tester transaction failure tx hashes once", () => {
+    const result = {
+      ...commandResult("tester", JSON.stringify({
+        txHash: txHash("ae"),
+        error: {
+          name: "TransactionConfirmationError",
+          message: "Transaction confirmation timed out",
+          txHash: txHash("ae"),
+          isTimeout: true,
+        },
+      })),
+      status: 2,
+    };
+
+    expect(classifyActorResult("tester", result)).toMatchObject({
+      outcome: "confirmation_timeout",
+      terminal: true,
+      txHashes: [txHash("ae")],
+    });
+  });
+
+  it("rejects mismatched top-level and nested tester transaction failure tx hashes", () => {
+    const result = {
+      ...commandResult("tester", JSON.stringify({
+        txHash: txHash("ae"),
+        error: {
+          name: "TransactionConfirmationError",
+          message: "Transaction confirmation timed out",
+          txHash: txHash("af"),
+          isTimeout: true,
+        },
+      })),
+      status: 2,
+    };
+
+    expect(classifyActorResult("tester", result)).toMatchObject({
+      outcome: "malformed_evidence",
+      terminal: true,
+      reason: "tester transaction failure evidence contained mismatched tx hashes",
+      txHashes: [],
+    });
+  });
+
   it("classifies serialized tester post-broadcast unresolved failures", () => {
     const result = {
       ...commandResult("tester", JSON.stringify({
@@ -3015,6 +3141,55 @@ describe("deterministic incident handling", () => {
     });
   });
 
+  it("counts matching top-level and nested transaction hashes once in summaries", async () => {
+    const writes = new Map<string, string>();
+    const args = parseArgs([
+      "--bot-config", "config/bot-testnet.json",
+      "--tester-config", "config/tester-testnet.json",
+      "--out-dir", "logs/live-supervisor/dedup-tx-hash-summary-test",
+      "--scenario", "bot-only",
+      "--stop-after-tx-count", "1",
+      "--max-cycles", "1",
+    ]);
+    const plan = resolvePlan(args, "/repo", { spawnSyncCommand: ignoredChecker(true) });
+
+    const exitCode = await supervise(args, plan, {
+      skipBuiltRuntimeCheck: true,
+      spawnCommand: ((_command: string, commandArgs: string[]) => isPreflightCommand(commandArgs) ? fakeSuccessfulPreflightChild() : fakeChild([
+        JSON.stringify(botEvent("bot.transaction.built", {
+          actions: { collectedOrders: 0, completedDeposits: 0, matchedOrders: 1, deposits: 0, withdrawalRequests: 0, withdrawals: 0 },
+        })),
+        JSON.stringify(botEvent("bot.transaction.committed", {
+          txHash: txHash("5c"),
+          error: { txHash: txHash("5c") },
+        })),
+      ].join("\n"))) as never,
+      spawnSyncCommand: ignoredChecker(true) as never,
+      stat: missingStat,
+      mkdir: () => Promise.resolve(undefined),
+      appendFile: (path, text) => {
+        const key = pathToString(path);
+        writes.set(key, `${writes.get(key) ?? ""}${textToString(text)}`);
+        return Promise.resolve();
+      },
+      writeFile: (path, text) => {
+        writes.set(pathToString(path), textToString(text));
+        return Promise.resolve();
+      },
+    });
+
+    expect(exitCode).toBe(0);
+    const summary = jsonArtifact(writes, "/repo/logs/live-supervisor/dedup-tx-hash-summary-test/summary.json");
+    expect(summary).toMatchObject({
+      stopped: "stop_after_tx_count",
+      txCreatingTxHashCount: 1,
+      txCreatingOutcomeCount: 1,
+    });
+    expect(recordAt(summary["txHashesByOutcome"], "summary tx hashes")).toEqual({
+      bot_match_committed: [txHash("5c")],
+    });
+  });
+
 });
 
 function commandResult(actor: "bot" | "tester" | "preflight", stdout: string): CommandResult {
diff --git a/apps/supervisor/src/index.ts b/apps/supervisor/src/index.ts
index 95c2c7a..50e932e 100644
--- a/apps/supervisor/src/index.ts
+++ b/apps/supervisor/src/index.ts
@@ -541,10 +541,9 @@ export function classifyActorResult(
   const evidence = actor === "preflight"
     ? parsePreflightEvidence(result.stdout)
     : parseJsonEvidence(result.stdout);
-  const txHashes = extractTxHashes(evidence.records);
   const base = {
     actor,
-    txHashes,
+    txHashes: [],
     evidence: {
       recordsAccepted: evidence.records.length,
       ignoredLineCount: evidence.ignoredLines.length,
@@ -556,10 +555,11 @@ export function classifyActorResult(
       stderrTruncated: result.stderrTruncated,
     },
   };
+  const genericBase = { ...base, txHashes: extractTxHashes(evidence.records) ?? [] };
 
   if (result.timedOut) {
     return {
-      ...base,
+      ...genericBase,
       outcome: "command_timeout",
       terminal: true,
       reason: "supervisor command timeout expired",
@@ -567,7 +567,7 @@ export function classifyActorResult(
   }
   if (result.spawnError !== undefined) {
     return {
-      ...base,
+      ...genericBase,
       outcome: "nonzero_exit",
       terminal: true,
       reason: `${actor} failed to spawn: ${result.spawnError}`,
@@ -575,7 +575,7 @@ export function classifyActorResult(
   }
   if (result.stdoutTruncated || result.stderrTruncated) {
     return {
-      ...base,
+      ...genericBase,
       outcome: "malformed_evidence",
       terminal: true,
       reason: result.stdoutTruncated
@@ -585,7 +585,7 @@ export function classifyActorResult(
   }
   if (evidence.malformedLines.length > 0) {
     return {
-      ...base,
+      ...genericBase,
       outcome: "malformed_evidence",
       terminal: true,
       reason: "stdout contained malformed JSON evidence",
@@ -1312,26 +1312,39 @@ function classifyBotResult(
     const outcome = stringField(failed, "outcome");
     const phase = stringField(failed, "phase");
     if (outcome === "timeout_after_broadcast" || outcome === "post_broadcast_unresolved" || outcome === "terminal_rejection") {
+      const txHashes = extractTxHashes([failed]);
+      if (txHashes === undefined) {
+        return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot post-broadcast transaction failure evidence contained mismatched tx hashes", publicState };
+      }
       if (!hasValidTxHash(failed)) {
         return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot post-broadcast transaction failure evidence did not include a valid tx hash", publicState };
       }
       if (outcome === "timeout_after_broadcast") {
-        return { ...base, outcome: "confirmation_timeout", terminal: true, reason: "bot tx confirmation timed out", publicState };
+        return { ...base, txHashes, outcome: "confirmation_timeout", terminal: true, reason: "bot tx confirmation timed out", publicState };
       }
       if (outcome === "post_broadcast_unresolved") {
-        return { ...base, outcome: "post_broadcast_unresolved", terminal: true, reason: "bot tx remained unresolved after broadcast", publicState };
+        return { ...base, txHashes, outcome: "post_broadcast_unresolved", terminal: true, reason: "bot tx remained unresolved after broadcast", publicState };
       }
-      return { ...base, outcome: "terminal_chain_rejection", terminal: true, reason: "bot tx reached terminal chain rejection", publicState };
+      return { ...base, txHashes, outcome: "terminal_chain_rejection", terminal: true, reason: "bot tx reached terminal chain rejection", publicState };
     }
     if (phase === "pre_broadcast" && (failed["retryable"] !== true || failed["terminal"] !== false)) {
-      return { ...base, outcome: "unknown", terminal: true, reason: "bot pre-broadcast transaction failure", publicState };
+      const txHashes = extractTxHashes([failed]);
+      if (txHashes === undefined) {
+        return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot pre-broadcast transaction failure evidence contained mismatched tx hashes", publicState };
+      }
+      return { ...base, txHashes, outcome: "unknown", terminal: true, reason: "bot pre-broadcast transaction failure", publicState };
     }
   }
 
   const skip = lastRecordOfType(botRecords, "bot.decision.skipped");
   if (skip !== undefined && stringField(skip, "reason") === "capital_below_minimum") {
+    const txHashes = extractTxHashes([skip]);
+    if (txHashes === undefined) {
+      return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot skip evidence contained mismatched tx hashes", publicState };
+    }
     return {
       ...base,
+      txHashes,
       outcome: "low_capital_stop",
       terminal: true,
       reason: "bot reported capital_below_minimum",
@@ -1364,17 +1377,22 @@ function classifyBotResult(
 
   if (lifecycle?.type === "bot.transaction.committed") {
     const committed = lifecycle.record;
+    const txHashes = extractTxHashes([committed]);
+    if (txHashes === undefined) {
+      return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot committed transaction evidence contained mismatched tx hashes", publicState };
+    }
     if (!hasValidTxHash(committed)) {
       return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot committed transaction evidence did not include a valid tx hash", publicState };
     }
     const actions = latestBotActions(botRecords, numberField(committed, "iterationId"));
     if (actions === undefined) {
-      return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot committed transaction evidence did not include matching built action evidence", publicState };
+      return { ...base, txHashes, outcome: "malformed_evidence", terminal: true, reason: "bot committed transaction evidence did not include matching built action evidence", publicState };
     }
     const outcome = classifyBotCommittedActions(actions);
     if (outcome === "unknown") {
       return {
         ...base,
+        txHashes,
         outcome,
         terminal: true,
         reason: "bot committed transaction evidence did not include classifiable action evidence",
@@ -1384,6 +1402,7 @@ function classifyBotResult(
     }
     return {
       ...base,
+      txHashes,
       outcome,
       terminal: false,
       reason: "bot transaction committed according to app evidence",
@@ -1395,9 +1414,14 @@ function classifyBotResult(
   if (skip !== undefined) {
     const reason = stringField(skip, "reason") ?? "unknown";
     const actions = actionCounts(skip["actions"]);
+    const txHashes = extractTxHashes([skip]);
+    if (txHashes === undefined) {
+      return { ...base, outcome: "malformed_evidence", terminal: true, reason: "bot skip evidence contained mismatched tx hashes", publicState };
+    }
     if (reason === "post_tx_ckb_reserve") {
       return {
         ...base,
+        txHashes,
         outcome: "bot_reserve_skip",
         terminal: false,
         reason: "bot skipped to preserve CKB reserve",
@@ -1408,6 +1432,7 @@ function classifyBotResult(
     }
     return {
       ...base,
+      txHashes,
       outcome: "bot_no_action_skip",
       terminal: false,
       reason: `bot skipped: ${reason}`,
@@ -1462,41 +1487,50 @@ function classifyTesterResult(
     const skip = recordField(latest, "skip");
     if (skip !== undefined) {
       const reason = stringField(skip, "reason") ?? "unknown";
+      const txHashes = extractTxHashes([latest]);
+      if (txHashes === undefined) {
+        return { ...base, outcome: "malformed_evidence", terminal: true, reason: "tester skip evidence contained mismatched tx hashes" };
+      }
       if (reason === "fresh-matchable-order") {
-        return { ...base, outcome: "tester_fresh_order_skip", terminal: false, reason: "tester skipped fresh matchable order", skipReason: reason };
+        return { ...base, txHashes, outcome: "tester_fresh_order_skip", terminal: false, reason: "tester skipped fresh matchable order", skipReason: reason };
       }
       if (reason === "matchable-order-transaction-missing") {
-        return { ...base, outcome: "tester_fresh_order_skip", terminal: false, reason: "tester skipped because matchable order transaction was not readable yet", skipReason: reason };
+        return { ...base, txHashes, outcome: "tester_fresh_order_skip", terminal: false, reason: "tester skipped because matchable order transaction was not readable yet", skipReason: reason };
       }
       if (reason === "sampled-amount-too-small") {
-        return { ...base, outcome: "tester_sampled_too_small_skip", terminal: false, reason: "tester sampled amount too small", skipReason: reason };
+        return { ...base, txHashes, outcome: "tester_sampled_too_small_skip", terminal: false, reason: "tester sampled amount too small", skipReason: reason };
       }
       if (reason === "estimated-conversion-too-small") {
-        return { ...base, outcome: "tester_estimated_too_small_skip", terminal: false, reason: "tester estimate converted amount too small", skipReason: reason };
+        return { ...base, txHashes, outcome: "tester_estimated_too_small_skip", terminal: false, reason: "tester estimate converted amount too small", skipReason: reason };
       }
       if (reason === "post-tx-ckb-reserve") {
-        return { ...base, outcome: "tester_reserve_skip", terminal: false, reason: "tester skipped to preserve CKB reserve", skipReason: reason };
+        return { ...base, txHashes, outcome: "tester_reserve_skip", terminal: false, reason: "tester skipped to preserve CKB reserve", skipReason: reason };
       }
-      return { ...base, outcome: "unknown", terminal: true, reason: `tester skip reason is not classified: ${reason}`, skipReason: reason };
+      return { ...base, txHashes, outcome: "unknown", terminal: true, reason: `tester skip reason is not classified: ${reason}`, skipReason: reason };
     }
 
     if ("txHash" in latest) {
+      const txHashes = extractTxHashes([latest]);
+      if (txHashes === undefined) {
+        return { ...base, outcome: "malformed_evidence", terminal: true, reason: "tester committed transaction evidence contained mismatched tx hashes" };
+      }
       if (!hasValidTxHash(latest)) {
         return { ...base, outcome: "malformed_evidence", terminal: true, reason: "tester committed transaction evidence did not include a valid tx hash" };
       }
       const actions = recordField(latest, "actions");
       const expectationFailure = validateTesterEvidenceExpectation(actions, expectation);
       if (expectationFailure !== undefined) {
-        return { ...base, outcome: "tester_deterministic_pre_broadcast_error", terminal: true, reason: expectationFailure };
+        return { ...base, txHashes, outcome: "tester_deterministic_pre_broadcast_error", terminal: true, reason: expectationFailure };
       }
       const testerOrder = testerOrderEvidence(actions);
       const conversionKind = stringField(recordField(actions ?? {}, "conversion"), "kind");
       if (testerOrder === undefined && conversionKind === undefined) {
-        return { ...base, outcome: "malformed_evidence", terminal: true, reason: "tester committed transaction evidence did not include action evidence" };
+        return { ...base, txHashes, outcome: "malformed_evidence", terminal: true, reason: "tester committed transaction evidence did not include action evidence" };
       }
       if (conversionKind !== undefined) {
         return {
           ...base,
+          txHashes,
           outcome: "tester_conversion_created",
           terminal: false,
           reason: "tester created a direct conversion transaction",
@@ -1505,6 +1539,7 @@ function classifyTesterResult(
       }
       return {
         ...base,
+        txHashes,
         outcome: "tester_order_created",
         terminal: false,
         reason: "tester created an order transaction",
@@ -2071,20 +2106,32 @@ function emptyActions(): ActionCounts {
   };
 }
 
-function extractTxHashes(records: Record<string, unknown>[]): string[] {
+function extractTxHashes(records: Record<string, unknown>[]): string[] | undefined {
   const hashes = new Set<string>();
   for (const record of records) {
-    addValidTxHash(hashes, stringField(record, "txHash"));
-    addValidTxHash(hashes, stringField(recordField(record, "error"), "txHash"));
-    addValidTxHash(hashes, stringField(recordField(record, "skip"), "txHash"));
+    const recordHashes = validTxHashes([
+      stringField(record, "txHash"),
+      stringField(recordField(record, "error"), "txHash"),
+      stringField(recordField(record, "skip"), "txHash"),
+    ]);
+    if (recordHashes.length > 1) {
+      return undefined;
+    }
+    for (const hash of recordHashes) {
+      hashes.add(hash);
+    }
   }
   return [...hashes];
 }
 
-function addValidTxHash(hashes: Set<string>, value: unknown): void {
-  if (typeof value === "string" && TX_HASH_PATTERN.test(value)) {
-    hashes.add(value);
+function validTxHashes(values: unknown[]): string[] {
+  const hashes = new Set<string>();
+  for (const value of values) {
+    if (typeof value === "string" && TX_HASH_PATTERN.test(value)) {
+      hashes.add(value);
+    }
   }
+  return [...hashes];
 }
 
 function hasValidTxHash(record: Record<string, unknown>): boolean {
@@ -2092,10 +2139,6 @@ function hasValidTxHash(record: Record<string, unknown>): boolean {
   return typeof txHash === "string" && TX_HASH_PATTERN.test(txHash);
 }
 
-function hasValidTxHashInRecordOrError(record: Record<string, unknown>): boolean {
-  return hasValidTxHash(record) || hasValidTxHash(recordField(record, "error") ?? {});
-}
-
 function minimalProcessEnv(env: NodeJS.ProcessEnv): Record<string, string> {
   return Object.fromEntries(["PATH", "HOME", "LANG", "LC_ALL", "TERM"].flatMap((key) => {
     const value = env[key];
@@ -2111,23 +2154,27 @@ function liveActorEnv(extra: Record<string, string>): Record<string, string> {
   };
 }
 
-function classifyTesterTransactionFailure(value: unknown, record: Record<string, unknown>): Pick<Classification, "outcome" | "terminal" | "reason"> | undefined {
+function classifyTesterTransactionFailure(value: unknown, record: Record<string, unknown>): Pick<Classification, "outcome" | "terminal" | "reason" | "txHashes"> | undefined {
   if (!isRecord(value)) {
     return undefined;
   }
   if (stringField(value, "name") !== "TransactionConfirmationError") {
     return undefined;
   }
-  if (!hasValidTxHashInRecordOrError(record)) {
-    return { outcome: "malformed_evidence", terminal: true, reason: "tester transaction failure evidence did not include a valid tx hash" };
+  const txHashes = extractTxHashes([record]);
+  if (txHashes === undefined) {
+    return { outcome: "malformed_evidence", terminal: true, reason: "tester transaction failure evidence contained mismatched tx hashes", txHashes: [] };
+  }
+  if (txHashes.length === 0) {
+    return { outcome: "malformed_evidence", terminal: true, reason: "tester transaction failure evidence did not include a valid tx hash", txHashes: [] };
   }
   if (value["isTimeout"] === false) {
-    return { outcome: "terminal_chain_rejection", terminal: true, reason: "tester tx reached terminal chain rejection" };
+    return { outcome: "terminal_chain_rejection", terminal: true, reason: "tester tx reached terminal chain rejection", txHashes };
   }
   if (value["isTimeout"] === true && "cause" in value) {
-    return { outcome: "post_broadcast_unresolved", terminal: true, reason: "tester tx remained unresolved after broadcast" };
+    return { outcome: "post_broadcast_unresolved", terminal: true, reason: "tester tx remained unresolved after broadcast", txHashes };
   }
-  return { outcome: "confirmation_timeout", terminal: true, reason: "tester transaction confirmation timed out" };
+  return { outcome: "confirmation_timeout", terminal: true, reason: "tester transaction confirmation timed out", txHashes };
 }
 
 function isTesterFundingError(value: unknown): boolean {
diff --git a/scripts/ickb-supervisor-dynamic-loop.mjs b/scripts/ickb-supervisor-dynamic-loop.mjs
index 894878c..94b9f48 100644
--- a/scripts/ickb-supervisor-dynamic-loop.mjs
+++ b/scripts/ickb-supervisor-dynamic-loop.mjs
@@ -5,7 +5,10 @@ import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseNonNegativeInteger, parsePositiveInteger, valueAfter } from "./ickb-script-helpers.mjs";
-import { DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE as DEFAULT_SUPERVISOR_LOOP_CHILD_TIMEOUT_SECONDS } from "./ickb-supervisor-loop.mjs";
+import {
+  DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE as DEFAULT_SUPERVISOR_LOOP_CHILD_TIMEOUT_SECONDS,
+  INSPECTION_REQUIRED_EXIT_CODE,
+} from "./ickb-supervisor-loop.mjs";
 
 const rootDir = fileURLToPath(new URL("..", import.meta.url));
 const CKB_UNIT = 100000000n;
@@ -22,6 +25,22 @@ export const DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE = DEFAULT_CHILD_TIMEOUT_SECONDS
 const DEFAULT_COMMAND_TIMEOUT_SECONDS = 240;
 const DEFAULT_CHUNK_TIMEOUT_MARGIN_SECONDS = 60;
 const DEFAULT_PREFLIGHT_TIMEOUT_SECONDS = 120;
+const DYNAMIC_LOOP_OWNED_FLAGS = [
+  "--tester-config",
+  "--preflight-role",
+  "--preflight-script",
+  "--supervisor-loop-script",
+  "--log-root",
+  "--session-root",
+  "--max-chunks",
+  "--chunk-max-runs",
+  "--stable-limit",
+  "--chunk-backoff-seconds",
+  "--between-chunks-seconds",
+  "--child-timeout-seconds",
+  "--chunk-timeout-seconds",
+  "--preflight-timeout-seconds",
+];
 const ALL_CKB_MIN_CKB = 3001n;
 const ICKB_STIMULUS_MIN_CKB = 2100n;
 const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
@@ -116,6 +135,10 @@ export function parseArgs(argv) {
     }
     throw new Error(`Unknown argument: ${arg}`);
   }
+  const misplacedDynamicLoopFlag = firstMatchingFlag(args.supervisorArgs, DYNAMIC_LOOP_OWNED_FLAGS);
+  if (misplacedDynamicLoopFlag !== undefined) {
+    throw new Error(`Do not pass dynamic-loop option ${misplacedDynamicLoopFlag} after --; put dynamic-loop options before --`);
+  }
   if (args.supervisorArgs.some((arg) => arg === "--out-dir" || arg.startsWith("--out-dir="))) {
     throw new Error("Do not pass supervisor --out-dir; dynamic-loop owns the session chunk roots");
   }
@@ -154,6 +177,7 @@ export function usage() {
     "  --session-root <path>                 Default: <log-root>/validation/dynamic-<time>-<pid>",
     "  -h, --help",
     "  -- [supervisor-options]",
+    "Dynamic-loop options must appear before --; supervisor --out-dir is owned by the dynamic loop.",
     "Reads tester preflight balance summaries, chooses a fundable tester scenario, then runs bounded supervisor-loop chunks.",
   ].join("\n");
 }
@@ -200,6 +224,21 @@ export async function runDynamicSupervisorLoop({ argv, root = rootDir, dependenc
     return 0;
   }
 
+  if (hasHelpFlag(args.supervisorArgs)) {
+    const result = runNode([
+      isAbsolute(args.supervisorLoopScript) ? args.supervisorLoopScript : resolve(root, args.supervisorLoopScript),
+      "--",
+      ...args.supervisorArgs,
+    ], root, dependencies, { timeout: args.chunkTimeoutSeconds * 1000 });
+    if (result.stdout) {
+      stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      stderr.write(result.stderr);
+    }
+    return typeof result.status === "number" ? result.status : 1;
+  }
+
   let session;
   try {
     session = await prepareValidationSession(args, root, dependencies);
@@ -275,6 +314,9 @@ export async function runDynamicSupervisorLoop({ argv, root = rootDir, dependenc
     if (stopReason === "tx_observed" || stopReason === "new_outcome") {
       return 0;
     }
+    if (stopReason === "max_runs" || stopReason === "stable_no_progress") {
+      return INSPECTION_REQUIRED_EXIT_CODE;
+    }
 
     if ((args.maxChunks === undefined || chunkIndex < args.maxChunks) && args.betweenChunksSeconds > 0) {
       await sleepMs(args.betweenChunksSeconds * 1000, dependencies);
@@ -286,7 +328,22 @@ export async function runDynamicSupervisorLoop({ argv, root = rootDir, dependenc
 
 function supervisorLoopStopReason(stdout) {
   const reasons = [...stdout.matchAll(/^loop stopped reason=([^\s]+)/gmu)].map((match) => match[1]);
-  return reasons.at(-1);
+  return reasons.at(-1) ?? [...stdout.matchAll(/^loop run=\d+ .*\bdecision=([^\s]+)/gmu)].map((match) => match[1]).at(-1);
+}
+
+function firstMatchingFlag(args, flags) {
+  for (const arg of args) {
+    for (const flag of flags) {
+      if (arg === flag || arg.startsWith(`${flag}=`)) {
+        return flag;
+      }
+    }
+  }
+  return undefined;
+}
+
+function hasHelpFlag(args) {
+  return args.some((arg) => arg === "-h" || arg === "--help");
 }
 
 function runTesterPreflight(args, root, dependencies) {
diff --git a/scripts/ickb-supervisor-dynamic-loop.test.mjs b/scripts/ickb-supervisor-dynamic-loop.test.mjs
index 2786fc5..bf991ca 100644
--- a/scripts/ickb-supervisor-dynamic-loop.test.mjs
+++ b/scripts/ickb-supervisor-dynamic-loop.test.mjs
@@ -50,6 +50,8 @@ test("dynamic supervisor loop parses options", () => {
     "--target-outcome",
     "bot_match_committed",
   ]);
+  assert.deepEqual(parseArgs(["--", "--help"]).supervisorArgs, ["--help"]);
+  assert.deepEqual(parseArgs(["--", "-h"]).supervisorArgs, ["-h"]);
   assert.equal(parseArgs([]).childTimeoutSeconds, DEFAULT_SUPERVISOR_LOOP_CHILD_TIMEOUT_SECONDS);
   assert.equal(
     parseArgs(["--chunk-max-runs", "3", "--child-timeout-seconds", "6", "--chunk-backoff-seconds", "4"]).chunkTimeoutSeconds,
@@ -66,10 +68,38 @@ test("dynamic supervisor loop parses options", () => {
   );
   assert.throws(() => parseArgs(["--unknown"]), /Unknown argument/u);
   assert.throws(() => parseArgs(["--", "--out-dir", "log/validation/bad"]), /Do not pass supervisor --out-dir/u);
+  assert.throws(() => parseArgs(["--", "--max-chunks", "1"]), /Do not pass dynamic-loop option --max-chunks after --/u);
+  assert.throws(() => parseArgs(["--", "--stable-limit=2"]), /Do not pass dynamic-loop option --stable-limit after --/u);
+  assert.deepEqual(parseArgs(["--", "--command-timeout-seconds", "9"]).supervisorArgs, ["--command-timeout-seconds", "9"]);
   assert.match(usage(), /tester-config/u);
   assert.match(usage(), /--log-root/u);
 });
 
+test("dynamic supervisor loop passes child help through visibly", async () => {
+  for (const helpFlag of ["--help", "-h"]) {
+    const output = { text: "", write(chunk) { this.text += chunk; } };
+    const commands = [];
+    const exitCode = await runDynamicSupervisorLoop({
+      root: "/repo",
+      argv: ["--", helpFlag],
+      io: { stdout: output, stderr: output },
+      dependencies: {
+        checkIgnored: () => {
+          throw new Error("should not prepare a validation session for child help");
+        },
+        spawnSync: (_command, args) => {
+          commands.push(args);
+          return { status: 0, signal: null, stdout: `child help ${helpFlag}\n`, stderr: "" };
+        },
+      },
+    });
+
+    assert.equal(exitCode, 0);
+    assert.deepEqual(commands[0], ["/repo/scripts/ickb-supervisor-loop.mjs", "--", helpFlag]);
+    assert.equal(output.text.includes(`child help ${helpFlag}`), true);
+  }
+});
+
 test("dynamic supervisor loop creates a default validation session root", async () => {
   const originalPrivateKey = process.env.PRIVATE_KEY;
   process.env.PRIVATE_KEY = "operator-secret";
@@ -101,7 +131,7 @@ test("dynamic supervisor loop creates a default validation session root", async
       },
     });
 
-    assert.equal(exitCode, 0);
+    assert.equal(exitCode, 3);
     assert.equal(writes.has("/repo/log/validation/dynamic-1700000000-4321/operator/launch.json"), true);
     assert.equal(appended.has("/repo/log/validation/dynamic-1700000000-4321/operator/events.ndjson"), true);
     assert.deepEqual(commands[1].args.slice(0, 3), [
@@ -249,19 +279,16 @@ test("dynamic supervisor loop runs selected bounded chunks", async () => {
     },
   });
 
-  assert.equal(exitCode, 0);
+  assert.equal(exitCode, 3);
   assert.equal(sleeps.length, 0);
-  assert.equal(commands.length, 4);
+  assert.equal(commands.length, 2);
   assert.equal(commands[1].args.includes("all-ckb-limit-order"), true);
-  assert.equal(commands[3].args.includes("ickb-to-ckb-limit-order"), true);
   assert.deepEqual(commands[1].args.slice(0, 3), ["scripts/ickb-supervisor-loop.mjs", "--out-root", "log/validation/test-session/chunks/chunk-0001"]);
   const separator = commands[1].args.indexOf("--");
   assert.equal(commands[1].args.slice(0, separator).includes("--out-root"), true);
   assert.equal(commands[1].args.slice(separator + 1).includes("--target-outcome"), true);
-  assert.deepEqual(commands[3].args.slice(-4), ["--tester-fee", "1", "--tester-fee-base", "1000"]);
   assert.match(output.text, /"type":"selected"/u);
   assert.match(output.text, /testerScenario":"all-ckb-limit-order"/u);
-  assert.match(output.text, /testerScenario":"ickb-to-ckb-limit-order"/u);
 });
 
 test("dynamic supervisor loop stops after inspection-worthy supervisor-loop reasons", async () => {
@@ -298,6 +325,40 @@ test("dynamic supervisor loop stops after inspection-worthy supervisor-loop reas
   assert.match(output.text, /"supervisorLoopStopReason":"tx_observed"/u);
 });
 
+test("dynamic supervisor loop preserves supervisor-loop inspection-required status", async () => {
+  const commands = [];
+  const output = { text: "", write(chunk) { this.text += chunk; } };
+  const exitCode = await runDynamicSupervisorLoop({
+    root: "/repo",
+    argv: [
+      "--log-root", "log",
+      "--session-root", "log/validation/inspection-status-session",
+      "--max-chunks", "3",
+      "--between-chunks-seconds", "0",
+    ],
+    io: { stdout: output, stderr: output },
+    dependencies: {
+      checkIgnored: () => true,
+      stat: missingStat,
+      lstat: missingStat,
+      mkdir: async () => undefined,
+      writeFile: async () => undefined,
+      appendFile: async () => undefined,
+      spawnSync: (_command, args, options) => {
+        commands.push({ args, options });
+        if (args[0] === "scripts/ickb-live-preflight.mjs") {
+          return { status: 0, signal: null, stdout: JSON.stringify({ balances: { CKB: { available: "3200" }, ICKB: { available: "0" } } }), stderr: "" };
+        }
+        return { status: 3, signal: null, stdout: "loop run=1 status=0 stopped=max_cycles outcomes=- tx=0 new=- stable=1 state=- decision=max_runs out=log/validation/inspection-status-session/chunks/chunk-0001\nloop stopped reason=max_runs runs=1 out=log/validation/inspection-status-session/chunks/chunk-0001\n", stderr: "" };
+      },
+    },
+  });
+
+  assert.equal(exitCode, 3);
+  assert.equal(commands.length, 2);
+  assert.match(output.text, /"supervisorLoopStopReason":"max_runs"/u);
+});
+
 test("dynamic supervisor loop leaves supervisor target steering intact for auto tester choice", async () => {
   const commands = [];
   const output = { text: "", write(chunk) { this.text += chunk; } };
@@ -331,7 +392,7 @@ test("dynamic supervisor loop leaves supervisor target steering intact for auto
   const supervisorArgs = commands[1].args;
   const separator = supervisorArgs.indexOf("--");
   const passthrough = supervisorArgs.slice(separator + 1);
-  assert.equal(exitCode, 0);
+  assert.equal(exitCode, 3);
   assert.equal(passthrough.includes("--tester-scenario"), false);
   assert.equal(passthrough.includes("auto"), false);
   assert.equal(passthrough.includes("--target-outcome"), true);
@@ -371,7 +432,7 @@ test("dynamic supervisor loop leaves fresh-order skip target planning to supervi
   const supervisorArgs = commands[1].args;
   const separator = supervisorArgs.indexOf("--");
   const passthrough = supervisorArgs.slice(separator + 1);
-  assert.equal(exitCode, 0);
+  assert.equal(exitCode, 3);
   assert.equal(passthrough.includes("--scenario"), false);
   assert.equal(passthrough.includes("--tester-scenario"), true);
   assert.equal(passthrough.includes("ickb-to-ckb-limit-order"), true);
diff --git a/scripts/ickb-supervisor-loop.mjs b/scripts/ickb-supervisor-loop.mjs
index 846fa7e..a035e61 100644
--- a/scripts/ickb-supervisor-loop.mjs
+++ b/scripts/ickb-supervisor-loop.mjs
@@ -13,6 +13,8 @@ const DEFAULT_CHILD_TIMEOUT_SECONDS = 65 * 60;
 export const DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE = DEFAULT_CHILD_TIMEOUT_SECONDS;
 const DEFAULT_SUPERVISOR_SCRIPT = "apps/supervisor/dist/index.js";
 const SUPERVISOR_OUTPUT_ROOT = "logs/live-supervisor";
+export const INSPECTION_REQUIRED_EXIT_CODE = 3;
+const LOOP_OWNED_FLAGS = ["--out-root", "--max-runs", "--stable-limit", "--backoff-seconds", "--child-timeout-seconds", "--supervisor-script"];
 export function parseArgs(argv) {
   const args = {
     help: false,
@@ -59,6 +61,10 @@ export function parseArgs(argv) {
     }
     throw new Error(`Unknown argument before --: ${arg}`);
   }
+  const misplacedLoopFlag = firstMatchingFlag(args.supervisorArgs, LOOP_OWNED_FLAGS);
+  if (misplacedLoopFlag !== undefined) {
+    throw new Error(`Do not pass loop option ${misplacedLoopFlag} after --; put loop options before --`);
+  }
   if (args.supervisorArgs.some((arg) => arg === "--out-dir" || arg.startsWith("--out-dir="))) {
     throw new Error("Do not pass supervisor --out-dir; use loop --out-root instead");
   }
@@ -77,7 +83,7 @@ export function usage() {
     `  --supervisor-script <path>     Default: ${DEFAULT_SUPERVISOR_SCRIPT}`,
     "  -h, --help",
     "Reads only each child run summary.json.",
-    "Supervisor --out-dir is owned by the loop and must not be passed after --.",
+    "Loop options must appear before --; supervisor --out-dir is owned by the loop.",
   ].join("\n");
 }
 
@@ -119,10 +125,10 @@ export function decideNext({ run, priorOutcomes, previousSignature, stableCount,
     return { action: "stop", reason: "new_outcome", newOutcomes, stableCount: nextStableCount, exitCode: 0 };
   }
   if (runIndex >= maxRuns) {
-    return { action: "stop", reason: "max_runs", newOutcomes, stableCount: nextStableCount, exitCode: 0 };
+    return { action: "stop", reason: "max_runs", newOutcomes, stableCount: nextStableCount, exitCode: INSPECTION_REQUIRED_EXIT_CODE };
   }
   if (nextStableCount >= stableLimit) {
-    return { action: "stop", reason: "stable_no_progress", newOutcomes, stableCount: nextStableCount, exitCode: 0 };
+    return { action: "stop", reason: "stable_no_progress", newOutcomes, stableCount: nextStableCount, exitCode: INSPECTION_REQUIRED_EXIT_CODE };
   }
   return { action: "continue", reason: "continue", newOutcomes, stableCount: nextStableCount, exitCode: 0 };
 }
@@ -155,6 +161,25 @@ export async function runSupervisorLoop({ argv, root = rootDir, dependencies = {
     return 0;
   }
 
+  if (hasHelpFlag(args.supervisorArgs)) {
+    const supervisorScript = isAbsolute(args.supervisorScript)
+      ? args.supervisorScript
+      : resolve(root, args.supervisorScript);
+    const spawnResult = spawnSupervisorHelp({
+      root,
+      supervisorScript,
+      supervisorArgs: args.supervisorArgs,
+      dependencies,
+    });
+    if (spawnResult.stdout) {
+      stdout.write(spawnResult.stdout);
+    }
+    if (spawnResult.stderr) {
+      stderr.write(spawnResult.stderr);
+    }
+    return typeof spawnResult.status === "number" ? spawnResult.status : 1;
+  }
+
   const now = dependencies.now ?? Date.now;
   let outRoot;
   let supervisorScript;
@@ -238,6 +263,34 @@ function spawnSupervisor({ root, supervisorScript, supervisorArgs, relativeOutDi
   });
 }
 
+function spawnSupervisorHelp({ root, supervisorScript, supervisorArgs, dependencies }) {
+  const spawnSyncFn = dependencies.spawnSync ?? spawnSync;
+  return spawnSyncFn(process.execPath, [
+    supervisorScript,
+    ...supervisorArgs,
+  ], {
+    cwd: root,
+    encoding: "utf8",
+    env: minimalProcessEnv(process.env),
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function hasHelpFlag(args) {
+  return args.some((arg) => arg === "-h" || arg === "--help");
+}
+
+function firstMatchingFlag(args, flags) {
+  for (const arg of args) {
+    for (const flag of flags) {
+      if (arg === flag || arg.startsWith(`${flag}=`)) {
+        return flag;
+      }
+    }
+  }
+  return undefined;
+}
+
 async function readSummary(path, dependencies) {
   const readFileFn = dependencies.readFile ?? readFile;
   const text = await readFileFn(path, "utf8");
diff --git a/scripts/ickb-supervisor-loop.test.mjs b/scripts/ickb-supervisor-loop.test.mjs
index 4de89bf..a950308 100644
--- a/scripts/ickb-supervisor-loop.test.mjs
+++ b/scripts/ickb-supervisor-loop.test.mjs
@@ -4,6 +4,7 @@ import test from "node:test";
 import {
   decideNext,
   DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE,
+  INSPECTION_REQUIRED_EXIT_CODE,
   parseArgs,
   runSupervisorLoop,
   summarizeRun,
@@ -13,6 +14,7 @@ import {
 
 test("supervisor loop parses loop options and supervisor passthrough", () => {
   assert.deepEqual(parseArgs(["--", "--help"]).supervisorArgs, ["--help"]);
+  assert.deepEqual(parseArgs(["--", "-h"]).supervisorArgs, ["-h"]);
   assert.deepEqual(parseArgs([
     "--out-root", "logs/live-supervisor/loop-test",
     "--max-runs", "5",
@@ -45,12 +47,42 @@ test("supervisor loop parses loop options and supervisor passthrough", () => {
   assert.throws(() => parseArgs(["--child-timeout-seconds", "0"]), /Invalid --child-timeout-seconds/u);
   assert.throws(() => parseArgs(["--", "--out-dir", "logs/live-supervisor/x"]), /Do not pass supervisor --out-dir/u);
   assert.throws(() => parseArgs(["--", "--out-dir=logs/live-supervisor/x"]), /Do not pass supervisor --out-dir/u);
+  assert.throws(() => parseArgs(["--", "--max-runs", "1", "--scenario", "standard-cycle"]), /Do not pass loop option --max-runs after --/u);
+  assert.throws(() => parseArgs(["--", "--stable-limit=2"]), /Do not pass loop option --stable-limit after --/u);
   assert.throws(() => parseArgs(["--scenario", "standard-cycle", "--out-dir=logs/live-supervisor/x"]), /Unknown argument before --: --scenario/u);
   assert.equal(parseArgs([]).childTimeoutSeconds, DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE);
   assert.match(usage(), /summary/u);
   assert.match(usage(), /--out-root <dir>/u);
 });
 
+test("supervisor loop passes child help through visibly", async () => {
+  for (const helpFlag of ["--help", "-h"]) {
+    const output = { text: "", write(chunk) { this.text += chunk; } };
+    const commands = [];
+    const exitCode = await runSupervisorLoop({
+      argv: ["--", helpFlag],
+      root: "/repo",
+      io: { stdout: output, stderr: output },
+      dependencies: {
+        spawnSync: (_command, args, options) => {
+          commands.push({ args, options });
+          return { status: 0, stdout: `child help ${helpFlag}\n`, stderr: "child warning\n" };
+        },
+        readFile: async () => {
+          throw new Error("should not read summary for child help");
+        },
+      },
+    });
+
+    assert.equal(exitCode, 0);
+    assert.deepEqual(commands[0].args, ["/repo/apps/supervisor/dist/index.js", helpFlag]);
+    assert.deepEqual(commands[0].options.stdio, ["ignore", "pipe", "pipe"]);
+    assert.equal(commands[0].options.encoding, "utf8");
+    assert.equal(output.text.includes(`child help ${helpFlag}`), true);
+    assert.equal(output.text.includes("child warning"), true);
+  }
+});
+
 test("supervisor loop summary signatures sort skip reasons", () => {
   const base = {
     stopped: "max_cycles",
@@ -185,7 +217,7 @@ test("supervisor loop decisions stop on incident, tx, new outcome, max runs, and
     runIndex: 2,
     maxRuns: 10,
   }).reason, "new_outcome");
-  assert.equal(decideNext({
+  const stableDecision = decideNext({
     run: baseRun,
     priorOutcomes,
     previousSignature: "same",
@@ -193,8 +225,10 @@ test("supervisor loop decisions stop on incident, tx, new outcome, max runs, and
     stableLimit: 3,
     runIndex: 3,
     maxRuns: 10,
-  }).reason, "stable_no_progress");
-  assert.equal(decideNext({
+  });
+  assert.equal(stableDecision.reason, "stable_no_progress");
+  assert.equal(stableDecision.exitCode, INSPECTION_REQUIRED_EXIT_CODE);
+  const maxRunsDecision = decideNext({
     run: baseRun,
     priorOutcomes,
     previousSignature: "same",
@@ -202,7 +236,9 @@ test("supervisor loop decisions stop on incident, tx, new outcome, max runs, and
     stableLimit: 3,
     runIndex: 3,
     maxRuns: 3,
-  }).reason, "max_runs");
+  });
+  assert.equal(maxRunsDecision.reason, "max_runs");
+  assert.equal(maxRunsDecision.exitCode, INSPECTION_REQUIRED_EXIT_CODE);
 });
 
 test("supervisor loop runs bounded supervisor commands until stable", async () => {
@@ -244,7 +280,7 @@ test("supervisor loop runs bounded supervisor commands until stable", async () =
       },
     });
 
-    assert.equal(exitCode, 0);
+    assert.equal(exitCode, INSPECTION_REQUIRED_EXIT_CODE);
     assert.equal(commands.length, 2);
     assert.deepEqual(commands[0].args.slice(-4), ["--scenario", "bot-only", "--out-dir", "logs/live-supervisor/loop-test/run-0001"]);
     assert.equal(commands[0].options.timeout, DEFAULT_CHILD_TIMEOUT_SECONDS_VALUE * 1000);
@@ -293,7 +329,7 @@ test("supervisor loop accepts validation session out roots", async () => {
     },
   });
 
-  assert.equal(exitCode, 0);
+  assert.equal(exitCode, INSPECTION_REQUIRED_EXIT_CODE);
   assert.deepEqual(commands[0].args.slice(-4), ["--scenario", "bot-only", "--out-dir", "log/validation/dynamic-test/chunks/chunk-0001/run-0001"]);
   assert.match(output.text, /out=log\/validation\/dynamic-test\/chunks\/chunk-0001/u);
 });
@@ -354,7 +390,7 @@ test("supervisor loop accepts explicit validation roots outside the repo", async
     },
   });
 
-  assert.equal(exitCode, 0);
+  assert.equal(exitCode, INSPECTION_REQUIRED_EXIT_CODE);
   assert.deepEqual(commands[0].args.slice(-4), ["--scenario", "bot-only", "--out-dir", "/var/tmp/ickb-log/validation/dynamic-test/chunks/chunk-0001/run-0001"]);
   assert.match(output.text, /out=\/var\/tmp\/ickb-log\/validation\/dynamic-test\/chunks\/chunk-0001/u);
 });