tickmarkr 2.5.6 → 2.5.7

package/dist/adapters/prompt.js

@@ -71,9 +71,29 @@ function workerVerdictWitness(raw, nonce, positions) {
 // these — a result carrying any other summary is a PARSED trailer, i.e. the worker speaking.
 export const NO_TRAILER_SUMMARY = "worker produced no TICKMARKR_RESULT trailer";
 export const UNPARSEABLE_TRAILER_SUMMARY = "unparseable TICKMARKR_RESULT trailer";
+// OBS-1062: every interactive TUI echoes the brief into the pane, and the brief carries the trailer
+// TEMPLATE above — so the nonce token is on screen before the worker has said anything. A token
+// whose object opens with the template's literal `"ok":true|false` (not a bool) is the brief being
+// displayed, never the worker speaking; it must not count as trailer participation, or the daemon
+// reaps the attempt as malformed at its first poll (v2.5.7 run …115246, both workers at 34 s).
+const TEMPLATE_BODY = '{"ok":true|false';
+// Bounded to THIS occurrence (review finding, Leg 0a R2): the `{` must sit before the next nonce
+// token, or a malformed worker token followed by a later template redraw would be erased as echo.
+function isTemplateEcho(raw, at, end) {
+    const open = raw.indexOf("{", at);
+    if (open === -1 || open >= end)
+        return false;
+    const joined = raw
+        .slice(open, open + 64)
+        .split("\n")
+        .map((l) => l.replace(/^[\s│|]+/, "").replace(/[\s│|]+$/, ""))
+        .join("");
+    return joined.startsWith(TEMPLATE_BODY);
+}
 export function parseWorkerResult(raw, nonce) {
     const fail = (summary, cause) => ({ ok: false, summary, deviations: [], raw, cause });
-    const positions = trailerTokenPositions(raw, nonce);
+    const all = trailerTokenPositions(raw, nonce);
+    const positions = all.filter((at, i) => !isTemplateEcho(raw, at, all[i + 1] ?? raw.length));
     // TUIs echo the prompt template, redraw lines, and HARD-wrap the JSON with per-line margins
     // (cursor does; recent-unwrapped can't rejoin hard newlines). Scan occurrences backward — last
     // parseable wins — joining wrapped lines, stripping margin/box chrome, and growing the candidate

package/dist/cli/commands/approve.js

@@ -1,11 +1,11 @@
-import { graphDefinitionHash, loadGraph, saveGraph } from "../../graph/graph.js";
+import { graphDefinitionHash, loadGraph, saveGraph, taskDefinitionFingerprint } from "../../graph/graph.js";
 import { execFileSync } from "node:child_process";
 import { userInfo } from "node:os";
 import { loadConfig } from "../../config/config.js";
 import { integrationBranch } from "../../run/merge.js";
 import { separabilityErrors } from "../../compile/collateral.js";
 import { GATE_NAMES } from "../../graph/schema.js";
-import { applyScopeAmendments, engagementComparable, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
+import { applyScopeAmendments, engagementComparable, engagementReleased, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
 export const APPROVAL_DISPOSITIONS = ["dispatch", "waive-gate", "re-dispatch", "fund-fixed-attempt", "fresh-budget"];
 /**
  * What each disposition's release actually buys — the clause every operator-facing sentence about
@@ -178,7 +178,7 @@ export async function approve(argv, cwd = process.cwd()) {
                 throw new Error(`scope-request for ${taskId} requires --files <glob,…>`);
             if (decisions)
                 throw new Error("--files cannot be combined with --waive, --uphold or --recheck");
-            const graph = applyScopeAmendments(loadGraph(cwd), journal);
+            const graph = applyScopeAmendments(loadGraph(cwd), journal, false, engagementReleased(events));
             const from = graphDefinitionHash(graph);
             if (!engagementComparable(journal.read(), from).comparable
                 || (lastHuman?.data.graphDefinitionHash !== undefined && lastHuman.data.graphDefinitionHash !== from)) {
@@ -196,11 +196,11 @@ export async function approve(argv, cwd = process.cwd()) {
                 throw new Error(`refusing scope-request approval for ${taskId}: ${conflicts.join("\n")}`);
             journal.append("task-approved", taskId, {
                 by, ...(reason ? { reason } : {}), via: "cli", release: "scope-request",
-                amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line },
+                amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line, definition: taskDefinitionFingerprint(task) },
             });
             // Do not write graph.json from this process while the daemon owns it: its sweep materializes
             // the amendment without replacing a sibling's running state with this command's snapshot.
-            const projected = applyScopeAmendments(graph, journal);
+            const projected = applyScopeAmendments(graph, journal, false, engagementReleased(events));
             const owner = approvalRunOwner(cwd, runId);
             if (!owner.live && !owner.blockingRunId)
                 saveGraph(cwd, projected);

package/dist/cli/commands/status.js

@@ -7,8 +7,11 @@ import { HerdrDriver } from "../../drivers/herdr.js";
 import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
-import { foldActivity } from "../../run/activity.js";
-import { Journal, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
+import { projectActivity } from "../../run/activity.js";
+import { projectOperatorSummary } from "../../run/operator-summary.js";
+import { trackJournalRows } from "../../run/protocol.js";
+import { newestPark, permittedDecisionVerbs } from "./approve.js";
+import { Journal, formatJournalNarration, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
 import { isPidLive, runLockRunId, runStatusLine } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
@@ -96,8 +99,8 @@ const taskClockReference = (events, taskId, content, fallback) => {
     }
     return fallback;
 };
-// Every attempt number a cell phrase carries is the engagement's own ladder (foldActivity counts
-// dispatch labels from 1). Name that ruler wherever a bare one appears, not only in the one phrase
+// Every attempt number a cell phrase carries is the engagement's own ladder (journal dispatch
+// labels are displayed from 1). Name that ruler wherever a bare one appears, not only in the one phrase
 // shipping today — a phrase added upstream must not reach the operator unruled.
 const labelAttemptRuler = (text) => text.replace(/(?<!engagement |run )\battempt (?=\d)/gu, "engagement attempt ");
 // The timer must keep the process ALIVE: an unref'd timer here let the event loop drain after the
@@ -907,9 +910,58 @@ const readRunRecord = (cwd, graph, namedRunId) => {
  * catch an empty or torn first write. Those snapshots own no task fold yet; once run-start exists,
  * however, a fold failure is unexpected and must surface instead of becoming a false empty run.
  */
-const recordTaskRows = (record, graph) => record.comparable && record.events.some((event) => event.event === "run-start")
-    ? new Map(deriveRunCockpitData({ fileName: `${record.runId}.journal.jsonl`, raw: record.raw }, "status", { graph }).taskRows.map((row) => [row.taskId, row]))
+const recordTaskRows = (record, graph, isDaemonAlive) => record.comparable && record.events.some((event) => event.event === "run-start")
+    ? new Map(deriveRunCockpitData({ fileName: `${record.runId}.journal.jsonl`, raw: record.raw }, "status", { graph, isDaemonAlive }).taskRows.map((row) => [row.taskId, row]))
     : new Map();
+/** Adapt the single journal snapshot to the shared, evidence-only projections. */
+const recordProjection = (record, graph, isDaemonAlive) => {
+    const rows = record ? recordTaskRows(record, graph, isDaemonAlive) : new Map();
+    const events = record?.comparable ? record.events : [];
+    const activity = projectActivity(record?.runId ?? "", trackJournalRows(record?.runId ?? "", events.map((raw, sourceIndex) => ({ raw, sourceIndex }))), graph.tasks);
+    const tasks = graph.tasks.map(task => {
+        const row = rows.get(task.id);
+        const evidence = events.filter(event => event.taskId === task.id);
+        const last = evidence.at(-1);
+        const recorded = activity.get(task.id);
+        let phase = last ? recorded.state : undefined;
+        // A completed battery is evidence of readiness, never evidence that merge started.
+        const gates = gateSnapshot(task, events, record?.rehashAt);
+        const boundary = events.reduce((index, event, at) => ["run-start", "run-resume", "run-end"].includes(event.event)
+            || (event.taskId === task.id && (event.event === "task-dispatch"
+                || (event.event === "phase-start" && event.data.phase === "gates"))) ? at : index, -1);
+        // Read the latest outcome, including non-verdicts. The gate rail retains earlier
+        // verdicts while a screen or infrastructure retry is pending; that historical
+        // pass must not make the current battery look ready to merge.
+        const currentResults = new Map(events.slice(boundary + 1).filter(event => event.taskId === task.id && event.event === "gate-result")
+            .map(event => [event.data.gate, normalizeGateOutcome(event.data).kind]));
+        if (recorded.state === "unconfirmed" && task.gates.length > 0 && !gates.priorGraph
+            && task.gates.every(gate => currentResults.get(gate) === "passed")) {
+            phase = "awaiting merge phase";
+        }
+        const responsibility = [...evidence].reverse().find(event => typeof event.data.role === "string" || typeof event.data.agent === "string");
+        return {
+            id: task.id, deps: task.deps, status: row?.state ?? task.status,
+            phase, lastEvidenceAt: last?.ts,
+            responsible: responsibility ? {
+                role: typeof responsibility.data.role === "string" ? responsibility.data.role : undefined,
+                agent: typeof responsibility.data.agent === "string" ? responsibility.data.agent : undefined,
+            } : undefined,
+        };
+    });
+    const decisions = tasks.flatMap(task => {
+        const park = task.status === "human" ? newestPark(events, task.id) : undefined;
+        return park ? [{ taskId: task.id, park, verbs: permittedDecisionVerbs(park) }] : [];
+    });
+    return { rows, activity, summaries: new Map(projectOperatorSummary(tasks, decisions).map(task => [task.taskId, task])) };
+};
+const summaryText = (summary) => sanitizeTaskText([
+    `phase ${summary.phase ?? "unrecorded"}`,
+    `last evidence ${summary.lastEvidenceAt ?? "unrecorded"}`,
+    `responsible ${[summary.responsible?.role, summary.responsible?.agent].filter(Boolean).join(" / ") || "unrecorded"}`,
+    `blocker ${summary.blocker?.kind ?? "none"}`,
+    `next action ${summary.blocker?.nextAction ?? "unrecorded"}`,
+    `human-decision ${summary.blocker?.decisionRequired ? "yes" : "no"}`,
+].join(" · "));
 /** The graph tasks this run's record actually speaks about — a row with no recorded fact is silence. */
 const recordedTasks = (graph, rows) => graph.tasks.filter((task) => {
     const row = rows.get(task.id);
@@ -936,14 +988,11 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const comparable = record?.comparable ?? false;
     const rehashAt = record?.rehashAt;
     const assignments = new Map();
-    let replayed = null;
     const contexts = new Map();
     // v1.53 T5: this run is dead — a newer run replaced it
     const supersededBy = [...events].reverse()
         .find((e) => e.event === "superseded" && typeof e.data.by === "string")?.data.by;
     if (record && comparable) {
-        if (!journalRowsOnly)
-            replayed = Journal.open(cwd, record.runId).replayStatuses();
         for (const e of events) {
             if (!journalRowsOnly && e.event === "task-dispatch" && e.taskId) {
                 const a = e.data.assignment;
@@ -956,7 +1005,12 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             }
         }
     }
-    const taskRows = record && journalRowsOnly ? recordTaskRows(record, g) : new Map();
+    const projection = recordProjection(record, g, () => daemon.state !== "dead");
+    const taskRows = projection.rows;
+    // Preserve the plain table's compact status vocabulary using the same snapshot as its evidence.
+    const replayed = new Map([...taskRows].flatMap(([id, row]) => row.state === undefined ? [] : [[id,
+            row.state === "running" || row.state === "interrupted" ? "pending" : graphTaskStatus(row.state, "pending"),
+        ]]));
     const clockFallback = new Date(now);
     const recordedClock = new Date(events.at(-1)?.ts ?? now);
     const zoneReference = Number.isFinite(recordedClock.getTime()) ? recordedClock : clockFallback;
@@ -973,14 +1027,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     };
     const renderedTasks = journalRowsOnly ? recordedTasks(g, taskRows) : g.tasks;
     const starved = new Set(blockedTasks(effective).map((t) => t.id));
-    // OBS-104: ONE activity fold feeds both surfaces — never re-derived here. Comparable events only
-    // (a recompiled graph's journal must not animate the wrong tasks); with no or stale journal the
-    // dep-waiting cells still derive from the effective graph statuses.
-    const activity = foldActivity(comparable ? events : [], effective.tasks);
-    // RULING-v189-scope §14c: a card answers BOTH supervisor questions. `foldActivity` names what a
-    // task waits FOR; this names what waits ON it. Read from `effective.tasks` — whose statuses are
-    // the journal's replay, never the compiled graph's — so a dependent the record says is done stops
-    // being named, and a task all of whose dependents are done acquires no entry at all.
+    // Reverse dependencies share the effective task statuses with the projection.
     const dependents = new Map();
     for (const task of effective.tasks) {
         if (task.status === "done")
@@ -1039,7 +1086,18 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             || (st === "failed" && failureKind === undefined));
         const livePhase = phases.get(t.id);
         const isStarved = !livePhase && starved.has(t.id);
-        const rawPhrase = livePhase ? phaseDetail(livePhase, now, workerLiveness.get(t.id)) : isStarved ? undefined : activity.cells.get(t.id);
+        const summary = projection.summaries.get(t.id);
+        // Attempt labels can restart at zero in legacy engagements. Pair the preparing caption's
+        // counter and timestamp from the same dispatch, rather than retaining a prior higher label.
+        const dispatch = [...events].reverse().find(event => event.taskId === t.id && event.event === "task-dispatch");
+        const projectedPhrase = summary.blocker?.kind === "dependency-wait"
+            ? `dep-waiting on ${summary.blocker.prerequisites.join(", ")}`
+            : summary.phase === "terminal"
+                ? st === "human" ? `parked${failureKind ? ` (${failureKind})` : ""}` : undefined
+                : summary.phase === "preparing" && dispatch
+                    ? `preparing · attempt ${(Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0) + 1} since ${dispatch.ts.slice(11, 19)}`
+                    : summary.phase ?? undefined;
+        const rawPhrase = livePhase ? phaseDetail(livePhase, now, workerLiveness.get(t.id)) : projectedPhrase;
         const phrase = rawPhrase === undefined
             ? undefined
             : journalRowsOnly
@@ -1053,12 +1111,12 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             ? gateSnapshot(t, events, rehashAt)
             : { states: defaultGateStates(t), priorGraph: false };
         const pane = panes.get(t.id);
-        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, pane, ...gates };
+        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, pane, summary, ...gates };
     });
     if (!unicode) {
-        // machine/CI surface — journals without phase-start stay byte-identical; new phase-aware frames
-        // use an ASCII spinner so pipes never receive terminal-only braille/ANSI.
-        const rows = cells.flatMap(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane }) => {
+        // Keep the machine task-title columns intact; projection details occupy their own line.
+        // Phase-aware frames use ASCII spinners so pipes never receive terminal-only braille/ANSI.
+        const rows = cells.flatMap(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane, summary }) => {
             const chain = gateChain(states, false);
             const prefix = livePhase ? `  ${ASCII_SPINNER[animationFrame % ASCII_SPINNER.length]} ${t.id} ` : `  ${surfaceTaskBox(st, merged)} ${t.id} `;
             const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}${pane ? `  pane ${pane}` : ""}`;
@@ -1069,6 +1127,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             // (a pane name is 60 columns on its own), so the floor costs wrapping, never the graph.
             return [
                 `${prefix}${shortGoal(t.title, Math.max(MACHINE_TITLE_FLOOR, width - prefix.length - suffix.length))}${suffix}`,
+                `    ${summaryText(summary)}`,
                 ...recoveryLinesForTask(t.id).map((line) => `    ${line}`),
             ];
         });
@@ -1142,7 +1201,8 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         besideLockup(fillLockup(dim(versionText), versionCells), factLines[1]),
         ...factLines.slice(2).map((line) => `${" ".repeat(lockupCells + lockupGapCells)}${line}`),
     ];
-    const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
+    const lastEvent = comparable ? events.at(-1) : undefined;
+    const nowLine = lastEvent ? [legend(`   now: ${formatJournalNarration(lastEvent)}`)] : [];
     const supervisionLegend = legend(`   ${supervisionText(supervision)}`);
     const taskSectionSummary = `${done} of ${total} merged · rows in graph order · gates left→right in pipeline order`;
     const taskSection = `  ${ok("▌")} ${title("TASKS")}   ${dim(taskSectionSummary)}`;
@@ -1220,6 +1280,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                     `    ${tone(cell.t.id)}  ${dim(taskArea(cell.t))}  ${sanitizeTaskText(cell.t.title)}`,
                     ...wrapCells(`    ${dim(machinery)}`, boardColumns, { continuationPrefix: "      " }),
                     ...wrapCells(`    ${dim(noteFor(cell))}`, boardColumns, { continuationPrefix: "      " }).filter((line) => line.trim()),
+                    ...wrapCells(`    ${dim(summaryText(cell.summary))}`, boardColumns, { continuationPrefix: "      " }),
                     "",
                 ];
             });
@@ -1249,15 +1310,15 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                             ? running
                             : dim;
             const titleTone = cell.redTier || cell.livePhase || (effort?.parks ?? 0) >= 3 ? title : dim;
-            return Array.from({ length: height }, (_, index) => `    ${idTone(fitColumn(columns[0][index] ?? "", idWidth, 1))}`
-                + dim(fitColumn(columns[1][index] ?? "", areaWidth))
-                + dim(fitColumn(columns[2][index] ?? "", depsWidth))
-                + titleTone(fitColumn(columns[3][index] ?? "", taskWidth))
-                + fitCells(columns[4][index] ?? "", gatesWidth)
-                + "  "
-                + dim(fitColumn(columns[5][index] ?? "", channelWidth))
-                + dim(fitColumn(columns[6][index] ?? "", attemptWidth, 1))
-                + dim(fitCells(columns[7][index] ?? "", noteWidth)));
+            return [...Array.from({ length: height }, (_, index) => `    ${idTone(fitColumn(columns[0][index] ?? "", idWidth, 1))}`
+                    + dim(fitColumn(columns[1][index] ?? "", areaWidth))
+                    + dim(fitColumn(columns[2][index] ?? "", depsWidth))
+                    + titleTone(fitColumn(columns[3][index] ?? "", taskWidth))
+                    + fitCells(columns[4][index] ?? "", gatesWidth)
+                    + "  "
+                    + dim(fitColumn(columns[5][index] ?? "", channelWidth))
+                    + dim(fitColumn(columns[6][index] ?? "", attemptWidth, 1))
+                    + dim(fitCells(columns[7][index] ?? "", noteWidth))), ...wrapCells(`    ${dim(summaryText(cell.summary))}`, boardColumns, { continuationPrefix: "      " })];
         });
         return [legend(headerRow), dim(ruleRow), ...rows];
     };
@@ -1305,7 +1366,7 @@ const oneLine = (cwd, namedRunId) => {
     const record = readRunRecord(cwd, graph, namedRunId);
     if (!record)
         return sanitizeTaskText(`tickmarkr · no runs yet · 0/${graph.tasks.length} done`);
-    const rows = recordTaskRows(record, graph);
+    const { rows } = recordProjection(record, graph);
     const claims = record.comparable
         ? [
             `${recordedDone(recordedTasks(graph, rows), rows)}/${graph.tasks.length} done`,

package/dist/cli/commands/verify.js

@@ -150,10 +150,12 @@ export async function verify(argv, cwd = process.cwd()) {
         allowPositionals: false,
     });
     const stateRoot = await verifyStateRoot(cwd);
+    const fileRoot = (file) => existsSync(join(cwd, ".tickmarkr", file)) ? cwd : stateRoot;
     if (resolve(stateRoot) !== resolve(cwd)) {
-        console.error(`verify: state files graph.json, doctor.json and config.yaml resolved read-only from ${join(stateRoot, ".tickmarkr")} (linked worktree)`);
+        console.error(`verify: state files resolved read-only from ${join(stateRoot, ".tickmarkr")} (linked worktree; per-file origins: `
+            + STATE_FILES.map(file => `${file}: ${join(fileRoot(file), ".tickmarkr", file)} (${fileRoot(file) === cwd ? "local" : "common root"})`).join("; ") + ")");
     }
-    const cfg = loadConfig(stateRoot);
+    const cfg = loadConfig(fileRoot("config.yaml"));
     const head = (await shGitOk("git rev-parse HEAD", cwd)).trim();
     const baseTip = (await shGitOk(`git rev-parse '${values.base}'`, cwd).catch(() => {
         throw new Error(`--base ${values.base} is not a resolvable ref — pass --base <ref> naming the branch this diff targets`);
@@ -167,7 +169,7 @@ export async function verify(argv, cwd = process.cwd()) {
     let files = values.files ?? [];
     let goal = `independent verification of the ${values.base}..HEAD diff`;
     if (values.task) {
-        const t = getTask(loadGraph(stateRoot), values.task);
+        const t = getTask(loadGraph(fileRoot("graph.json")), values.task);
         acceptance = t.acceptance;
         if (!files.length)
             files = t.files;
@@ -223,7 +225,7 @@ export async function verify(argv, cwd = process.cwd()) {
     let author = HUMAN_AUTHOR;
     const adapters = allAdapters();
     if (wantAcceptance || wantReview) {
-        const health = readDoctor(stateRoot) ?? (await probeAll(adapters));
+        const health = readDoctor(fileRoot("doctor.json")) ?? (await probeAll(adapters));
         const pools = rolePools(cfg, adapters, health);
         judgeChannels = pools.judge;
         channels = pools.review;

package/dist/gates/baseline.d.ts

@@ -1,6 +1,6 @@
 import type { TickmarkrConfig } from "../config/config.js";
 import type { AcceptanceItem } from "../graph/schema.js";
-import { type RunCapacity, type ShResult } from "../run/git.js";
+import { type RunCapacity, type ShellOptions, type ShResult } from "../run/git.js";
 import type { GateResult } from "./types.js";
 /**
  * T7: the capacity a gate's own command ran under rides the RESULT, beside the verdict it explains,
@@ -157,7 +157,12 @@ export declare const CAPTURE_CEILING_MS = 1800000;
 /** OBS-1044: a cached vitest entry whose count is a stdout sum may be inflated; only a manifest-derived
  * count is safe to apply as a deficit floor. A null count compares nothing and is safe as-is. */
 export declare function staleFileCountCommands(baseline: Baseline, commands: Record<string, string>, cwd: string): string[];
-export declare function captureBaseline(cwd: string, commands: Record<string, string>): Promise<Baseline>;
+export interface BaselineReceiptOptions {
+    onReceipt?: ShellOptions["onReceipt"];
+    /** Only comparison's build command may carry task-build identity; capture never does. */
+    taskBuildAttribution?: ShellOptions["receiptAttribution"];
+}
+export declare function captureBaseline(cwd: string, commands: Record<string, string>, opts?: BaselineReceiptOptions): Promise<Baseline>;
 export interface VacuousOracleWarning {
     kind: "vacuous-oracle";
     taskId: string;
@@ -171,7 +176,7 @@ export declare function detectVacuousOracles(cwd: string, tasks: ReadonlyArray<{
 export interface RetryOptions {
     authorizeRetry?: (cause: "infra" | "host-starved") => boolean;
 }
-export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: RetryOptions & {
+export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: RetryOptions & BaselineReceiptOptions & {
     rerunOf?: HostStarvedRerun;
     infraRerun?: HostStarvedRerun;
     selected?: readonly string[];

package/dist/gates/baseline.js

@@ -487,13 +487,13 @@ export function staleFileCountCommands(baseline, commands, cwd) {
     })
         .map(([name]) => name);
 }
-export async function captureBaseline(cwd, commands) {
+export async function captureBaseline(cwd, commands, opts = {}) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
         if (name === "tipTest" && commands.test !== undefined && cmd === commands.test) {
             continue;
         }
-        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS);
+        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS, { onReceipt: opts.onReceipt });
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
         // ponytail: a capture that was itself killed records the ceiling as its "measurement", which
         // scales the next ceiling up — the right direction for a suite that never finished once.
@@ -634,7 +634,10 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         }
         const entry = baseline.commands[name];
         const ceilingMs = effectiveCeilingMs(entry);
-        const r = await sh(cmd, cwd, ceilingMs);
+        const r = await sh(cmd, cwd, ceilingMs, {
+            onReceipt: opts.onReceipt,
+            ...(name === "build" ? { receiptAttribution: opts.taskBuildAttribution } : {}),
+        });
         // T7: every verdict below carries the capacity ITS OWN command ran under, taken off the shell
         // result rather than re-derived after the fact. The skip row above ran no command and therefore
         // states no capacity — a row that never divided the machine must not claim that it did.

package/dist/gates/review.js

@@ -185,7 +185,10 @@ export { modelProvider };
 export function matchClosureId(candidate, target) {
     if (typeof candidate !== "string")
         return typeof target === "string" ? false : undefined;
-    const normCandidate = candidate.replace(/\s+/g, "");
+    // OBS-1068: the brief's copy block printed each id as `Fingerprint: <id>` and told the seat to copy
+    // it EXACTLY — three faithful approvals in one run were discarded as closure-mismatch. A leading
+    // `Fingerprint:` label is the brief's own wording, never the reviewer's id; strip it before comparing.
+    const normCandidate = candidate.replace(/^\s*fingerprint\s*:\s*/i, "").replace(/\s+/g, "");
     if (typeof target === "string") {
         return normCandidate === target.replace(/\s+/g, "");
     }
@@ -476,6 +479,11 @@ carriedAuthors = []) {
         return capFail;
     const nonce = generateVerdictNonce();
     const repoRoot = daemonRepoRoot(worktree, artifactDir);
+    // OBS-880 add.1: guidance only. Do not expand scope globs into permission to run suites.
+    const ownTestFiles = [...new Set(task.files.filter((file) => !/[*?[\]{}()!]/.test(file) && /(?:^|\/)[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file)))];
+    const suiteBudget = ownTestFiles.length
+        ? `You may run at most the task's own test files explicitly named in files[]; these are the only suites you may run: ${ownTestFiles.map((file) => `\`${file}\``).join(", ")}.`
+        : "No suite may be run: files[] names no explicit test file owned by this task.";
     const prompt = `TICKMARKR-REVIEW
 You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
 Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
@@ -489,6 +497,9 @@ ${task.acceptance.map((a) => `- ${renderAcceptanceItem(a)}`).join("\n")}
 
 ${renderDeclaredWriteScope(task.files)}
 
+## Reviewer suite budget
+${suiteBudget} Never run the whole suite (including an unfiltered npm test or vitest run). The gate suite owns the runner lease; a parallel full suite starves the gate.
+
 ${priorMaterials.length ? `${renderPriorMaterials(priorMaterials)}
 
 ` : ""}## Diff

package/dist/gates/run-gates.d.ts

@@ -1,3 +1,4 @@
+import type { CommandReceiptAttribution } from "../run/protocol.js";
 import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
 import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
@@ -42,9 +43,10 @@ export type GateEvent = {
     gate: GateName;
     name: string;
     payload: Record<string, unknown>;
-    result: GateResult;
+    result?: GateResult;
 };
 export interface GateContext {
+    buildReceiptIdentity?: Omit<CommandReceiptAttribution, "invocation">;
     authorizeInfraRetry?: (subject: string, cause?: VerificationRetryCause) => boolean;
     verificationScope?: VerificationScope;
     worktree: string;
@@ -62,6 +64,7 @@ export interface GateContext {
     excludeReviewers?: string[];
     demotedReviewers?: Set<string>;
     reviewNoVerdicts?: Map<string, string[]>;
+    recheck?: boolean;
     carriedAuthors?: readonly string[];
     reviewHistory?: string[];
     priorReviewers?: PriorReviewer[];

package/dist/gates/run-gates.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
 import { loadavg, tmpdir } from "node:os";
 import { join, posix } from "node:path";
@@ -258,6 +259,40 @@ function classifySignalOnlyTest(g) {
 }
 export async function runGates(task, ctx) {
     const results = [];
+    // Receipt identity belongs to this round, never to a cached verdict. Each call from the shell
+    // allocates a new invocation, including retries whose local spawn counter starts at one again.
+    let currentBuild;
+    let buildStarted = false;
+    let receiptNotes = Promise.resolve();
+    const beginBuild = () => {
+        buildStarted = false;
+        currentBuild = { ...(ctx.buildReceiptIdentity ?? {
+                runId: ctx.artifactDir ?? "standalone", taskId: task.id, attempt: 0, gateRound: 0,
+            }), invocation: randomUUID() };
+        return { ...currentBuild };
+    };
+    const buildReceipt = (receipt, reason) => {
+        const matches = currentBuild !== undefined && receipt.attribution !== undefined
+            && Object.keys(currentBuild)
+                .every((key) => receipt.attribution[key] === currentBuild[key]);
+        const attributed = matches && (receipt.outcome === "started" || !receipt.confirmedStart || buildStarted);
+        if (attributed)
+            buildStarted = receipt.outcome === "started";
+        const { attribution, ...observation } = receipt;
+        const payload = attributed ? { ...receipt, gate: "build", ...(reason ? { reason, freshBuildRan: false } : {}) } : {
+            ...observation, gate: "build", attributionStatus: "unattributed",
+            reportedAttribution: attribution,
+        };
+        // Shell observers are synchronous. Serialize asynchronous note sinks and drain before the
+        // verdict (also on cancellation), without letting an observer change execution or retry policy.
+        receiptNotes = receiptNotes.then(async () => {
+            await ctx.onGate?.({ phase: "note", gate: "build", name: "build-receipt", payload });
+        }).catch(() => { });
+    };
+    const noBuild = async (outcome, reason) => {
+        buildReceipt({ outcome, confirmedStart: false, attribution: beginBuild() }, reason);
+        await receiptNotes;
+    };
     let selectionDecision;
     let commits = [];
     const stateDir = ctx.stateDir ?? resolveStateDir(ctx.worktree, ctx.artifactDir);
@@ -272,6 +307,14 @@ export async function runGates(task, ctx) {
     // the ledger names the reuse and the identity even where the gate-result row's details must stay
     // the fresh verdict's (see formatReusedRow).
     const noteReuse = (gate, r, id) => ctx.onGate?.({ phase: "note", gate, name: "gate-reused-verdict", payload: { gate, pass: r.pass, details: r.meta?.reusedDetails, ...reusedIdentity(id) }, result: r });
+    // OBS-1055: on a recheck a cached red is the answer the operator just said was wrongly given; it is
+    // journaled as discarded and the gate runs. Returns true when the hit must NOT be reused.
+    const discardCachedRed = async (gate, hit) => {
+        if (!ctx.recheck || hit.pass)
+            return false;
+        await ctx.onGate?.({ phase: "note", gate, name: "recheck-rerun", payload: { gate, reason: "cached-red-discarded" }, result: hit });
+        return true;
+    };
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
@@ -595,20 +638,30 @@ export async function runGates(task, ctx) {
                 const hit = verdictStore.get(identity);
                 if (hit)
                     classifySignalOnlyTest(hit); // Older entries predate classification at the write seam.
-                if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+                if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")
+                    && !(await discardCachedRed(g, hit))) {
                     r = formatReusedRow(hit, identity);
                     cached = true;
+                    if (g === "build")
+                        await noBuild("reused-result", "verdict reused; no fresh build ran in this invocation");
                     await noteReuse(g, r, identity);
                 }
             }
             if (!r) {
-                // VL-1: a detected vitest test command is judged by its own invocation-bound report — the
-                // stdout-count/file-count path (compareToBaseline's fileCountDeficit) never runs for it. Any
-                // other scripted test command keeps today's exit-code contract byte-identically.
-                const useManifest = g === "test" && commands.test !== undefined && isVitestTestCommand(commands.test, ctx.worktree);
-                r = useManifest
-                    ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir, retryOptions(identity)))
-                    : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], { ...retryOptions(identity), ...(g === "test" && selected ? { selected } : {}) })))[0];
+                if (g === "build" && !cmd)
+                    await noBuild("skipped", "no build command detected");
+                try {
+                    // VL-1: a detected vitest test command is judged by its own invocation-bound report — the
+                    // stdout-count/file-count path (compareToBaseline's fileCountDeficit) never runs for it. Any
+                    // other scripted test command keeps today's exit-code contract byte-identically.
+                    const useManifest = g === "test" && commands.test !== undefined && isVitestTestCommand(commands.test, ctx.worktree);
+                    r = useManifest
+                        ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir, retryOptions(identity)))
+                        : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], { ...retryOptions(identity), ...(g === "build" ? { onReceipt: buildReceipt, taskBuildAttribution: beginBuild } : {}), ...(g === "test" && selected ? { selected } : {}) })))[0];
+                }
+                finally {
+                    await receiptNotes;
+                }
             }
             // the screen's interval IS the test gate's first interval, so the split needs no second clock
             if (g === "test" && selected)
@@ -929,6 +982,8 @@ export async function runGates(task, ctx) {
     if (entryDirt) {
         addMeasurement(sequence[0], entryMeasurement);
         await emitStart(sequence[0]);
+        if (enabled("build"))
+            await noBuild("refused", "dirty worktree; no build start confirmed");
         await record(await dirtyRefusal(sequence[0], entryDirt));
         return done();
     }
@@ -1037,7 +1092,8 @@ export async function runGates(task, ctx) {
             const hit = verdictStore.get(identity);
             if (hit)
                 classifySignalOnlyTest(hit);
-            if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+            if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")
+                && !(await discardCachedRed("test", hit))) {
                 full = formatReusedRow(hit, identity);
                 cached = true;
                 await noteReuse("test", full, identity);

package/dist/gates/test-manifest.d.ts

@@ -36,6 +36,9 @@ export interface TestReport {
     certificate?: {
         at: number;
         exitCode: number;
+        /** Unhandled and module collection errors observed by the reporter; absent on older reports. */
+        errors?: number;
+        diagnostics?: string[];
     };
 }
 /** Reads and structurally validates the report; a missing or malformed file is `undefined` — never a partial parse. */

package/dist/gates/test-manifest.js

@@ -448,11 +448,29 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
         });
         const verdict = verifyManifestReport({ manifest: files, nonce, exitCode: invoked.exitCode,
             report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs });
+        // Preserve the validator's verdict and classification; runner evidence only explains it.
+        const stdoutPath = join(dir, `test-runner-stdout-${nonce}.log`);
+        const stderrPath = join(dir, `test-runner-stderr-${nonce}.log`);
+        const stdoutTail = Buffer.from(invoked.stdout).subarray(-16 * 1024);
+        const stderrTail = Buffer.from(invoked.stderr).subarray(-16 * 1024);
+        writeFileSync(stdoutPath, stdoutTail);
+        writeFileSync(stderrPath, stderrTail);
+        const report = invoked.report?.nonce === nonce ? invoked.report : undefined;
+        const neverStarted = report ? files.filter(file => !(file in report.started)).length : "unknown";
+        const errors = report?.certificate?.errors;
+        const reporterErrors = typeof errors === "number" && Number.isInteger(errors) && errors >= 0 ? errors : "unknown";
+        const reportedDiagnostics = report?.certificate?.diagnostics;
+        const runnerErrors = Array.isArray(reportedDiagnostics) ? reportedDiagnostics.filter(error => typeof error === "string") : [];
+        const diagnostics = !verdict.pass
+            ? `\nclassification: ${verdict.meta.classification ?? "unknown"}; runner-level diagnostic: never-started ${neverStarted}; reporter errors ${reporterErrors}`
+                + [...runnerErrors,
+                    stdoutTail.toString(), stderrTail.toString()].filter(Boolean).map(text => `\n${text}`).join("")
+            : "";
         return { pass: verdict.pass, kind: verdict.kind,
-            details: verdict.details + (!invoked.report && invoked.stderr ? `\nvitest reporter: ${invoked.stderr}` : ""),
+            details: verdict.details + diagnostics,
             classification: verdict.meta.classification,
             meta: { ...verdict.meta, nonce, manifest: files, manifestPath, listingCommand: invocation.listing, verification,
-                spawnedCommand, processExit: invoked.exitCode, pid: invoked.pid },
+                spawnedCommand, processExit: invoked.exitCode, pid: invoked.pid, stdoutPath, stderrPath },
             exitCode: invoked.exitCode ?? -1, reportPath };
     }
     catch (error) {