tickmarkr 2.6.1 → 2.6.3

package/dist/run/wall-budget.js

@@ -0,0 +1,280 @@
+import { gateDeclined } from "../report/bundle.js";
+/**
+ * OBS-1201: where a run's wall time went. Every instant of the engagement window lands in exactly ONE
+ * bucket — the first of WALL_PRIORITY with a span covering it — and what no span covers is residual,
+ * so the exposed buckets always sum to the wall. Task-time sums every span as recorded, so concurrent
+ * work (two workers, four suites waiting on one lease) stays visible without inflating the wall.
+ *
+ * Only journaled observations become spans: a fresh gate row's measured duration less the matched
+ * suite waits inside it, a worker launch matched to its result, a suite wait matched to its admission,
+ * and the gap a restart left between one engagement's last row and the next run-resume. A copy of
+ * evidence — a cache reuse, a journal replay, a row naming an invocation already counted — never adds
+ * a span; a reused full suite's row still times the fresh screen it carries. A row without a duration, a launch, wait or gate start with no matching end, and one cut by
+ * a restart are counted, never timed. Residual
+ * is unattributed time, not a claim of idleness. Pure: journal rows in, numbers out.
+ */
+export const WALL_PRIORITY = ["interruption", "test", "semantics", "worker", "queue", "other-gate"];
+const perBucket = () => Object.fromEntries(WALL_PRIORITY.map((bucket) => [bucket, 0]));
+const at = (e) => Date.parse(e.ts);
+const measured = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+const bucketOf = (gate) => gate === "test" ? "test" : gate === "acceptance" || gate === "review" ? "semantics" : "other-gate";
+// Rows another process writes around a restart — the operator's approval, the resuming daemon's
+// reclaim and rehash audit — so the prior engagement's own last row is the one before them.
+// ponytail: a closed list; a new out-of-engagement writer lengthens the interruption it precedes.
+const OUTSIDE_ENGAGEMENT = new Set(["task-approved", "graph-rehash", "lock-reclaimed", "superseded"]);
+const outsideEngagement = (e) => OUTSIDE_ENGAGEMENT.has(e.event) || (e.event === "exit-cause" && e.data.cause === "unclean");
+const WORKER_END = new Set(["worker-result", "worker-dead", "worker-hard-timeout"]);
+const invocationOf = (data) => {
+    if (typeof data.nonce === "string")
+        return data.nonce;
+    const receipt = data.evidenceReceipt;
+    return typeof receipt?.invocationId === "string" ? receipt.invocationId : undefined;
+};
+/** Undefined when the journal names no measurable window (no run-start, or unreadable timestamps). */
+export function wallBudget(events) {
+    const first = events.findIndex((e) => e.event === "run-start");
+    if (first < 0)
+        return undefined;
+    const lastOf = (event) => events.map((e) => e.event).lastIndexOf(event);
+    const lastEnd = lastOf("run-end");
+    const lastResume = lastOf("run-resume");
+    const from = at(events[first]);
+    // A closed engagement ends at its run-end; an open or crashed one at its newest row.
+    const to = at(events[lastEnd > lastResume ? lastEnd : events.length - 1]);
+    if (!Number.isFinite(from) || !Number.isFinite(to) || to < from)
+        return undefined;
+    const spans = [];
+    const span = (bucket, a, b) => {
+        const s = Math.max(a, from);
+        const t = Math.min(b, to);
+        if (Number.isFinite(s) && Number.isFinite(t) && t > s)
+            spans.push({ bucket, from: s, to: t });
+    };
+    const evidence = { fresh: 0, replay: 0, reuse: 0, unknown: 0 };
+    const untimed = Object.fromEntries(WALL_PRIORITY.map((bucket) => [bucket, { unknown: 0, unmatched: 0, interrupted: 0 }]));
+    const counted = new Set();
+    // A gate row is journaled when its whole round settles (acceptance, review and test often share one
+    // timestamp), so its measured duration is anchored at the gate's FIRST phase-start in the round.
+    const gateStarts = new Map();
+    const workers = new Map();
+    // A dispatch that never journals a launch (every pre-launch-row journal) ran a worker nobody timed.
+    const dispatched = new Set();
+    // A wait is owned by the gate whose command was admitted (the daemon names it when the phase is
+    // unambiguous; a parallel sibling leaves it absent). Its measurement started before admission, so
+    // a matched wait inside that gate's own span is queue, not service, and is cut out before priority
+    // applies. Sibling gates keep executing through it, so nothing is cut from them. A wait naming no
+    // gate belongs to the suite lease, which is the test gate's.
+    const owner = (task, gate) => `${task}\0${typeof gate === "string" ? gate : "test"}`;
+    const waits = new Map();
+    const queued = new Map();
+    const admit = (task, gate, ts) => {
+        const key = owner(task, gate);
+        const opened = waits.get(key);
+        if (opened === undefined)
+            return;
+        span("queue", opened, ts);
+        // One open wait per owner, closed in journal order: the list stays sorted and non-overlapping.
+        queued.set(key, [...(queued.get(key) ?? []), [opened, ts]]);
+        waits.delete(key);
+    };
+    const service = (gate, task, a, b) => {
+        const bucket = bucketOf(gate);
+        // One linear sweep over the sorted waits; span() drops any empty or inverted piece.
+        let cursor = a;
+        for (const [ws, we] of queued.get(owner(task, gate)) ?? []) {
+            if (we <= cursor || ws >= b)
+                continue;
+            span(bucket, cursor, ws);
+            cursor = Math.max(cursor, we);
+        }
+        span(bucket, cursor, b);
+    };
+    // A gate that started and never journaled its result is evidence without timing, never a zero.
+    const untimedStarts = (starts, kind) => {
+        for (const gate of starts?.keys() ?? [])
+            untimed[bucketOf(gate)][kind]++;
+    };
+    for (let i = first + 1; i < events.length; i++) {
+        const e = events[i];
+        const task = e.taskId ?? "";
+        const ts = at(e);
+        switch (e.event) {
+            case "run-resume": {
+                let last = i - 1;
+                while (last > first && outsideEngagement(events[last]))
+                    last--;
+                span("interruption", at(events[last]), ts);
+                untimed.worker.interrupted += workers.size;
+                untimed.worker.unknown += dispatched.size;
+                untimed.queue.interrupted += waits.size;
+                for (const starts of gateStarts.values())
+                    untimedStarts(starts, "interrupted");
+                workers.clear();
+                dispatched.clear();
+                waits.clear();
+                gateStarts.clear();
+                break;
+            }
+            case "phase-start": {
+                if (e.data.phase === "gates") {
+                    untimedStarts(gateStarts.get(task), "unmatched");
+                    gateStarts.delete(task);
+                }
+                else if (typeof e.data.gate === "string") {
+                    const starts = gateStarts.get(task) ?? new Map();
+                    if (!starts.has(e.data.gate))
+                        starts.set(e.data.gate, ts);
+                    gateStarts.set(task, starts);
+                }
+                if (e.data.admitted === true)
+                    admit(task, e.data.gate, ts);
+                break;
+            }
+            case "suite-admitted":
+                admit(task, undefined, ts);
+                break;
+            case "suite-wait":
+                // Repeated rows while a wait is open re-report its count; they do not open a second wait.
+                if (!waits.has(owner(task, e.data.gate)))
+                    waits.set(owner(task, e.data.gate), ts);
+                break;
+            case "task-dispatch":
+                if (dispatched.has(task))
+                    untimed.worker.unknown++;
+                dispatched.add(task);
+                break;
+            case "worker-launch":
+                if (workers.has(task))
+                    untimed.worker.unmatched++;
+                workers.set(task, ts);
+                dispatched.delete(task);
+                break;
+            case "gate-provisioned":
+                if (measured(e.data.durationMs))
+                    service(typeof e.data.gate === "string" ? e.data.gate : "build", task, ts - e.data.durationMs, ts);
+                break;
+            case "gate-result": {
+                const gate = e.data.gate;
+                if (typeof gate !== "string")
+                    break;
+                const anchor = gateStarts.get(task)?.get(gate);
+                gateStarts.get(task)?.delete(gate);
+                if (gateDeclined(e.data))
+                    break;
+                const bucket = bucketOf(gate);
+                const invocation = invocationOf(e.data);
+                const identity = invocation === undefined ? undefined : `${gate}\0${invocation}`;
+                if (e.data.reused === true) {
+                    evidence.reuse++;
+                    // A held screen runs fresh before its full suite is carried from the cache, and the one
+                    // merge-candidate row holds both: the screen's measured interval is fresh execution, the
+                    // carried suite adds none. A replay's copy is not a measurement of this attempt.
+                    const screen = e.data.fullSuite === true && e.data.replayedFromAttempt === undefined ? e.data.selectedDurationMs : undefined;
+                    if (!measured(screen) || screen <= 0)
+                        break;
+                    evidence.fresh++;
+                    const screenFrom = anchor ?? ts - screen;
+                    service(gate, task, screenFrom, Math.min(screenFrom + screen, ts));
+                    break;
+                }
+                if (e.data.replayedFromAttempt !== undefined || (identity !== undefined && counted.has(identity))) {
+                    evidence.replay++;
+                    break;
+                }
+                if (identity !== undefined)
+                    counted.add(identity);
+                const d = e.data.durationMs;
+                if (!measured(d)) {
+                    evidence.unknown++;
+                    untimed[bucket].unknown++;
+                    break;
+                }
+                evidence.fresh++;
+                const full = e.data.fullSuite === true && measured(e.data.fullDurationMs) && measured(e.data.selectedDurationMs);
+                if (anchor === undefined)
+                    service(gate, task, ts - d, ts);
+                else if (full) {
+                    // The full suite ends at the row; the selected run began at the gate's first phase-start.
+                    const fullFrom = ts - e.data.fullDurationMs;
+                    service(gate, task, anchor, Math.min(anchor + e.data.selectedDurationMs, fullFrom));
+                    service(gate, task, fullFrom, ts);
+                }
+                else
+                    service(gate, task, anchor, Math.min(anchor + d, ts));
+                break;
+            }
+            default:
+                if (WORKER_END.has(e.event) && workers.has(task)) {
+                    span("worker", workers.get(task), ts);
+                    workers.delete(task);
+                }
+        }
+    }
+    untimed.worker.unmatched += workers.size;
+    untimed.worker.unknown += dispatched.size;
+    untimed.queue.unmatched += waits.size;
+    for (const starts of gateStarts.values())
+        untimedStarts(starts, "unmatched");
+    const taskMs = perBucket();
+    for (const s of spans)
+        taskMs[s.bucket] += s.to - s.from;
+    // One sweep over span edges: each segment goes to the highest-priority bucket still open over it.
+    const rank = (bucket) => WALL_PRIORITY.indexOf(bucket);
+    const edges = spans.flatMap((s) => [[s.from, rank(s.bucket), 1], [s.to, rank(s.bucket), -1]])
+        .sort((a, b) => a[0] - b[0]);
+    const open = WALL_PRIORITY.map(() => 0);
+    const exposedMs = perBucket();
+    let cursor = from;
+    for (const [t, r, delta] of edges) {
+        if (t > cursor) {
+            const top = open.findIndex((n) => n > 0);
+            if (top >= 0)
+                exposedMs[WALL_PRIORITY[top]] += t - cursor;
+            cursor = t;
+        }
+        open[r] += delta;
+    }
+    const wallMs = to - from;
+    const residualMs = wallMs - WALL_PRIORITY.reduce((sum, bucket) => sum + exposedMs[bucket], 0);
+    return { wallMs, exposedMs, residualMs, taskMs, evidence, untimed };
+}
+/** Whole seconds past a minute, one decimal below ten seconds — never a rounded-away "0s" for a real span. */
+export const formatSpan = (ms) => {
+    if (ms > 0 && ms < 10_000)
+        return `${(Math.ceil(ms / 100) / 10).toString()}s`;
+    const s = Math.round(ms / 1_000);
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3_600)
+        return `${Math.floor(s / 60)}m ${s % 60}s`;
+    return `${Math.floor(s / 3_600)}h ${Math.floor((s % 3_600) / 60)}m`;
+};
+const plural = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+/**
+ * One fact per bucket, then residual and the evidence tally — the words every surface prints. A
+ * bucket whose only evidence is untimed reads `unknown`, never a zero it did not measure.
+ */
+export function wallBudgetFacts(b) {
+    const pct = (ms) => b.wallMs > 0 ? ` (${Math.round((100 * ms) / b.wallMs)}%)` : "";
+    const facts = WALL_PRIORITY.map((bucket) => {
+        const { unknown, unmatched, interrupted } = b.untimed[bucket];
+        const notes = [
+            ...(unknown ? [bucket === "worker"
+                    ? `${unknown} ${unknown === 1 ? "dispatch" : "dispatches"} without a launch row`
+                    : `${plural(unknown, "row")} without a duration`] : []),
+            ...(unmatched ? [`${unmatched} unmatched`] : []),
+            ...(interrupted ? [`${interrupted} cut by a restart`] : []),
+        ];
+        if (!b.exposedMs[bucket] && !b.taskMs[bucket] && notes.length)
+            return [bucket, `unknown — ${notes.join(" · ")}`];
+        const timed = `${formatSpan(b.exposedMs[bucket])}${pct(b.exposedMs[bucket])} · task-time ${formatSpan(b.taskMs[bucket])}`;
+        return [bucket, [timed, ...notes.map((note) => `${note}, untimed`)].join(" · ")];
+    });
+    const { fresh, replay, reuse, unknown } = b.evidence;
+    return [
+        ...facts,
+        ["residual", `${formatSpan(b.residualMs)}${pct(b.residualMs)} — unattributed, not proven idle`],
+        ["gate evidence", `fresh ${fresh} · replay ${replay} · reuse ${reuse} · unknown ${unknown}`],
+    ];
+}
+export const WALL_PRIORITY_TEXT = [...WALL_PRIORITY, "residual"].join(" › ");

package/dist/tui/cockpit/board.js

@@ -47,9 +47,9 @@ const AREAS = [
     ["FLEET", [/^src\/(route|config|adapters)\//]],
     ["RUN", [/^src\/(run|drivers|eval)\//]],
     ["GATE", [/^src\/gates\//]],
-    ["UI", [/^src\/(cli|tui|report)\//, /^src\/brand\.ts/]],
-    ["DOCS", [/^(docs|skills)\//]],
-    ["REPO", [/^(scripts|schema)\//, /^\.github\//, /^tests\/(lint|repo|helpers)\//, /^(vitest\.config|package\.json|tsconfig)/]],
+    ["UI", [/^src\/(cli|tui|report)\//, /^src\/brand\.ts/, /^tests\/cockpit\//]],
+    ["DOCS", [/^(docs|skills)\//, /^\.claude\/skills\//]],
+    ["REPO", [/^(scripts|schema)\//, /^\.github\//, /^tests\/(lint|repo|helpers|fixtures)\//, /^(vitest\.config|package\.json|tsconfig)/]],
 ];
 export const BOARD_AREA_ORDER = AREAS.map(([n]) => n);
 const expandBraces = (p) => {

package/dist/tui/cockpit/decision-actions.d.ts

@@ -25,6 +25,10 @@ export interface DecisionCommand {
     readonly reason?: string;
     /** `--review-rounds`: the review-round ceiling the release carries. */
     readonly reviewRounds?: number;
+    /** OBS-1178: `--park <line>@<ts>` — the displayed park this decision binds to. */
+    readonly park?: string;
+    /** OBS-1178: `--gate <gate>` — the failed gate a waive binds to. */
+    readonly gate?: string;
 }
 /** The exact argv the production command receives — built only from the closed verb set. */
 export declare function decisionArgv(command: DecisionCommand, { runId, by }: {
@@ -57,13 +61,11 @@ export declare const journalFileFor: (cwd: string, runId: string) => string;
  * the named verb is outside the park's table, so a confirm inset can never promise a decision the
  * command would refuse. The enactor is read from the run lock now, and read again at the receipt.
  */
-export declare function previewDecision(command: DecisionCommand, { cwd, runId, by }: {
+export declare function previewDecision(named: DecisionCommand, { cwd, runId, by }: {
     cwd: string;
     runId: string;
     by: string;
 }): DecisionPreviewResult;
-/** Who enacts it — the three lock states, each stated by the command's own sentence. */
-export declare function enactmentLines(run: ApprovalRunOwner, disposition: ApprovalDisposition): string[];
 /** The confirm inset: run/task, the newest park line, actor/reason, exact argv, consequence, enactor. */
 export declare function decisionConfirmLines(preview: DecisionPreview): readonly string[];
 /** The task-approved row the file gained, located by its physical line. */
@@ -135,8 +137,7 @@ export interface DecisionKeyResult {
 /**
  * The reducer never writes and never reads a file; it names commands. `a` opens the menu for the
  * selected park (a diagnostic park opens a menu with no verbs, stating why); ↑↓ move; Enter picks a
- * verb — which OPENS the confirm inset, never confirms; `y` on a confirm names the write; `n`/Esc
- * cancel the deepest layer. Enter on a confirm is inert by construction.
+ * verb opens the confirm inset; `y` names the write; `n`/Esc cancel the deepest layer. Enter on a confirm is inert.
  */
 export declare function applyDecisionKey(session: DecisionSession, event: DecisionKeyEvent, selected: RunDecision | undefined): DecisionKeyResult;
 /** Store the preview a picked verb produced — or its refusal as the notice. */
@@ -145,3 +146,5 @@ export declare function withDecisionPreview(session: DecisionSession, result: De
 export declare function withDecisionReceipt(session: DecisionSession, receipt: DecisionReceipt): DecisionSession;
 /** The verbs the keybar may advertise for the current layer — nothing the flow cannot honour. */
 export declare function decisionKeybar(session: DecisionSession, selected: RunDecision | undefined): string;
+/** Who enacts it — the three lock states, each stated by the command's own sentence. */
+export declare function enactmentLines(run: ApprovalRunOwner, disposition: ApprovalDisposition): string[];

package/dist/tui/cockpit/decision-actions.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { APPROVAL_ENACTS, approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, DECISION_VERBS, newestPark, permittedDecisionVerbs, readJournalEvents, releaseForDecision, } from "../../cli/commands/approve.js";
+import { APPROVAL_ENACTS, approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, DECISION_VERBS, newestPark, parkToken, permittedDecisionVerbs, readJournalEvents, releaseForDecision, } from "../../cli/commands/approve.js";
 import { stateDirName } from "../../graph/graph.js";
-import { Journal } from "../../run/journal.js";
+import { bindingToken, effectiveDecisions, Journal, physicalLine, recordedBinding } from "../../run/journal.js";
 const parkDiagnostic = (park) => {
     if (park.kind === "scope-request")
         return park.approveCommand ?? "scope-request requires tickmarkr approve with --files <glob,…>";
@@ -50,6 +50,8 @@ export function decisionArgv(command, { runId, by }) {
     const flag = { approve: [], waive: ["--waive"], uphold: ["--uphold"], recheck: ["--recheck"] }[command.verb];
     return [
         runId, command.taskId, ...flag,
+        ...(command.park === undefined ? [] : ["--park", command.park]),
+        ...(command.gate === undefined ? [] : ["--gate", command.gate]),
         ...(command.reviewRounds === undefined ? [] : ["--review-rounds", String(command.reviewRounds)]),
         "--by", by,
         ...(command.reason === undefined ? [] : ["--reason", command.reason]),
@@ -62,10 +64,9 @@ export const journalFileFor = (cwd, runId) => join(stateDirName(cwd), "runs", ru
  * the named verb is outside the park's table, so a confirm inset can never promise a decision the
  * command would refuse. The enactor is read from the run lock now, and read again at the receipt.
  */
-export function previewDecision(command, { cwd, runId, by }) {
-    let argv;
+export function previewDecision(named, { cwd, runId, by }) {
     try {
-        argv = decisionArgv(command, { runId, by });
+        decisionArgv(named, { runId, by });
     }
     catch (e) {
         return { ok: false, refusal: e.message };
@@ -78,15 +79,29 @@ export function previewDecision(command, { cwd, runId, by }) {
     catch (e) {
         return { ok: false, refusal: e.message };
     }
-    const park = newestPark(events, command.taskId, sourceIndexes);
+    const park = newestPark(events, named.taskId, sourceIndexes);
     if (!park)
-        return { ok: false, refusal: `task ${command.taskId} has no park in run ${runId} — nothing to decide` };
+        return { ok: false, refusal: `task ${named.taskId} has no park in run ${runId} — nothing to decide` };
+    // OBS-1178: the argv binds the park this preview displays; approve refuses it once another opens.
+    const token = parkToken(park);
+    if (named.park !== undefined && named.park !== token)
+        return { ok: false, refusal: `task ${named.taskId}'s open park is ${token ?? "untimestamped"}, not ${named.park} — refresh and decide the open park` };
+    if (named.gate !== undefined && named.gate !== park.failedGate)
+        return { ok: false, refusal: `refusing mismatched gate for ${named.taskId}: --gate ${named.gate} but park ${token} failed ${park.failedGate ?? "no gate"} — nothing appended` };
+    const command = { ...named, ...(token === undefined ? {} : { park: token }), ...(named.verb === "waive" && named.gate === undefined && park.failedGate !== undefined ? { gate: park.failedGate } : {}) };
+    let argv;
+    try {
+        argv = decisionArgv(command, { runId, by });
+    }
+    catch (e) {
+        return { ok: false, refusal: e.message };
+    }
     const verbs = permittedDecisionVerbs(park);
     if (!verbs.includes(command.verb)) {
         const why = parkDiagnostic(park) ?? `permitted: ${verbs.join(", ")}`;
         return { ok: false, refusal: `${command.verb} is not a decision for ${command.taskId}'s ${park.kind ?? "unknown"} park (${why})` };
     }
-    const released = events.slice(park.index + 1).find((e) => e.event === "task-approved" && e.taskId === command.taskId);
+    const released = releaseSince(events, park.index, command.taskId);
     if (released) {
         return { ok: false, refusal: `task ${command.taskId} was already released at #L${sourceIndexes[events.indexOf(released)] + 1} by ${String(released.data.by ?? "unknown")} — nothing to confirm` };
     }
@@ -100,28 +115,12 @@ export function previewDecision(command, { cwd, runId, by }) {
     };
 }
 const parkLine = (park) => `#L${park.line} ${park.kind ?? "unknown kind"}${park.failedGate ? ` · failed gate ${park.failedGate}` : ""}${park.reason ? ` · ${park.reason}` : ""}`;
-const quoteArg = (arg) => (/^[\w.:/@=-]+$/u.test(arg) ? arg : JSON.stringify(arg));
-/** What a confirmed write buys, from the command's own table — never a phrase of this file's own. */
-function consequenceLines(verb, park, release, disposition) {
-    const lines = [`consequence  disposition ${disposition}; appends one task-approved${release ? ` with release ${release}` : " with no release"}`];
-    if (verb === "waive")
-        lines.push(`             marks gate ${park.failedGate} satisfied; it does NOT mark the task done`);
-    if (verb === "recheck")
-        lines.push("             marks no gate satisfied; the whole declared battery re-runs");
-    if (verb === "uphold")
-        lines.push("             sides with the reviewer; funds one fixed attempt carrying the findings");
-    lines.push(`             it will ${APPROVAL_ENACTS[disposition]}`);
-    return lines;
-}
-/** Who enacts it — the three lock states, each stated by the command's own sentence. */
-export function enactmentLines(run, disposition) {
-    const owner = run.live
-        ? "enactment    matching live daemon — pending daemon enactment at its next task boundary"
-        : run.blockingRunId
-            ? `enactment    other live run \`${run.blockingRunId}\` holds the repository lock — recorded, not dispatched`
-            : `enactment    no live owner — recorded, not dispatched; resume required: tickmarkr resume ${run.runId}`;
-    return [owner, `             ${approvalEnactment(disposition, run)}`];
+/** The decision already open on this park, if any. OBS-1178: a refused or unsound row released nothing. */
+function releaseSince(events, parkIndex, taskId) {
+    const effective = effectiveDecisions(events);
+    return events.find((e, i) => i > parkIndex && e.event === "task-approved" && e.taskId === taskId && effective.has(physicalLine(events, i)));
 }
+const quoteArg = (arg) => (/^[\w.:/@=-]+$/u.test(arg) ? arg : JSON.stringify(arg));
 /** The confirm inset: run/task, the newest park line, actor/reason, exact argv, consequence, enactor. */
 export function decisionConfirmLines(preview) {
     return [
@@ -157,7 +156,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
     if (!park || park.index !== preview.park.index || park.line !== preview.park.line || park.kind !== preview.park.kind) {
         return { ok: false, preview, stale: true, refusal: `task ${named.taskId}'s park changed since preview (${park ? `now #L${park.line} ${park.kind ?? "unknown"}` : "no park now"}) — refresh and preview again` };
     }
-    const released = before.slice(park.index + 1).find((e) => e.event === "task-approved" && e.taskId === named.taskId);
+    const released = releaseSince(before, park.index, named.taskId);
     if (released) {
         return { ok: false, preview, stale: true, refusal: `task ${named.taskId} was released at #L${beforeSourceIndexes[before.indexOf(released)] + 1} by ${String(released.data.by ?? "unknown")} after this preview — no second decision appended; refresh` };
     }
@@ -208,6 +207,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
         via: "cli",
         gate: named.verb === "waive" ? park.failedGate : named.verb === "uphold" ? "review" : undefined,
         reviewRoundCeiling: named.reviewRounds,
+        park: parkToken(park),
     };
     const actual = {
         release,
@@ -216,6 +216,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
         via: appended.event.data.via,
         gate: appended.event.data.gate,
         reviewRoundCeiling: appended.event.data.reviewRoundCeiling,
+        park: recordedBinding(appended.event.data.park) === undefined ? undefined : bindingToken(recordedBinding(appended.event.data.park)),
     };
     const mismatch = Object.keys(expected)
         .find((field) => actual[field] !== expected[field]);
@@ -264,8 +265,7 @@ export const initialDecisionSession = () => ({ menu: null, confirming: null, rec
 /**
  * The reducer never writes and never reads a file; it names commands. `a` opens the menu for the
  * selected park (a diagnostic park opens a menu with no verbs, stating why); ↑↓ move; Enter picks a
- * verb — which OPENS the confirm inset, never confirms; `y` on a confirm names the write; `n`/Esc
- * cancel the deepest layer. Enter on a confirm is inert by construction.
+ * verb opens the confirm inset; `y` names the write; `n`/Esc cancel the deepest layer. Enter on a confirm is inert.
  */
 export function applyDecisionKey(session, event, selected) {
     if (session.confirming !== null) {
@@ -315,3 +315,26 @@ export function decisionKeybar(session, selected) {
         return session.menu.verbs.length === 0 ? "Esc Close" : "↑↓ Choose · Enter Preview · Esc Close";
     return selected === undefined ? "" : "a Actions";
 }
+// Consequence and enactor lines, shared by the confirm inset and the receipt above. Kept below the key
+// grammar so the operator walkthrough's line citations stay put.
+/** What a confirmed write buys, from the command's own table — never a phrase of this file's own. */
+function consequenceLines(verb, park, release, disposition) {
+    const lines = [`consequence  disposition ${disposition}; appends one task-approved${release ? ` with release ${release}` : " with no release"}`];
+    if (verb === "waive")
+        lines.push(`             marks gate ${park.failedGate} satisfied; it does NOT mark the task done`);
+    if (verb === "recheck")
+        lines.push("             marks no gate satisfied; the whole declared battery re-runs");
+    if (verb === "uphold")
+        lines.push("             sides with the reviewer; funds one fixed attempt carrying the findings");
+    lines.push(`             it will ${APPROVAL_ENACTS[disposition]}`);
+    return lines;
+}
+/** Who enacts it — the three lock states, each stated by the command's own sentence. */
+export function enactmentLines(run, disposition) {
+    const owner = run.live
+        ? "enactment    matching live daemon — pending daemon enactment at its next task boundary"
+        : run.blockingRunId
+            ? `enactment    other live run \`${run.blockingRunId}\` holds the repository lock — recorded, not dispatched`
+            : `enactment    no live owner — recorded, not dispatched; resume required: tickmarkr resume ${run.runId}`;
+    return [owner, `             ${approvalEnactment(disposition, run)}`];
+}

package/dist/tui/cockpit/derive.js

@@ -5,6 +5,7 @@ import { channelKey } from "../../adapters/types.js";
 import { newestPark, permittedDecisionVerbs } from "../../cli/commands/approve.js";
 import { parseOwnedName } from "../../drivers/types.js";
 import { projectActivity } from "../../run/activity.js";
+import { effectiveDecisions, withPhysicalLine } from "../../run/journal.js";
 import { isPidLive } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { projectOperatorSummary } from "../../run/operator-summary.js";
@@ -79,6 +80,15 @@ function parseSource(raw) {
     }
     return { events, defects };
 }
+/**
+ * OBS-1178: the rows the task-state folds read. A refused or unsound decision released nothing, so its
+ * task-approved row is dropped here; the one decision fold keys every row by its physical line. The
+ * journal rows the cockpit draws keep every line as evidence.
+ */
+function decidedEvents(events) {
+    const effective = effectiveDecisions(events.map((event) => withPhysicalLine(event, event.line)));
+    return events.filter((event) => event.event !== "task-approved" || effective.has(event.line));
+}
 function assignmentFrom(value) {
     const assignment = recordValue(value);
     return assignment
@@ -844,7 +854,8 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
         // alive in the lock — the cockpit called a live run interrupted.
         : pid !== undefined && (options.isDaemonAlive ?? isPidLive)(pid);
     const interrupted = !alive;
-    const tasks = deriveTasks(events, interrupted);
+    const decided = decidedEvents(events);
+    const tasks = deriveTasks(decided, interrupted);
     const taskFacts = [...tasks.values()];
     const done = taskFacts.filter((task) => task.state === "done").length;
     const failed = taskFacts.filter((task) => task.state === "failed").length;
@@ -873,7 +884,7 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
     // run-end — the run's own closing statement is enough.
     const runStatus = failed > 0
         ? "failed"
-        : human > 0 || unresolvedSummaryParks(events).length > 0
+        : human > 0 || unresolvedSummaryParks(decided).length > 0
             ? "parked"
             : lifecycle === "superseded" || hasInterruptedTask
                 ? "interrupted"

package/dist/tui/cockpit/live-runtime.d.ts

@@ -46,5 +46,15 @@ export interface ConsolidatedOptions {
     environment?: NodeJS.ProcessEnv;
     diagnostics?: readonly HomeNeedsYouTarget[];
 }
+/**
+ * OBS-1178: the store's incremental fold reads every task-approved row as a release. A refused or unsound
+ * decision released nothing, so whenever the rows the store has read hold one — whatever state the raw
+ * fold shows now, since a later run-end restores a park but not the gate evidence a rejected recheck
+ * cleared — the operator snapshot is refolded over the decided rows, each keeping its physical line and
+ * the store's evidence identity.
+ * ponytail: a whole-journal read per observed journal change (parsed only when it holds an approval);
+ * move the decision fold into OperatorStateFold if that ever measures slow.
+ */
+export declare function decidedLiveStore(store: LiveStore): LiveStore;
 /** The live entry mounts the dependency-owned leaves, using only C2 snapshots/history/page. */
 export declare function runConsolidatedCockpit(options: ConsolidatedOptions): Promise<void>;

package/dist/tui/cockpit/live-runtime.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { existsSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { renderMarkdownRecord } from "../../cli/commands/report.js";
 import { loadConfig } from "../../config/config.js";
@@ -20,9 +20,10 @@ import { createPointerReportReader, POINTER_TRACKING_ON, POINTER_TRACKING_OFF }
 import { deriveRunDecisions, previewDecision, executeDecision, withDecisionPreview, withDecisionReceipt, decisionConfirmLines } from "./decision-actions.js";
 import { approvalRunOwner } from "../../cli/commands/approve.js";
 import { GLYPHS } from "../../brand.js";
-import { Journal } from "../../run/journal.js";
+import { effectiveEvents, Journal, parseJournalText, physicalLine } from "../../run/journal.js";
 import { observeNamedRun, WATCH_OWNER_ENV } from "../../run/supervision.js";
 import { formatOwnedName } from "../../drivers/types.js";
+import { readOperatorState } from "../../run/operator-state.js";
 import { cellWidth, wrapCells } from "./width.js";
 import { resolveShellColourMode } from "./theme.js";
 let timelineUsers = 0;
@@ -58,6 +59,52 @@ export function borrowRuntimeTimeline() {
 }
 export const SHELL_TERMINAL_ENTER = "\x1b[?1049h\x1b[22;0t\x1b]0;tickmarkr cockpit\x07" + POINTER_TRACKING_ON;
 export const SHELL_TERMINAL_RESTORE = POINTER_TRACKING_OFF + "\x1b[23;0t\x1b[?25h\x1b[?1049l";
+/**
+ * OBS-1178: the store's incremental fold reads every task-approved row as a release. A refused or unsound
+ * decision released nothing, so whenever the rows the store has read hold one — whatever state the raw
+ * fold shows now, since a later run-end restores a park but not the gate evidence a rejected recheck
+ * cleared — the operator snapshot is refolded over the decided rows, each keeping its physical line and
+ * the store's evidence identity.
+ * ponytail: a whole-journal read per observed journal change (parsed only when it holds an approval);
+ * move the decision fold into OperatorStateFold if that ever measures slow.
+ */
+export function decidedLiveStore(store) {
+    let key;
+    let operator;
+    const decided = (snap) => {
+        const { journal, graph } = snap;
+        const observed = `${journal.source}:${journal.generation}:${journal.offset}:${graph.identity}:${graph.status}`;
+        if (observed !== key) {
+            key = observed;
+            operator = undefined;
+            let bytes;
+            try {
+                bytes = readFileSync(journal.source).subarray(0, journal.offset);
+            }
+            catch {
+                return snap;
+            }
+            if (bytes.includes("task-approved")) {
+                const rows = parseJournalText(bytes.subarray(0, bytes.lastIndexOf(10) + 1).toString("utf8"))
+                    .filter(e => e !== null && typeof e === "object" && typeof e.event === "string" && typeof e.data === "object" && e.data !== null);
+                const kept = effectiveEvents(rows);
+                if (kept.length !== rows.length) {
+                    const events = kept.map((event, i) => {
+                        const line = physicalLine(kept, i);
+                        return { source: journal.source, line, id: `${journal.source}#L${line}`, generation: journal.generation, event };
+                    });
+                    operator = readOperatorState({ events, graph: graph.status === "readable" ? graph.value : undefined,
+                        readable: journal.status === "readable" && journal.backlogBytes === 0 });
+                }
+            }
+        }
+        if (!operator)
+            return snap;
+        const { sequence, observedAt, graphAvailability } = snap.operator;
+        return { ...snap, operator: { ...operator, sequence, observedAt, graphAvailability } };
+    };
+    return { ...store, snapshot: () => decided(store.snapshot()), refresh: () => decided(store.refresh()) };
+}
 /** Preserve a policy-disabled gate from C2 even when C5's generic event
  * mapper calls an unpassed result unknown. Lead with the gate name so a long
  * task identity cannot clip the label that explains the disabled glyph. */
@@ -97,7 +144,7 @@ export async function runConsolidatedCockpit(options) {
             output.write(SHELL_TERMINAL_ENTER);
         }
         store = createLiveStore({ cwd, runId, now: options.now });
-        const source = store;
+        const source = decidedLiveStore(store);
         if (options.observeRun !== false)
             observation = observeNamedRun(cwd, runId, options.environment);
         // BD-1 (RULING-231-19 §2): the daemon-placed board carries the watch owner token and mounts

package/dist/tui/cockpit/run-cockpit.d.ts

@@ -34,6 +34,9 @@ export declare function deriveRunViewRows(data: RunCockpitData, viewId: RunViewI
  * task row — identity, phase, build evidence, blocker, next action — each unrecorded field saying so,
  * each recorded one citing the journal line it was read from, and the OBS-1048 stall marker when the
  * newest attempt's harvest is suspect. No attempt label is printed here: the ruler is the row's own.
+ * A task with no recorded dispatch folds identity, phase, and build into one missing-evidence clause
+ * (OBS-1104). A recorded blocker or next action — a pre-dispatch park, a dependency wait — stays,
+ * cited to the journal row that produced it.
  */
 export declare function taskProjectionText(row: TaskRow, journal?: readonly JournalRow[]): string;
 /**