tickmarkr 2.5.5 → 2.5.7

package/README.md

@@ -52,7 +52,7 @@ prefer, every example below works with either.
 
 - **macOS or Linux.** Every command shells out through `bash`, so native Windows is not
   supported — use WSL (untested).
-- Node ≥ 20 and `git` on PATH.
+- Node ≥ 20.3 and `git` on PATH.
 - At least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, `pi`,
   or `kimi`), authenticated through its own login. tickmarkr never handles vendor API keys itself.
 
@@ -476,6 +476,8 @@ accepted contributions are credited via `Co-authored-by:` on the release commit.
 
 ## Documentation
 
+- [Experimental execution policy](docs/experimental-execution-policy.md) — bounded recovery, cumulative task time, and repair selection.
+
 - **[FLEET.md](https://github.com/alzahrani-khalid/tickmarkr/blob/main/FLEET.md)** — routing modes, steering syntax, tier provenance, and run flags (advanced reference)
 - **[LICENSE](LICENSE)** — MIT license
 - **[CONTRIBUTING.md](CONTRIBUTING.md)** — development setup and contribution guidelines

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,8 +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
@@ -85,6 +88,8 @@ export function permittedDecisionVerbs(park) {
     }
     if (park.kind === "infra")
         return ["approve", "recheck"];
+    if (park.kind === "diff-cap")
+        return ["recheck"]; // OBS-1007: a cap trip is re-gated under a raised cap, never re-bought
     return ["approve"];
 }
 /** The release marker this command appends for a verb on a park — the fact a read-back must match. */
@@ -138,6 +143,21 @@ export async function approve(argv, cwd = process.cwd()) {
         if (status === undefined) {
             throw new Error(`task ${taskId} has no events in run ${runId} — unknown task or never dispatched`);
         }
+        // OBS-1022: a task-failed task whose preserved ref (or task branch) carries commits ahead of the
+        // integration base owns verified-able work; --recheck re-gates that tree with no worker. Any other
+        // verb on a failed task, or a recheck over nothing landed, is refused naming why.
+        if (status === "failed" && recheck) {
+            const ahead = failedTaskCommitsAhead(cwd, journal, runId, taskId);
+            if (ahead.count === 0) {
+                throw new Error(`task ${taskId} is failed and ${ahead.ref} carries no commits ahead of ${ahead.base} — nothing to re-gate; use resume --retry-failed to fund a worker`);
+            }
+            journal.append("task-approved", taskId, {
+                by, ...(reason ? { reason } : {}), via: "cli", release: RECHECK_RELEASE,
+                recheckedRef: ahead.ref, commitsAhead: ahead.count,
+                ...(reviewRoundCeiling === undefined ? {} : { reviewRoundCeiling }),
+            });
+            return disposition(cwd, runId, "re-dispatch", `re-checking failed ${taskId} in ${runId} — by ${by}; ${ahead.count} commit(s) on ${ahead.ref} ahead of ${ahead.base}; no worker funded`, serialization.contended);
+        }
         if (status !== "human") {
             // a silent no-op would be worse than a loud refusal — name the actual status (D-05)
             throw new Error(`task ${taskId} is ${status}, not a parked human gate — refusing (a silent no-op would be worse)`);
@@ -149,7 +169,7 @@ export async function approve(argv, cwd = process.cwd()) {
         const lastHuman = park === undefined ? undefined : events[park.index];
         const capPark = park?.kind === ATTEMPT_CAP_RELEASE;
         const gateFailPark = park?.kind === "gate-fail";
-        const infraPark = park?.kind === "infra";
+        const infraPark = park?.kind === "infra" || park?.kind === "diff-cap";
         const failedGate = gateFailPark ? park?.failedGate : undefined;
         if ((park?.kind === "scope-request" && !decisions) || files !== undefined) {
             if (park?.kind !== "scope-request")
@@ -158,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)) {
@@ -176,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);
@@ -205,7 +225,7 @@ export async function approve(argv, cwd = process.cwd()) {
         }
         if (recheck) {
             if ((!gateFailPark || !failedGate) && !infraPark) {
-                throw new Error(`--recheck applies to a gate-fail or infra park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
+                throw new Error(`--recheck applies to a gate-fail, infra or diff-cap park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
             }
             journal.append("task-approved", taskId, {
                 by,
@@ -214,7 +234,7 @@ export async function approve(argv, cwd = process.cwd()) {
                 release: RECHECK_RELEASE,
                 ...(reviewRoundCeiling === undefined ? {} : { reviewRoundCeiling }),
             });
-            return disposition(cwd, runId, "re-dispatch", `re-checking ${taskId} in ${runId} — by ${by}; ${failedGate ? `failed gate ${failedGate}` : "infra park"}; no gate marked satisfied`, serialization.contended);
+            return disposition(cwd, runId, "re-dispatch", `re-checking ${taskId} in ${runId} — by ${by}; ${failedGate ? `failed gate ${failedGate}` : `${park.kind} park`}; no gate marked satisfied`, serialization.contended);
         }
         if (waive) {
             if (!gateFailPark || !failedGate) {
@@ -242,6 +262,11 @@ export async function approve(argv, cwd = process.cwd()) {
         if (park?.tombstone) {
             throw new Error(`task ${taskId}'s newest park is a tombstone (${park.reason ?? "no reason"}) — permanent by design; no verb releases it`);
         }
+        // OBS-1007: a cap trip is re-gated under a raised cap, never re-bought — plain approve would fund a
+        // worker the production oracle (permittedDecisionVerbs) says this park cannot buy.
+        if (park?.kind === "diff-cap") {
+            throw new Error(`task ${taskId} is parked on a diff cap; plain approve would fund another worker — raise gates.diffCap and pass --recheck (disposition re-dispatch)`);
+        }
         journal.append("task-approved", taskId, {
             by,
             ...(reason ? { reason } : {}),
@@ -256,6 +281,42 @@ export async function approve(argv, cwd = process.cwd()) {
         serialization.release();
     }
 }
+/**
+ * OBS-1022: what a failed task has landed. A preserved snapshot is authoritative only when it contains
+ * the current task-branch tip; an older preservation can remain in the journal after a later retry has
+ * advanced/rebuilt the branch. Missing task branches may still recover from a preserved ref. The selected
+ * ref is counted against the run's integration branch; unreadable refs count as zero and fail closed.
+ */
+function failedTaskCommitsAhead(cwd, journal, runId, taskId) {
+    const cfg = loadConfig(cwd);
+    const base = integrationBranch(cfg, runId);
+    const taskRef = `${base}--${taskId}`;
+    const preserved = [...journal.read()].reverse().find((e) => e.taskId === taskId && e.event === "worktree-preserved" && typeof e.data.ref === "string");
+    const preservedRef = preserved?.data.ref;
+    let ref = taskRef;
+    if (preservedRef) {
+        try {
+            execFileSync("git", ["rev-parse", "--verify", taskRef], { cwd, stdio: "ignore" });
+            execFileSync("git", ["merge-base", "--is-ancestor", taskRef, preservedRef], { cwd, stdio: "ignore" });
+            ref = preservedRef;
+        }
+        catch {
+            try {
+                execFileSync("git", ["rev-parse", "--verify", taskRef], { cwd, stdio: "ignore" });
+            }
+            catch {
+                ref = preservedRef;
+            }
+        }
+    }
+    try {
+        const out = execFileSync("git", ["rev-list", "--count", `${base}..${ref}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return { ref, base, count: Number.parseInt(out.trim(), 10) || 0 };
+    }
+    catch {
+        return { ref, base, count: 0 };
+    }
+}
 // The status is command OUTPUT, not a typed sibling result: the registered approve function returns
 // one primitive string and the dispatcher prints those bytes unchanged. A compact sentinel followed
 // by JSON makes the contract unambiguous to machines without widening the shared command result type.

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

@@ -203,6 +203,11 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
         worker: "interactive" | "print";
         workersPerTab: number;
     };
+    executionPolicy?: {
+        boundedInfrastructure: boolean;
+        repairSelection: boolean;
+        taskExecutionLimitMs: number;
+    } | undefined;
     setup?: string | undefined;
     cost?: {
         models?: Record<string, {
@@ -322,6 +327,11 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
         worker: "interactive" | "print";
         workersPerTab: number;
     };
+    executionPolicy?: {
+        boundedInfrastructure: boolean;
+        repairSelection: boolean;
+        taskExecutionLimitMs: number;
+    } | undefined;
     setup?: string | undefined;
     cost?: {
         models?: Record<string, {

package/dist/cli/commands/fleet.js

@@ -324,6 +324,8 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         ...structuredClone(initial),
         denyAdapters: deny.adapters,
         denyModels: deny.models,
+        // OBS-1046: the allow complement is staged beside the deny lists, never folded into them
+        allowOut: deny.allowOut ?? initial.allowOut,
         denyWorkersAdapters: deny.workersAdapters,
         denyWorkersModels: deny.workersModels,
         map,
@@ -644,6 +646,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         const staged = structuredClone(initial);
         staged.denyAdapters = state.denyAdapters;
         staged.denyModels = state.denyModels;
+        staged.allowOut = state.allowOut ?? initial.allowOut;
         // OBS-994/FL-1: the workers-only deny scope rides the same review/write funnel as the flat one.
         staged.denyWorkersAdapters = state.denyWorkersAdapters;
         staged.denyWorkersModels = state.denyWorkersModels;
@@ -699,6 +702,7 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         health,
         initialDenyAdapters: editable.denyAdapters,
         initialDenyModels: editable.denyModels,
+        initialAllowOut: editable.allowOut,
         initialDenyWorkersAdapters: editable.denyWorkersAdapters,
         initialDenyWorkersModels: editable.denyWorkersModels,
         modelGroups,

package/dist/cli/commands/plan.js

@@ -7,7 +7,7 @@ import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
-import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
+import { chainDepth, dispatchWaves, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -364,11 +364,27 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             : "";
         return { line: `${channelKey(reviewer)}${rotationNote} — reviewPolicy full`, cost: seatCost(reviewer) };
     };
+    // OBS-1018: depth and wave come from the same functions the daemon admits by, so the plan shows the
+    // critical path the run will actually follow at this concurrency.
+    const depths = chainDepth(g);
+    const waves = dispatchWaves(g, cfg.concurrency);
+    const byId = new Map(g.tasks.map((t) => [t.id, t]));
+    const chainLine = (t) => {
+        const wave = waves.get(t.id);
+        // Map absence never implies status: a pending task stays wave-less when a dependency is
+        // running/gated/failed/human, so render the real status and name the blocking deps.
+        const tail = wave !== undefined
+            ? `wave ${wave} at concurrency ${cfg.concurrency}`
+            : t.status !== "pending"
+                ? `no wave (${t.status})`
+                : `no wave (pending; blocked by ${t.deps.filter((d) => byId.get(d)?.status !== "done").map((d) => `${d}:${byId.get(d)?.status ?? "missing"}`).join(", ")})`;
+        return `    chain: depth ${depths.get(t.id)} · ${tail}`;
+    };
     const routed = [];
     for (const t of g.tasks) {
         const refusals = [...(oracleRefusals.get(t.id) ?? []), ...(inputRefusals.get(t.id) ?? [])];
         if (refusals.length) {
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! pre-dispatch refusal — ${refusals.join("; ")}`);
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! pre-dispatch refusal — ${refusals.join("; ")}`, chainLine(t));
             continue;
         }
         try {
@@ -382,7 +398,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             const judge = judgeSeat(t);
             const review = reviewSeat(t, r.assignment);
             cost += est + judge.cost + review.cost;
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`, `    judge: ${judge.line}${judge.cost ? ` ~$${judge.cost.toFixed(2)}` : ""}`, `    review: ${review.line}${review.cost ? ` ~$${review.cost.toFixed(2)}` : ""}`);
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`, `    judge: ${judge.line}${judge.cost ? ` ~$${judge.cost.toFixed(2)}` : ""}`, `    review: ${review.line}${review.cost ? ` ~$${review.cost.toFixed(2)}` : ""}`, chainLine(t));
             const d = derivation(t.shape);
             if (d)
                 lines.push(d);
@@ -406,7 +422,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             if (!(e instanceof RoutingError))
                 throw e;
             const msg = `${e.message}${exclusionReason(e.message)}`;
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! ${msg}`);
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! ${msg}`, chainLine(t));
             const d = derivation(t.shape);
             if (d)
                 lines.push(d);

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`,