tickmarkr 2.5.2 → 2.5.3

package/dist/adapters/qwen.d.ts

@@ -1,5 +1,6 @@
 import { type ClassifiedWorkerResult } from "./prompt.js";
 import { type WorkerAdapter } from "./types.js";
 export declare const QWEN_VERSION_IDENTITY: RegExp;
+export declare const QWEN_HARNESS_BANNER_ROWS: readonly ["⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice."];
 export declare function parseQwenResult(raw: string, nonce: string): ClassifiedWorkerResult;
 export declare const qwen: WorkerAdapter;

package/dist/adapters/qwen.js

@@ -3,6 +3,13 @@ import { parseWorkerResult } from "./prompt.js";
 import { channelsFromConfig, shq, } from "./types.js";
 export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
 const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
+// Verbatim stderr from tests/fixtures/qwen/safe-mode.stderr (qwen 0.21.15). These bytes are launch
+// harness, not evidence that a reviewer took a turn. Keep the declaration closed and row-shaped so
+// llm.ts can sweep partial terminal paints without a broad SAFE MODE/warning regex.
+export const QWEN_HARNESS_BANNER_ROWS = [
+    "⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.",
+    "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.",
+];
 function decodeQwenEvents(events) {
     const text = [];
     let failed = false;
@@ -136,6 +143,7 @@ export const qwen = {
     channels: (cfg) => channelsFromConfig("qwen", cfg),
     hardcodedFlags: { binary: "qwen", flags: ["--safe-mode", "--approval-mode", "-m", "-o", "-p"] },
     headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --safe-mode --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    harnessBannerRows: QWEN_HARNESS_BANNER_ROWS,
     // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
     // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
     // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.

package/dist/adapters/types.d.ts

@@ -171,6 +171,7 @@ export interface WorkerAdapter {
     probe(): Promise<AuthHealth>;
     channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;
+    harnessBannerRows?: readonly string[];
     interactiveCommand(promptFile: string, model: string): string | null;
     interactiveSeed?: InteractiveSeed;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;

package/dist/cli/commands/doctor.d.ts

@@ -8,6 +8,12 @@ import { type VitestListResult } from "../../gates/acceptance.js";
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export declare const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
 export declare const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
+type ReviewDemotionSummary = {
+    reviewer: string;
+    count: number;
+    causes: Record<string, number>;
+};
+export declare function recentReviewDemotions(cwd: string, lastRuns?: number): ReviewDemotionSummary[];
 export type DoctorOpts = {
     banner?: boolean;
     kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;

package/dist/cli/commands/doctor.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { detectPackageManager, turboContinueFindings } from "../../gates/baseline.js";
 import { version } from "./version.js";
@@ -26,6 +26,46 @@ const initialFetch = globalThis.fetch;
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
+// Use the routing profile's established 50-run recency horizon without importing journal machinery
+// into doctor. Torn/malformed rows are ignored one at a time: diagnostics must survive a killed write.
+export function recentReviewDemotions(cwd, lastRuns = 50) {
+    const runs = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runs))
+        return [];
+    const grouped = new Map();
+    const ids = readdirSync(runs, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")
+        && existsSync(join(runs, entry.name, "journal.jsonl")))
+        .map((entry) => entry.name).sort().slice(-lastRuns);
+    for (const id of ids) {
+        const lines = readFileSync(join(runs, id, "journal.jsonl"), "utf8").split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!row || typeof row !== "object")
+                continue;
+            const event = row;
+            if (event.event !== "review-pool-demotion" || !event.data || typeof event.data !== "object")
+                continue;
+            const data = event.data;
+            if (typeof data.reviewer !== "string" || !data.reviewer.trim())
+                continue;
+            const cause = typeof data.cause === "string" && data.cause.trim() ? data.cause : "unknown";
+            const summary = grouped.get(data.reviewer) ?? { reviewer: data.reviewer, count: 0, causes: {} };
+            summary.count++;
+            summary.causes[cause] = (summary.causes[cause] ?? 0) + 1;
+            grouped.set(data.reviewer, summary);
+        }
+    }
+    return [...grouped.values()].sort((a, b) => a.reviewer.localeCompare(b.reviewer));
+}
 const ORCA_HOOK_ADAPTERS = {
     claude: "claude-code",
     "claude-code": "claude-code",
@@ -581,6 +621,15 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const healthy = h.installed && (a.id !== kimi.id || h.authed);
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
+    const reviewDemotions = recentReviewDemotions(cwd);
+    if (reviewDemotions.length) {
+        rows.push(legend("recent review-seat demotions:"));
+        for (const demotion of reviewDemotions) {
+            const causes = Object.entries(demotion.causes)
+                .map(([cause, count]) => `${cause}${count === demotion.count ? "" : ` ×${count}`}`).join(", ");
+            rows.push(alignedStatusRow("warn", demotion.reviewer, `${demotion.count} review seat${demotion.count === 1 ? "" : "s"} demoted · cause ${causes}`));
+        }
+    }
     if (existsSync(graphPath(cwd))) {
         try {
             const graph = loadGraph(cwd);

package/dist/cli/commands/run.js

@@ -35,6 +35,7 @@ const RAIL_TONES = {
 };
 /** Approval-close lifecycle labels extend the established closed rail vocabulary. */
 export const APPROVAL_RAIL_ROWS = {
+    "end-condition-held": { label: "close held", tone: "attention" },
     "approval-window-start": { label: "approval window", tone: "attention" },
     "approval-window-expired": { label: "approval window expired", tone: "attention" },
     "tip-verify-cancelled": { label: "tip verify cancelled", tone: "attention" },
@@ -124,6 +125,7 @@ export const RAIL_ROWS = {
     "gate-result": { label: "gate", tone: "pass" },
     "baseline-wait": { label: "baseline wait", tone: "active" },
     "suite-budget": { label: "suite budget", tone: "attention" },
+    "gate-replayed": { label: "gate replayed", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
     "judge-retry": { label: "judge retry", tone: "attention" },
     "review-no-verdict": { label: "review unavailable", tone: "attention" },

package/dist/cli/commands/status.js

@@ -825,23 +825,17 @@ const liveness = (events, daemon, now = Date.now()) => {
     const state = daemon.state === "alive" ? "alive" : ended ? "finished" : "dead";
     return `last event ${age} ago · daemon pid ${daemon.pid} ${state}${cause ? ` · ${cause}` : ""}`;
 };
-// Resume's shared comparator remains the fail-closed baseline. Status may additionally accept the
-// daemon's audited graph-rehash release, but only when its `from` names that baseline identity (or
-// null for an explicitly released legacy journal) and its `to` names the graph loaded now.
+// OBS-978: the one comparator resume, plan and the operator fold read decides the join — it already
+// audits the rehash chain. When it binds and the journal holds a graph-rehash, the newest row is the
+// audit that bound the loaded graph; rehashAt marks the facts recorded against a prior graph.
 const statusEngagement = (events, loadedHash) => {
-    const baseline = engagementComparable(events, loadedHash);
+    if (!engagementComparable(events, loadedHash).comparable)
+        return { comparable: false };
     for (let i = events.length - 1; i >= 0; i--) {
-        const event = events[i];
-        if (event.event !== "graph-rehash")
-            continue;
-        const auditsBaseline = baseline.comparable || baseline.reason === "mismatch"
-            ? event.data.from === baseline.recorded
-            : event.data.from === null;
-        return event.data.to === loadedHash && auditsBaseline
-            ? { comparable: true, rehashAt: i }
-            : { comparable: false };
+        if (events[i].event === "graph-rehash")
+            return { comparable: true, rehashAt: i };
     }
-    return { comparable: baseline.comparable };
+    return { comparable: true };
 };
 // The journal's own reader rule (src/run/journal.ts readJsonl), applied to bytes already in hand:
 // skip blanks, drop a line that will not parse (a torn trailing write after a crash), keep the rest.

package/dist/compile/ownership.d.ts

@@ -13,6 +13,12 @@ export type OwnershipFinding = {
     taskIds: string[];
     corroboration?: OwnershipCorroboration;
     detail: string;
+} | {
+    code: "unowned-shape-oracle";
+    taskId: string;
+    source: string;
+    oracle: string;
+    detail: string;
 } | {
     code: "test-path-outside-allowlist";
     taskId: string;
@@ -26,6 +32,9 @@ export type OwnershipFinding = {
     path: string;
     detail: string;
 };
+export declare const SHAPE_ORACLES: readonly ["tests/run/narration.test.ts", "tests/cli/brand-surfaces.test.ts", "tests/run/notify-identity.test.ts", "tests/run/outcome-projections.test.ts", "tests/cockpit/setup.test.ts"];
+export declare const SHAPE_ORACLE_SOURCES: readonly ["src/run/daemon.ts", "src/cli/commands/run.ts"];
+export declare const SHAPE_ORACLE_MAP: Record<string, readonly string[]>;
 /**
  * Cross-task ownership evidence. Findings are data: this checker never throws or changes the graph;
  * the compile seam promotes only a corroborated unowned-test finding and reports every other shape.

package/dist/compile/ownership.js

@@ -2,6 +2,38 @@ import { readFileSync, readdirSync } from "node:fs";
 import { basename, extname, join, posix } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { collateralHits } from "./collateral.js";
+export const SHAPE_ORACLES = [
+    "tests/run/narration.test.ts",
+    "tests/cli/brand-surfaces.test.ts",
+    "tests/run/notify-identity.test.ts",
+    "tests/run/outcome-projections.test.ts",
+    "tests/cockpit/setup.test.ts",
+];
+export const SHAPE_ORACLE_SOURCES = [
+    "src/run/daemon.ts",
+    "src/cli/commands/run.ts",
+];
+export const SHAPE_ORACLE_MAP = {
+    "src/run/daemon.ts": SHAPE_ORACLES,
+    "src/cli/commands/run.ts": SHAPE_ORACLES,
+};
+// Anchored-glob only: a files[] entry touches a mapped source when it names the source (or its
+// extensionless stem) exactly, or when its glob's literal head — everything before the first
+// wildcard — is the stem plus a literal dot, i.e. the wildcard only ever spans the extension
+// ("src/run/daemon.*"). A broad multi-file glob like "src/**" that merely happens to cover the
+// source is an unrelated task casting a wide net, not one touching daemon narration — that
+// distinction is what broke every fixture using tests/fixtures/sample.prd.md's files: src/** task.
+function touchesSource(files, source) {
+    const stem = source.replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    return files.some((entry) => {
+        if (entry === source || entry === stem)
+            return true;
+        const special = entry.search(/[*?{[]/);
+        // Leg-2 v2.5.3: the anchored head is necessary, not sufficient — the pattern must also MATCH the
+        // source under the shared matcher, or "src/run/daemon.{js,jsx}" (never daemon.ts) would count as a touch.
+        return special !== -1 && entry.slice(0, special) === `${stem}.` && filesGlob([entry])(source);
+    });
+}
 const normalize = (path) => path.replace(/^\.\//, "").split("\\").join("/");
 function testSources(repoRoot) {
     const root = join(repoRoot, "tests");
@@ -155,6 +187,7 @@ export function ownershipFindings(tasks, repoRoot) {
         const context = task.context.map(normalize);
         return {
             task,
+            files,
             owns: files.length === 0 ? () => false : filesGlob(files),
             allows: files.length === 0 ? () => true : filesGlob([...files, ...context]),
         };
@@ -204,6 +237,23 @@ export function ownershipFindings(tasks, repoRoot) {
             });
         }
     }
+    for (const entry of indexed) {
+        for (const [source, oracles] of Object.entries(SHAPE_ORACLE_MAP)) {
+            if (!touchesSource(entry.files, source))
+                continue;
+            for (const oracle of oracles) {
+                if (!entry.owns(oracle)) {
+                    findings.push({
+                        code: "unowned-shape-oracle",
+                        taskId: entry.task.id,
+                        source,
+                        oracle,
+                        detail: `${entry.task.id} touches ${source} without owning shape oracle ${oracle}`,
+                    });
+                }
+            }
+        }
+    }
     for (const source of sources) {
         for (const owner of owners(source.path)) {
             for (const path of repositoryPaths(source.text)) {
@@ -234,11 +284,24 @@ export function ownershipFindings(tasks, repoRoot) {
             }
         }
     }
-    return findings.sort((a, b) => `${a.code}:${"test" in a ? a.test : a.path}:${"taskId" in a ? a.taskId : ""}`.localeCompare(`${b.code}:${"test" in b ? b.test : b.path}:${"taskId" in b ? b.taskId : ""}`));
+    const target = (f) => {
+        switch (f.code) {
+            case "unowned-test": return f.test;
+            case "unowned-shape-oracle": return f.oracle;
+            case "test-path-outside-allowlist": return f.test;
+            case "unordered-context-write": return f.path;
+        }
+    };
+    return findings.sort((a, b) => {
+        const taskA = "taskId" in a ? a.taskId : "";
+        const taskB = "taskId" in b ? b.taskId : "";
+        return `${a.code}:${target(a)}:${taskA}`.localeCompare(`${b.code}:${target(b)}:${taskB}`);
+    });
 }
 export function renderOwnershipFinding(finding) {
     return `tickmarkr: ownership-lint[${finding.code}]: ${finding.detail}`;
 }
 export function blocksCompile(finding) {
-    return finding.code === "unowned-test" && finding.corroboration !== undefined;
+    return (finding.code === "unowned-test" && finding.corroboration !== undefined)
+        || finding.code === "unowned-shape-oracle";
 }

package/dist/gates/baseline.d.ts

@@ -161,6 +161,7 @@ export declare function detectVacuousOracles(cwd: string, tasks: ReadonlyArray<{
 export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: {
     rerunOf?: HostStarvedRerun;
     infraRerun?: HostStarvedRerun;
+    selected?: readonly string[];
 }): Promise<GateResult[]>;
 export interface HostStarvedRerun {
     durationMs: number;
@@ -184,7 +185,10 @@ export declare function resetCalmWindowForTests(): void;
 export declare function waitForCalmWindow(): Promise<number>;
 /** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */
 export declare function runnerFileCount(raw: string): number | null;
-export declare function fileCountDeficit(entry: BaselineCommand | undefined, raw: string): string | undefined;
+export declare function fileCountDeficit(entry: BaselineCommand | undefined, raw: string, opts?: {
+    name?: string;
+    selected?: readonly string[];
+}): string | undefined;
 /** Both readers classify fresh evidence first, retaining the whole-output guard against infra forgiveness. */
 export declare function classifyFreshRunnerOutput(entry: BaselineCommand | undefined, raw: string, code: number): FailureClassification | undefined;
 export {};

package/dist/gates/baseline.js

@@ -627,7 +627,16 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
                 details: `${g.meta?.classification === "infra" ? "infra; " : ""}runner-infra rerun after waiting ${opts.infraRerun.waitedMs}ms for a calm load window: ${withRerun.details.replace(/^infra; /, "")}`,
                 meta: { ...withRerun.meta, runnerInfraRerun: opts.infraRerun },
             } : withRerun;
-            results.push(r.capacity ? { ...final, capacity: r.capacity } : final);
+            const withSelected = name === "test" && opts.selected
+                ? {
+                    ...final,
+                    meta: {
+                        ...final.meta,
+                        ...(Array.isArray(opts.selected) ? { selectedTests: [...opts.selected] } : {}),
+                    },
+                }
+                : final;
+            results.push(r.capacity ? { ...withSelected, capacity: r.capacity } : withSelected);
         };
         // …and whether the entry that would forgive this command was measured in the same world. A
         // baseline captured under a different fork cap forgives nothing: its fingerprints describe a
@@ -657,7 +666,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             continue;
         }
         const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
-        const deficit = fileCountDeficit(entry, raw);
+        const deficit = fileCountDeficit(entry, raw, { name, selected: opts.selected });
         if (deficit) {
             record({ gate: name, pass: false, details: deficit, meta: { classification: "infra", infra: true } });
             continue;
@@ -689,7 +698,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         if (name === "test" && classification === "infra" && !rerunOf && !opts.infraRerun) {
             const waitedMs = await waitForCalmWindow();
             const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { infraRerun: provenance }));
+            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance }));
             continue;
         }
         // OBS-896: every fresh failure must be timeout-class, and the suite must take at least twice its
@@ -698,7 +707,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             && hostStarved(failing.join("\n"), r.durationMs ?? 0, entry?.durationMs)) {
             const waitedMs = await waitForCalmWindow();
             const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { rerunOf: provenance }));
+            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance }));
             continue;
         }
         if (classification === "infra") {
@@ -833,7 +842,11 @@ export function runnerFileCount(raw) {
     });
     return counts.length ? counts.reduce((sum, count) => sum + count, 0) : null;
 }
-export function fileCountDeficit(entry, raw) {
+export function fileCountDeficit(entry, raw, opts) {
+    // OBS-985: only a real, named selected-test run of the TEST gate is exempt — a truthy flag or an
+    // empty list named no selection and let a full-suite call opt itself out of the deficit guard.
+    if (opts?.name === "test" && opts.selected !== undefined && opts.selected.length > 0)
+        return undefined;
     const actual = runnerFileCount(raw);
     return entry?.fileCount != null && actual !== null && actual < entry.fileCount
         ? `infra; runner reported ${actual} test files, below baseline ${entry.fileCount} — suite incomplete`

package/dist/gates/llm.d.ts

@@ -65,7 +65,7 @@ export interface LlmRunResult {
     seatAuthoredBytes?: number;
 }
 export declare const PROMPT_GLYPHS: readonly ["➜", "❯", "$", "%", ">>", ">"];
-export declare function reviewSeatOutput(raw: string, nonce: string): string;
+export declare function reviewSeatOutput(raw: string, nonce: string, adapterBannerRows?: readonly string[]): string;
 export declare const REVIEW_FIRST_LIVENESS_MS = 30000;
 export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
 export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;

package/dist/gates/llm.js

@@ -204,12 +204,14 @@ const IDENTITY_OPENERS = ["review ·", "tickmarkr"];
 // Stages of the preamble walk. Each complete harness row is accepted only at or after its stage.
 const ECHO = 0, START = 1, BANNER = 2, IDENTITY = 3, SEAT = 4;
 // The char offset where the seat's own text begins, or -1 when the capture ends inside the preamble.
-function seatStart(output) {
+function seatStart(output, adapterBannerRows) {
     const rows = output.split("\n");
     if (rows.length > 1 && rows[rows.length - 1] === "")
         rows.pop(); // the read's own line terminator
     let stage = ECHO;
     let bannerAt; // next banner row expected once the banner has begun
+    let adapterBannerAt;
+    let identitySeen = false;
     let offset = 0;
     for (let i = 0; i < rows.length; i++) {
         const row = rows[i].replace(/[ \t]+$/, "");
@@ -217,7 +219,7 @@ function seatStart(output) {
         const last = i === rows.length - 1;
         // Complete harness rows: equality against the shape the preamble allows at this stage.
         let accepted = false;
-        if (stage < SEAT && t.length === 0)
+        if (!identitySeen && stage < SEAT && t.length === 0)
             accepted = true; // blank rows between preamble rows
         else if (stage <= ECHO && completeEchoRow(row))
             accepted = true;
@@ -225,17 +227,27 @@ function seatStart(output) {
             stage = BANNER;
             accepted = true;
         }
-        else if (stage <= BANNER && bannerAt === undefined && BANNER_ROWS.includes(row)) {
+        else if (!identitySeen && stage <= BANNER && bannerAt === undefined && BANNER_ROWS.includes(row)) {
             stage = BANNER;
             bannerAt = BANNER_ROWS.indexOf(row) + 1;
             accepted = true;
         }
-        else if (stage <= BANNER && bannerAt !== undefined && row === BANNER_ROWS[bannerAt]) {
+        else if (!identitySeen && stage <= BANNER && bannerAt !== undefined && row === BANNER_ROWS[bannerAt]) {
             bannerAt++;
             accepted = true;
         }
-        else if (stage <= IDENTITY && IDENTITY_LINE.test(t)) {
-            stage = SEAT;
+        else if (stage <= IDENTITY && adapterBannerAt === undefined && adapterBannerRows.includes(row)) {
+            stage = BANNER;
+            adapterBannerAt = adapterBannerRows.indexOf(row) + 1;
+            accepted = true;
+        }
+        else if (stage <= IDENTITY && adapterBannerAt !== undefined && row === adapterBannerRows[adapterBannerAt]) {
+            adapterBannerAt++;
+            accepted = true;
+        }
+        else if (!identitySeen && stage <= IDENTITY && IDENTITY_LINE.test(t)) {
+            stage = IDENTITY;
+            identitySeen = true;
             accepted = true;
         }
         if (accepted) {
@@ -253,9 +265,16 @@ function seatStart(output) {
             ? BANNER_ROWS.some((b) => b.startsWith(row))
             : BANNER_ROWS[bannerAt]?.startsWith(row) === true))
             return -1;
+        if (stage <= IDENTITY && (adapterBannerAt === undefined
+            ? adapterBannerRows.some((b) => b.startsWith(row))
+            : adapterBannerRows[adapterBannerAt]?.startsWith(row) === true))
+            return -1;
         // The identity row is painted right after the banner, so its prefix is a partial paint only there;
         // with no banner in the capture, "review" or "tick" alone is the seat's own first row.
-        if (stage <= IDENTITY && bannerAt === BANNER_ROWS.length && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
+        if (!identitySeen && stage <= IDENTITY
+            && (bannerAt === BANNER_ROWS.length
+                || (adapterBannerRows.length > 0 && adapterBannerAt === adapterBannerRows.length))
+            && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
             return -1;
         return offset;
     }
@@ -266,9 +285,9 @@ function seatStart(output) {
 // Every capture taken before the preamble finishes therefore measures ZERO seat-authored bytes,
 // which is what makes the caller's running Math.max safe: a partial banner counted once would be
 // retained for the whole call and buy a silent seat its full ceiling.
-export function reviewSeatOutput(raw, nonce) {
+export function reviewSeatOutput(raw, nonce, adapterBannerRows = []) {
     const output = stripVTControlCharacters(raw).replace(/\r\n?/g, "\n");
-    const start = seatStart(output);
+    const start = seatStart(output, adapterBannerRows);
     if (start < 0)
         return "";
     const seat = output.slice(start);
@@ -287,7 +306,10 @@ async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 3000
         const pf = join(dir, "prompt.md");
         writeFileSync(pf, prompt);
         const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
-        return { output: r.stdout + "\n" + r.stderr, exitCode: r.code, timedOut: r.timedOut === true, seatAuthoredBytes: Buffer.byteLength((r.stdout + r.stderr).trim()) };
+        const output = r.stdout + "\n" + r.stderr;
+        const nonce = extractPromptNonce(prompt) ?? "";
+        return { output, exitCode: r.code, timedOut: r.timedOut === true,
+            seatAuthoredBytes: Buffer.byteLength(reviewSeatOutput(output, nonce, adapter.harnessBannerRows).trim()) };
     }
     finally {
         rmSync(dir, { recursive: true, force: true });
@@ -349,7 +371,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
             const startedAt = Date.now();
             out = await via.driver.read(slot, 400);
             const reviewing = prompt.startsWith("TICKMARKR-REVIEW");
-            seatAuthoredBytes = Buffer.byteLength(reviewSeatOutput(out, nonce));
+            seatAuthoredBytes = Buffer.byteLength(reviewSeatOutput(out, nonce, adapter.harnessBannerRows));
             let firstLivenessObserved = false;
             let priorSnapshot = normalizeStallSnapshot(out);
             const anchoredAt = Date.now();
@@ -365,7 +387,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 const matched = await via.driver.waitOutput(slot, exitPattern, sliceMs, { regex: true });
                 const raw = await via.driver.read(slot, 400);
                 out = raw;
-                seatAuthoredBytes = Math.max(seatAuthoredBytes, Buffer.byteLength(reviewSeatOutput(raw, nonce)));
+                seatAuthoredBytes = Math.max(seatAuthoredBytes, Buffer.byteLength(reviewSeatOutput(raw, nonce, adapter.harnessBannerRows)));
                 // waitOutput is the driver's authoritative marker match. The raw check covers drivers whose
                 // wait timed out at the same boundary the marker landed; either way a trailer completes
                 // normally and is never mistaken for inactivity.

package/dist/gates/review.d.ts

@@ -53,6 +53,17 @@ export declare function isDiffCapPark(result: GateResult): boolean;
 export declare function diffCapParkReason(results: GateResult[]): string | null;
 export declare function modelId(model: string): string;
 export { modelProvider };
+/**
+ * One function decides whether a reviewer's `resolved` or `reraised` id names a carried fingerprint,
+ * comparing both sides with every whitespace run removed (`s.replace(/\s+/g, "")`).
+ */
+export declare function matchClosureId(candidate: unknown, fingerprint: string): boolean;
+export declare function matchClosureId(candidate: unknown, fingerprints: Iterable<string>): string | undefined;
+/**
+ * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
+ * all route through matchClosureId.
+ */
+export declare function isReviewClosureInvalid(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly string[]): boolean;
 export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[], // v1.1 failover: reviewer channels that already produced garbage for this task
 prefer?: string[], // v1.53 T2: review.prefer — reorders eligible channels, never changes eligibility
 floor?: Tier, // task-declared only; config floors govern workers and must not silently move review seats

package/dist/gates/review.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { channelKey, shq } from "../adapters/types.js";
 import { criticalPathHits, DEFAULT_DIFF_CAP, DEFAULT_REVIEW_CRITICAL_PATHS, declaredReviewPolicy, isReviewLeafPath, raiseReviewPolicy, REVIEW_VERSION_MIRRORS, TIER_RANK, } from "../config/config.js";
@@ -168,6 +168,31 @@ export function modelId(model) {
     return model.slice(model.lastIndexOf("/") + 1);
 }
 export { modelProvider };
+export function matchClosureId(candidate, target) {
+    if (typeof candidate !== "string")
+        return typeof target === "string" ? false : undefined;
+    const normCandidate = candidate.replace(/\s+/g, "");
+    if (typeof target === "string") {
+        return normCandidate === target.replace(/\s+/g, "");
+    }
+    for (const fp of target) {
+        if (typeof fp === "string" && normCandidate === fp.replace(/\s+/g, ""))
+            return fp;
+    }
+    return undefined;
+}
+/**
+ * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
+ * all route through matchClosureId.
+ */
+export function isReviewClosureInvalid(v, priorIds) {
+    const priors = priorIds instanceof Set ? priorIds : new Set(priorIds);
+    const closureLists = [v?.resolved, v?.reraised];
+    const allCandidateIds = [...(v?.resolved ?? []), ...(v?.reraised ?? [])];
+    return !!v && (priors.size > 0 || closureLists.some((list) => list !== undefined)) && (closureLists.some((list) => !Array.isArray(list) || list.some((id) => !matchClosureId(id, priors)))
+        || new Set(allCandidateIds.map((id) => matchClosureId(id, priors) ?? id)).size !== allCandidateIds.length
+        || [...priors].some((id) => !allCandidateIds.some((candidate) => matchClosureId(candidate, id))));
+}
 // v1.53 T2: same entry grammar as routing.map.prefer (router.ts preferIndex — router is out of this
 // module's dependency direction for a private fn, so the 3 lines live here too): `adapter` matches
 // every channel of that adapter, `adapter:model` exactly one; unmatched channels sort after all entries.
@@ -357,7 +382,19 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // make two otherwise-identical runs diverge in their journal bytes. The reviewer channel already
     // disambiguates every call that matters: a retry always excludes the flaked channel (run-gates.ts),
     // so it can never collide with the attempt it replaces.
-    const artifactId = `${task.id}-${channelKey(reviewer).replace(/[^a-zA-Z0-9_.-]/g, "-")}`;
+    const baseArtifactId = `${task.id}-${channelKey(reviewer).replace(/[^a-zA-Z0-9_.-]/g, "-")}`;
+    let artifactId = baseArtifactId;
+    if (artifactDir) {
+        if (existsSync(join(artifactDir, `review-brief-${baseArtifactId}.md`)) ||
+            existsSync(join(artifactDir, `review-raw-${baseArtifactId}.txt`))) {
+            let counter = 2;
+            while (existsSync(join(artifactDir, `review-brief-${baseArtifactId}-${counter}.md`)) ||
+                existsSync(join(artifactDir, `review-raw-${baseArtifactId}-${counter}.txt`))) {
+                counter++;
+            }
+            artifactId = `${baseArtifactId}-${counter}`;
+        }
+    }
     const briefPath = artifactDir ? join(artifactDir, `review-brief-${artifactId}.md`) : undefined;
     // Persistence is evidence, not a gate input: a full disk or a removed run dir never fails the gate.
     let savedBrief;
@@ -397,10 +434,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const v = extractVerdictJson(raw, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     const priorIds = new Set(priorMaterials.map((finding) => finding.fingerprint));
-    const closureLists = [v?.resolved, v?.reraised];
-    const closureInvalid = !!v && (priorIds.size > 0 || closureLists.some((list) => list !== undefined)) && (closureLists.some((list) => !Array.isArray(list) || list.some((id) => typeof id !== "string" || !priorIds.has(id)))
-        || new Set([...(v?.resolved ?? []), ...(v?.reraised ?? [])]).size !== (v?.resolved?.length ?? 0) + (v?.reraised?.length ?? 0)
-        || [...priorIds].some((id) => !v?.resolved?.includes(id) && !v?.reraised?.includes(id)));
+    const closureInvalid = isReviewClosureInvalid(v, priorIds);
     // findings decides the verdict on its own; the legacy path still needs approve + issues to parse.
     if (!v || closureInvalid || (findings === null && (typeof v.approve !== "boolean" || !Array.isArray(v.issues)))) {
         // OBS-196: name the cause and persist the raw bytes — a ruled-on "unparseable" without its
@@ -434,7 +468,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const decided = findings !== null
         ? classifyReviewFindings(findings)
         : classifyReviewIssues(v.approve, v.issues);
-    const reraised = priorMaterials.filter((finding) => v.reraised?.includes(finding.fingerprint));
+    const reraised = priorMaterials.filter((finding) => v.reraised?.some((id) => matchClosureId(id, finding.fingerprint)));
     if (reraised.length) {
         if (decided.pass)
             decided.headline = "requested changes";
@@ -455,7 +489,15 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         details,
         meta: {
             ...policyMeta, ...rotationMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider,
-            ...(priorMaterials.length ? { resolved: v.resolved, reraised: v.reraised } : {}),
+            ...(priorMaterials.length ? {
+                resolved: v.resolved,
+                reraised: v.reraised,
+                normalisedMatches: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                resolvedMatches: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                reraisedMatches: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                normalisedResolved: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                normalisedReraised: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+            } : {}),
             ...(reraised.length ? { findings: [
                     ...structuredFindings("review", details).filter((finding) => !reraised.some((prior) => prior.note === finding.note)),
                     ...reraised,

package/dist/gates/run-gates.js

@@ -366,7 +366,7 @@ export async function runGates(task, ctx) {
             // ponytail: legacy runs adjacent tools in ONE compareToBaseline call, so there is one interval
             // to measure and each of its gates carries it. Split it only if this branch ever stops batching.
             const finish = startMeasurement();
-            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates]);
+            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates], selected ? { selected } : {});
             const batch = finish();
             for (const g of gates)
                 addMeasurement(g, batch);
@@ -386,7 +386,7 @@ export async function runGates(task, ctx) {
         // any later tool before anyone reads its verdict.
         for (const g of gates) {
             await emitStart(g);
-            const [r] = await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g]));
+            const [r] = await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], g === "test" && selected ? { selected } : {}));
             // the screen's interval IS the test gate's first interval, so the split needs no second clock
             if (g === "test" && selected)
                 selectedDurationMs = spans.get("test").durationMs;

package/dist/run/daemon.d.ts

@@ -109,7 +109,9 @@ export declare const SUITE_WAIT_CEILING_MS = 600000;
 export declare const setSuiteWaitCeilingForTests: (ms: number) => void;
 export declare const resetSuiteWaitCeilingForTests: () => void;
 export declare const APPROVAL_POLL_MS = 250;
-export declare const APPROVAL_WINDOW_MS = 1000;
+export declare const APPROVAL_WINDOW_MS = 120000;
+export declare const setApprovalWindowForTests: (ms: number) => void;
+export declare const resetApprovalWindowForTests: () => void;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;

package/dist/run/daemon.js

@@ -307,7 +307,13 @@ let suiteWaitCeilingMs = SUITE_WAIT_CEILING_MS;
 export const setSuiteWaitCeilingForTests = (ms) => { suiteWaitCeilingMs = ms; };
 export const resetSuiteWaitCeilingForTests = () => { suiteWaitCeilingMs = SUITE_WAIT_CEILING_MS; };
 export const APPROVAL_POLL_MS = 250;
-export const APPROVAL_WINDOW_MS = 1_000;
+export const APPROVAL_WINDOW_MS = 120_000;
+// Keep ordinary park tests off the operator's production wait. Explicit timing tests
+// use the same setter/reset pattern as the suite wait ceiling above.
+const DEFAULT_APPROVAL_WINDOW_MS = process.env.VITEST ? 1 : APPROVAL_WINDOW_MS;
+let approvalWindowMs = DEFAULT_APPROVAL_WINDOW_MS;
+export const setApprovalWindowForTests = (ms) => { approvalWindowMs = ms; };
+export const resetApprovalWindowForTests = () => { approvalWindowMs = DEFAULT_APPROVAL_WINDOW_MS; };
 const PROVIDER_DEATH_REQUEUE_CAP = 2; // v1.46 T1: requeue same assignment twice, then fall through to the normal ladder
 const PROVIDER_DEATH_BACKOFF_MS = 500; // short backoff before provider-death requeue
 const NO_TRAILER_DEMOTION_STREAK = 2; // OBS-57: consecutive no-trailer windows demote a channel for the rest of the run
@@ -1768,6 +1774,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                     return `${identity} — release with ${commands.map((command) => `\`${command}\``).join(" or ")}`;
                 };
                 const park = async (t, reason, kind, assignment, attempts, startMs, gateFails = 0, consults = 0, tokens, metered = 0, retryMode = "fresh", details = {}) => {
+                    // OBS-979: a worker refusal can identify the missing authoring scope even when gates
+                    // subsequently supply the park's disposition. Keep that actionable path on the park itself.
+                    const worker = journal.read().reverse().find((e) => e.taskId === t.id && e.event === "worker-result");
+                    if (t.files.length > 0 && worker?.data.ok === false && typeof worker.data.summary === "string") {
+                        const allowed = filesGlob(t.files);
+                        const paths = [...worker.data.summary.matchAll(/(?:^|[\s`'"(])((?:[A-Za-z0-9_@.()[\]-]+\/)+[A-Za-z0-9_@.[\]-]+|[A-Za-z0-9_@-]+(?:\.[A-Za-z0-9_-]+)+)(?=$|[\s`'"),:;.!?])/g)]
+                            .map((match) => match[1].replace(/^\.\//, "").replace(/\.$/, ""))
+                            .filter((path) => !path.split("/").includes("..") && !allowed(path));
+                        if (paths.length)
+                            reason += ` — files[] repair hint: ${[...new Set(paths)].join(", ")}`;
+                    }
                     graph = setStatus(graph, t.id, "human");
                     saveGraph(repoRoot, graph);
                     journal.append("task-human", t.id, { ...details, reason, kind });
@@ -2026,6 +2043,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             gate: g.gate, ...(unverdicted ? {} : { pass: g.pass }), details: g.details,
                             ...(gateSubject ? { commit: gateSubject.commit, attempt: gateSubject.attempt } : {}),
                             ...(gateSubject?.replayMeasurement ? { replayMeasurement: true } : {}),
+                            ...(gateSubject?.replayedFromAttempt !== undefined ? { replayedFromAttempt: gateSubject.replayedFromAttempt } : {}),
                             ...(g.meta?.skipped === true || noVerdictReview ? { skipped: true } : {}),
                             // T9: an infra-only exit is journaled AS one. The operator reading a red `test` row has to
                             // be able to tell "the suite found a defect" from "the runner never ran", and the merge
@@ -4136,33 +4154,64 @@ export async function runDaemon(repoRoot, opts = {}) {
                             const gated = await gitHead(wt);
                             gateSubject = { commit: await gateCommitSubject(taskBase, gated, wt), attempt };
                             await trackedDriver.project?.(t.id, "in-review");
+                            // Only the immediately preceding attempt can lend a red. Re-journal its results
+                            // as this attempt's verdicts so all existing disposition and fingerprint accounting
+                            // sees the replay, without buying another command or reviewer invocation.
+                            const taskEvents = journal.read().filter((e) => e.taskId === t.id);
+                            const previousRound = taskEvents.map((e) => e.event === "phase-start" && e.data.phase === "gates").lastIndexOf(true);
+                            const previousRows = retryMode === "repair"
+                                ? taskEvents.slice(previousRound + 1).filter((e) => e.event === "gate-result"
+                                    && e.data.attempt === attempt - 1)
+                                : [];
                             journal.phaseStart(t.id, "gates");
-                            ({ results, commits } = await withSuiteWindow(t.id, t.gates.includes("test") && commands.test !== undefined, () => runReviewRecovery(t, {
-                                carriedFindings: outstandingFindings,
-                                worktree: wt, baseRef: taskBase, result, author: assignment,
-                                commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
-                                collateral: collateral.get(t.id) ?? [],
-                                pipeline: "v185", selectTests: !testGateFailed,
-                                via: cfg.visibility.llm === "pane"
-                                    ? {
-                                        driver: trackedDriver,
-                                        // D-07: judge/review panes self-clean when their verdict is read (keepLlm) — only "forever" keeps them.
-                                        keep: keepLlm,
-                                        onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined,
-                                        // T2 ownership contract: canonical names (tickmarkr:<role>:<task>:0:<runId>) so reconcile
-                                        // owns judge/review panes; run-gates' -r1 retry suffix becomes attempt 1 in llm.ts.
-                                        // Same-name reuse across worker attempts is safe: panes self-clean when read (keepLlm),
-                                        // and herdr's DEFECT-01 reclaim covers a kept holdover under keepPanes:forever.
-                                        nameFor: (role) => formatOwnedName({ role, taskId: t.id, attempt: 0, runId }),
-                                        // role-tab label (SUP-01): role-first + task id, unique per concurrent instance within a run.
-                                        // Duplicate labels from a resumed run or operator-made tabs are accepted (per-process state).
-                                        labelFor: (role) => `${role.toUpperCase()} ${t.id}`,
-                                    }
-                                    : undefined,
-                                excludeReviewers: badReviewers,
-                                reviewHistory, demotedReviewers,
-                                onGate,
-                            })));
+                            const replay = previousRows.length > 0
+                                && previousRows.every((e) => e.data.commit === gateSubject.commit)
+                                && previousRows.some((e) => e.data.pass === false && e.data.skipped !== true);
+                            if (replay) {
+                                gateSubject.replayedFromAttempt = attempt - 1;
+                                results = previousRows.map(({ data }) => ({
+                                    gate: String(data.gate), pass: data.pass === true, details: String(data.details),
+                                    // The verdict is reused; its old timing is not a measurement of this attempt.
+                                    meta: Object.fromEntries(Object.entries(data).filter(([key]) => !GATE_TELEMETRY_KEYS.includes(key) && key !== "capacity")),
+                                }));
+                                commits = await commitsAheadOf(taskBase, wt);
+                                for (const g of results) {
+                                    journal.append("gate-replayed", t.id, {
+                                        attempt, priorAttempt: attempt - 1, gate: g.gate, commit: gateSubject.commit,
+                                        ...(g.meta?.skipped === true ? { skipped: true } : { pass: g.pass }),
+                                        details: g.details,
+                                    });
+                                    journalGateResult(g);
+                                }
+                            }
+                            else {
+                                ({ results, commits } = await withSuiteWindow(t.id, t.gates.includes("test") && commands.test !== undefined, () => runReviewRecovery(t, {
+                                    carriedFindings: outstandingFindings,
+                                    worktree: wt, baseRef: taskBase, result, author: assignment,
+                                    commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
+                                    collateral: collateral.get(t.id) ?? [],
+                                    pipeline: "v185", selectTests: !testGateFailed,
+                                    via: cfg.visibility.llm === "pane"
+                                        ? {
+                                            driver: trackedDriver,
+                                            // D-07: judge/review panes self-clean when their verdict is read (keepLlm) — only "forever" keeps them.
+                                            keep: keepLlm,
+                                            onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined,
+                                            // T2 ownership contract: canonical names (tickmarkr:<role>:<task>:0:<runId>) so reconcile
+                                            // owns judge/review panes; run-gates' -r1 retry suffix becomes attempt 1 in llm.ts.
+                                            // Same-name reuse across worker attempts is safe: panes self-clean when read (keepLlm),
+                                            // and herdr's DEFECT-01 reclaim covers a kept holdover under keepPanes:forever.
+                                            nameFor: (role) => formatOwnedName({ role, taskId: t.id, attempt: 0, runId }),
+                                            // role-tab label (SUP-01): role-first + task id, unique per concurrent instance within a run.
+                                            // Duplicate labels from a resumed run or operator-made tabs are accepted (per-process state).
+                                            labelFor: (role) => `${role.toUpperCase()} ${t.id}`,
+                                        }
+                                        : undefined,
+                                    excludeReviewers: badReviewers,
+                                    reviewHistory, demotedReviewers,
+                                    onGate,
+                                })));
+                            }
                             results.forEach(classifySignalOnlyTest);
                             graph = addEvidence(graph, t.id, { commits, gateResults: results, artifacts: [promptFile] });
                             saveGraph(repoRoot, graph);
@@ -4377,6 +4426,19 @@ export async function runDaemon(repoRoot, opts = {}) {
                 };
                 taskLoopStarted = true;
                 const inflight = new Map();
+                // A settled worker can release a dependency or an approval in the same poll tick.
+                // Audit the current graph at every empty-flight boundary, never a prior ready snapshot.
+                const holdEndCondition = () => {
+                    sweepLiveApprovals();
+                    const freeSlots = Math.max(0, concurrency - inflight.size);
+                    const dispatchable = readyTasks(graph).filter((t) => !inflight.has(t.id));
+                    if (freeSlots === 0 || dispatchable.length === 0)
+                        return false;
+                    for (const task of dispatchable) {
+                        journal.append("end-condition-held", task.id, { deps: task.deps, freeSlots });
+                    }
+                    return true;
+                };
                 closeLoop: while (true) {
                     let approvalDeadline;
                     while (true) {
@@ -4412,7 +4474,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 .filter((t) => t.status === "pending").every(behindPark);
                             if (onlyParks) {
                                 if (approvalDeadline === undefined) {
-                                    const windowMs = opts.approvalWindowMs ?? APPROVAL_WINDOW_MS;
+                                    const windowMs = opts.approvalWindowMs ?? approvalWindowMs;
                                     approvalDeadline = Date.now() + windowMs;
                                     journal.append("approval-window-start", undefined, { windowMs, parked: [...parked] });
                                     // The narrator may itself append a decision at this boundary.
@@ -4428,6 +4490,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 }
                                 journal.append("approval-window-expired", undefined, { parked: [...parked] });
                             }
+                            if (holdEndCondition()) {
+                                approvalDeadline = undefined;
+                                continue;
+                            }
                             break;
                         }
                         approvalDeadline = undefined;
@@ -4438,6 +4504,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                             waiters.push(new Promise((wake) => setTimeout(wake, APPROVAL_POLL_MS)));
                         }
                         await Promise.race(waiters); // aborted rejects on termination — unwinds the run
+                        if (inflight.size === 0)
+                            holdEndCondition();
                     }
                     // D-07: the sweep now closes only what's LEFT in keptSlots — done-closed worker slots were removed
                     // (no double-close) and self-cleaned LLM/consult panes were never added under keepLlm:false. This
@@ -4515,12 +4583,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const approvalSerialization = await acquireApprovalSerialization(repoRoot, runId);
                     releaseApprovalSerialization = approvalSerialization.release;
                     // Close the last poll-to-run-end race while holding the same serializer as approve.
-                    sweepLiveApprovals();
-                    if (readyTasks(graph).length) {
+                    if (holdEndCondition()) {
                         releaseApprovalSerialization();
                         releaseApprovalSerialization = undefined;
-                        if (summary.tipVerify)
-                            journal.append("tip-verify-cancelled", undefined, { reason: "approval", lastMergedTask });
+                        // Verification has settled: retain its verdict. The cache key will require a
+                        // new battery if dispatch actually moves the tip or changes its commands.
                         continue closeLoop;
                     }
                     const outstanding = outstandingApprovals(journal.read());

package/dist/run/journal.js

@@ -949,18 +949,27 @@ export function gateResultJournalData(gate, pass, details, meta = {}) {
     const signalBasis = deriveSignalBasis(gate, pass, details, meta);
     return { gate, pass, details, ...meta, signalBasis, signalQuality: signalQualityFromBasis(signalBasis) };
 }
-// T3 (Sol #2 / Fable F2): one canonical engagement identity, shared by status AND resume. The run-start
-// event records graphDefinitionHash (over compiled task definitions only — see graph.graphDefinitionHash);
-// this is the single field both consumers read, and the single comparator below is the single place the
-// journal↔graph join is decided. unbound (no recorded definition hash, e.g. a pre-v1.44 journal) and
+// T3 (Sol #2 / Fable F2) + OBS-978: one canonical engagement identity, shared by status, plan, the operator
+// fold AND resume. The run-start event records graphDefinitionHash (over compiled task definitions only — see
+// graph.graphDefinitionHash); each audited graph-rehash row (resume --graph-changed) then moves the identity to
+// its `to`, so the recorded hash is the last audited rehash, else run-start. A row is audited when its `from`
+// names the identity it replaced, or the run-start one (all pre-OBS-978 daemons wrote); a row auditing neither
+// binds nothing — the journal is unbound until a release from null. unbound (also a pre-v1.44 journal) and
 // mismatch are both not-comparable — status renders the notice either way; resume refuses either way and
 // distinguishes the reason only for its message and the --graph-changed release event.
 export function recordedGraphDefinitionHash(events) {
+    const start = events.find((e) => e.event === "run-start");
+    if (!start)
+        return undefined;
+    const origin = typeof start.data.graphDefinitionHash === "string" ? start.data.graphDefinitionHash : null;
+    let recorded = origin;
     for (const e of events) {
-        if (e.event === "run-start" && typeof e.data.graphDefinitionHash === "string")
-            return e.data.graphDefinitionHash;
+        if (e.event !== "graph-rehash")
+            continue;
+        const audited = e.data.from === recorded || e.data.from === origin;
+        recorded = audited && typeof e.data.to === "string" ? e.data.to : null;
     }
-    return undefined;
+    return recorded ?? undefined;
 }
 // THE shared comparator (criterion: status and resume decide through one comparator). status reads
 // .comparable; resume reads .comparable plus .reason/.recorded for its refusal message and the release.

package/dist/run/operator-state.d.ts

@@ -57,7 +57,7 @@ export declare class OperatorStateFold {
     private tasks;
     private start?;
     private startEvent?;
-    private latestGraphRehash?;
+    private rehashes;
     private end?;
     private active;
     private approved;

package/dist/run/operator-state.js

@@ -10,7 +10,7 @@ export class OperatorStateFold {
     tasks = new Map();
     start;
     startEvent;
-    latestGraphRehash;
+    rehashes = [];
     end;
     active = false;
     approved = false;
@@ -34,7 +34,7 @@ export class OperatorStateFold {
             this.tipFailed = false;
         }
         if (e.event === "graph-rehash")
-            this.latestGraphRehash = { ...e, data: { from: e.data.from, to: e.data.to } };
+            this.rehashes = [...this.rehashes, { ...e, data: { from: e.data.from, to: e.data.to } }];
         if (e.event === "tip-verify-failed" || (e.event === "tip-verify" && e.data.pass === false))
             this.tipFailed = true;
         if (e.event === "run-end") {
@@ -146,13 +146,9 @@ export class OperatorStateFold {
     comparableTo(hash) {
         if (!hash)
             return false;
-        const events = [this.startEvent, this.latestGraphRehash].filter((e) => e !== undefined);
-        const baseline = engagementComparable(events, hash);
-        if (this.latestGraphRehash) {
-            const from = baseline.comparable ? baseline.recorded : baseline.reason === "mismatch" ? baseline.recorded : null;
-            return this.latestGraphRehash.data.to === hash && this.latestGraphRehash.data.from === from;
-        }
-        return baseline.comparable;
+        // The shared comparator audits the rehash chain; the fold keeps only the rows it reads.
+        const events = [this.startEvent, ...this.rehashes].filter((e) => e !== undefined);
+        return engagementComparable(events, hash).comparable;
     }
 }
 /** C1/C6 share this pure reader; callers supply the same observation and journal snapshot. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",

package/skills/tickmarkr-auto/SKILL.md

@@ -92,7 +92,7 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 1. **Prepare** — confirm the target list. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal events rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
+4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
 5. **Verify and consolidate** — continue only after a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", and the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty — a run with a parked task is partial, not green. Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout; redirect explicitly beside the spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records.
 7. **Continue** — move to the next requested target. If a target fails or is parked, stop with the journal evidence rather than silently skipping it.

package/skills/tickmarkr-loop/SKILL.md

@@ -88,7 +88,7 @@ When spawning consultants (agents gathering synthesis input for decisions like S
 1. **Prepare** — start from the requested spec. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal events rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
+4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
 5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", and the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty — a run with a parked task is partial, not green. Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout. Redirect it explicitly beside the source spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).
 

package/skills/tickmarkr-overseer/SKILL.md

@@ -149,6 +149,14 @@ through brief lineage. **An executor choice nobody made is still an executor cho
    guidance belongs in the memory file or the shipped docs.
 4. Arm the watcher and your own supervision beat (Supervision). Report the hierarchy map (pane ids + names) to the user.
 
+### Seat-spawn and Leg-2 recipes
+
+Every mission to a Claude or Grok seat is delivered only with `herdr pane run <pane> "<message>"` and
+verified by reading the pane back; never use `agent prompt` for mission delivery. Launch a Grok seat with
+`herdr agent start <seat> --kind grok --pane <pane> -- -m grok-4.6`. For Leg-2, a Codex reviewer under
+`workspace-write` must be briefed with an in-worktree verdict path such as
+`<repo>/.tickmarkr/overseer/verdicts/<task>.md`, and its verdict must be written there before it is read.
+
 ## Supervising tickmarkr as the executor — WHO DOES WHAT
 
 When the mission runs `/tickmarkr-auto` (tickmarkr dispatches the workers), supervision changes shape —
@@ -204,6 +212,9 @@ journal tail to decide what happens next, or sweeping orphans — you have taken
 - **The journal is the source of truth**, not panes. Watchers go on `run-end` / `task-human` /
   `task-failed` / `consult-verdict`; never sleep-poll inside an agent turn. **Never key a watcher on an
   agent's `done`** — that is turn end and fires the moment a seat finishes acknowledging you.
+  A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for those terminal
+  events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and
+  ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake.
   **All four are covered by one shipped instrument** — `scripts/watch-journal.sh <runs-dir> [poll] [cap]
   [events-csv]` — which arms on a line baseline, wakes once, and grades a `run-end` against every green
   clause. `scripts/watch-parks.sh` stays the park-specific wake for THIS seat (it counts parks and speaks
@@ -476,6 +487,52 @@ number — an unmeasured budget is not a small budget.
 .claude/skills/tickmarkr-overseer/scripts/watch-context.sh overseer <overseer-agent-or-pane> 50 50 <handoff-file>
 ```
 
+### A GO has a deadline — arm `watch-launch.sh` in the same act as the GO
+
+A GO that produces no run is a silent failure until someone notices; on 2026-09-11 an orchestrator's codex
+sandbox was rooted at the main repo, the spec worktree was outside its writable roots, it stopped at the
+denial without reporting, the overseer's 10-minute wake expired un-re-armed, and three hours passed.
+Two rules close that hole:
+
+- **Every orchestrator seat is sandbox-rooted at the worktree it will run in** (`cd <worktree>` before
+  `herdr agent start … --sandbox workspace-write`), and its brief says: *a denied path or refused command
+  is reported to the overseer pane within 60 s — never a silent stop.*
+- **The overseer arms the launch watcher in the SAME act as the GO**, with the lock path the run will
+  create, and treats `LAUNCH_OVERDUE` as a first-class event (read the orchestrator pane, fix the seat,
+  re-issue the GO):
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-launch.sh <worktree>/.tickmarkr/graph.lock 900 <overseer-pane> &
+```
+
+It prints `LAUNCH_OK` with the lock's contents when the run starts (exit 0) and, past the deadline, delivers
+`LAUNCH OVERDUE …` to the overseer pane AND as an OS notification (exit 3). Any wake you arm yourself with
+a cap (a background `until` loop) must be RE-ARMED on every expiry; an expired wake is not a watch.
+
+
+### A GO has a deadline — arm `watch-launch.sh` in the same act as the GO
+
+A GO that produces no run is a silent failure until someone notices; on 2026-09-11 an orchestrator's codex
+sandbox was rooted at the main repo, the spec worktree was outside its writable roots, it stopped at the
+denial without reporting, the overseer's 10-minute wake expired un-re-armed, and three hours passed.
+Two rules close that hole:
+
+- **Every orchestrator seat is sandbox-rooted at the worktree it will run in** (`cd <worktree>` before
+  `herdr agent start … --sandbox workspace-write`), and its brief says: *a denied path or refused command
+  is reported to the overseer pane within 60 s — never a silent stop.*
+- **The overseer arms the launch watcher in the SAME act as the GO**, with the lock path the run will
+  create, and treats `LAUNCH_OVERDUE` as a first-class event (read the orchestrator pane, fix the seat,
+  re-issue the GO):
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-launch.sh <worktree>/.tickmarkr/graph.lock 900 <overseer-pane> &
+```
+
+It prints `LAUNCH_OK` with the lock's contents when the run starts (exit 0) and, past the deadline, delivers
+`LAUNCH OVERDUE …` to the overseer pane AND as an OS notification (exit 3). Any wake you arm yourself with
+a cap (a background `until` loop) must be RE-ARMED on every expiry; an expired wake is not a watch.
+
+
 The first argument chooses the closed per-seat tier (`orchestrator-context` or `overseer-context`),
 and every beat names the second argument as that tier's seat. The watcher beats only after reading a
 rendered percentage, keeps beating on the supervision cadence even when its requested poll is slower,
@@ -580,9 +637,9 @@ they are left implicit:
   Send only when the seat is idle and the ANSI prompt line is empty or dim-only (the Esc/SGR discriminator
   separates an autosuggest ghost from typed input), then read back activity or an ACK; presence is not
   delivery. If a stale draft must be replaced, supersede it explicitly with
-  `agent prompt " <-- disregard … ACTUAL: …"` instead of stacking another instruction behind it.
+  `herdr pane run <pane> "<-- disregard … ACTUAL: …"` instead of stacking another instruction behind it.
 - **A MESSAGE TO A WORKING SEAT IS A QUEUED MESSAGE, AND THE QUEUE DRAINS ONLY AT TURN BOUNDARIES.**
-  Delivery is not arrival: `agent prompt` to a `working` claude seat lands in its queue (`Press up to
+  Delivery is not arrival: a message sent to a `working` claude seat lands in its queue (`Press up to
   edit queued messages` on the seat's prompt line is the tell) and is READ only when the current turn
   ends — and with in-process teammates a turn runs 20–40 minutes, so steering latency equals subagent
   runtime. Measured 2026-08-17/18 (P98 leg 1): a FREEZE HOLD and a checker-release directive stacked
@@ -622,7 +679,7 @@ they are left implicit:
 - **AGENT NAMES ARE GLOBAL ACROSS WORKSPACES — verify a seat you spawned by PANE ID, never by name.**
   Names must be unique among live agents *everywhere*, not within your workspace, so another workspace can
   already hold `opus`, `sol`, `reviewer` or `orch`. When it does, your `agent start` **fails**, your pane
-  is left a bare shell, and `agent list` / `agent read` / `agent prompt` for that name then resolve to the
+  is left a bare shell, and `agent list` / `agent read` for that name then resolve to the
   **stranger's seat**. Measured 2026-08-06 (OBS-392): a spawn of `fable` collided with a live seat in
   another workspace; `agent list` reported `fable -> blocked` and it was read as *this* seat coming up
   blocked. It was an operator research session sitting on a *"Resume full session?"* prompt. One more
@@ -644,7 +701,7 @@ they are left implicit:
   Re-arm name-keyed watchers in the same act as the rename; file-keyed artifact watchers are
   unaffected (one more reason to prefer them).
 - Stale typed input is unclearable via CLI — supersede it:
-  `pane run "<-- disregard everything before this arrow (stale draft). ACTUAL: <message>"`.
+  `herdr pane run <pane> "<-- disregard everything before this arrow (stale draft). ACTUAL: <message>"`.
   **But DISCRIMINATE before you supersede or file it: text on an idle seat's prompt line has FOUR
   authors** — the seat's own draft, an operator, another agent's `agent send` (writes WITHOUT Enter),
   and claude-code's AUTOSUGGEST, which renders context-plausible ghost text BYTE-IDENTICAL to a typed

package/skills/tickmarkr-overseer/scripts/watch-launch.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# watch-launch.sh — a GO that produced no run is a silent failure until someone notices. This watcher
+# notices. Arm it in the SAME act as the GO (orchestrator briefed to compile → plan → run) and it waits
+# for the run's lock; when the lock has not appeared by the deadline it delivers LAUNCH OVERDUE to the
+# overseer's pane AND as an OS notification, so the wake reaches a seat instead of a log nobody reads.
+#
+# Why it exists (2026-09-11): an orchestrator's codex sandbox was rooted at the main repo, the spec
+# worktree was outside its writable roots, it stopped at the denial without reporting, and the overseer's
+# own 10-minute wake expired un-re-armed. Three hours passed before anyone looked. A launch has a
+# deadline; silence past it is the event.
+#
+# usage: watch-launch.sh <lock-path> <deadline-s> <overseer-pane> [poll-s]
+#   <lock-path>      the run's .tickmarkr/graph.lock in the worktree the run will be launched in
+#   <deadline-s>     seconds from now by which the lock must exist (a compile+plan+launch takes minutes,
+#                    never hours; 900 is a generous default for a 7-task spec)
+#   <overseer-pane>  the pane that must hear about it (herdr pane id), e.g. wZ:p18S
+#   [poll-s]         poll interval, default 15
+# exit 0 LAUNCH_OK (lock seen; prints its contents) · exit 3 LAUNCH_OVERDUE (delivered) · exit 64 usage
+set -u
+LOCK="${1:-}"; DEADLINE="${2:-}"; PANE="${3:-}"; POLL="${4:-15}"
+[ -n "$LOCK" ] && [ -n "$DEADLINE" ] && [ -n "$PANE" ] || { echo "usage: watch-launch.sh <lock-path> <deadline-s> <overseer-pane> [poll-s]" >&2; exit 64; }
+start=$(date +%s)
+while :; do
+  if [ -f "$LOCK" ]; then
+    printf 'LAUNCH_OK %s %s\n' "$(date -u +%H:%M:%SZ)" "$(cat "$LOCK" 2>/dev/null | tr -d '\n')"
+    exit 0
+  fi
+  now=$(date +%s)
+  if [ $((now - start)) -ge "$DEADLINE" ]; then
+    msg="LAUNCH OVERDUE $(date -u +%H:%M:%SZ): no lock at $LOCK after ${DEADLINE}s — read the orchestrator pane NOW (sandbox denial? preflight refusal? unsubmitted GO?)"
+    echo "LAUNCH_OVERDUE $msg"
+    # Both deliveries, always: a pane the overseer reads AND a notification the operator sees.
+    herdr pane run "$PANE" "$msg" >/dev/null 2>&1 || echo "  (pane delivery failed — the notification is the only path)"
+    herdr notification show "$msg" >/dev/null 2>&1 || true
+    exit 3
+  fi
+  sleep "$POLL"
+done