tickmarkr 2.6.1 → 2.6.2

package/dist/run/merge.d.ts

@@ -1,5 +1,5 @@
 import type { TickmarkrConfig } from "../config/config.js";
-import { type Baseline, type GateEvidenceOptions, type FailureClassification } from "../gates/baseline.js";
+import { type Baseline, type BaselineProvenance, type GateEvidenceOptions, type FailureClassification } from "../gates/baseline.js";
 import type { GateEvidenceReceipt } from "./protocol.js";
 export interface TipVerifyResult {
     evidenceReceipt?: GateEvidenceReceipt;
@@ -21,6 +21,8 @@ export interface TipVerifyResult {
     spawnedCommand?: string;
     /** Q121s: nonzero exit whose failures are ALL baseline-recorded — forgiven exactly as the battery forgives. */
     forgiven?: boolean;
+    /** OBS-1123: the capture that recorded the forgiven fingerprints; absent for a legacy baseline that never said. */
+    baselineProvenance?: BaselineProvenance;
     /** D-131: carried from a persisted per-gate verdict — this cycle did NOT execute the command. */
     reused?: true;
     /**

package/dist/run/merge.js

@@ -225,6 +225,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
                 exitCode: hit.exitCode ?? 0,
                 fingerprints: hit.meta?.fingerprints ?? [],
                 ...(hit.meta?.forgiven ? { forgiven: true } : {}),
+                ...(hit.meta?.forgiven && hit.meta.baselineProvenance ? { baselineProvenance: hit.meta.baselineProvenance } : {}),
                 details: formatReusedDetails(hit.details, id),
                 ...(hit.meta?.reportPath ? { reportPath: hit.meta.reportPath } : {}),
                 ...(hit.meta?.spawnedCommand ? { spawnedCommand: hit.meta.spawnedCommand } : {}),
@@ -382,7 +383,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
                                 + `${describeCapacity(entry?.capacity)} and this verification ran under ${describeCapacity(r.capacity)} `
                                 + `— forgiveness across a changed capacity is not evidence`
                             : `exit ${r.code}`)),
-            ...(forgiven && !deficit ? { forgiven: true } : {}),
+            ...(forgiven && !deficit ? { forgiven: true, ...(baseline?.provenance ? { baselineProvenance: baseline.provenance } : {}) } : {}),
             ...(cause ? { cause } : {}),
             ...(pass ? {} : { artifact }),
         };
@@ -401,7 +402,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
         const id = pending.get(result.gate);
         if (id && id.tree === completedTree && !isInfraResult(result)) {
             store.set(id, { ...result, meta: {
-                    fingerprints: result.fingerprints, forgiven: result.forgiven,
+                    fingerprints: result.fingerprints, forgiven: result.forgiven, baselineProvenance: result.baselineProvenance,
                     reportPath: result.reportPath, spawnedCommand: result.spawnedCommand,
                     artifact: result.artifact,
                     evidenceReceipt: result.evidenceReceipt, evidenceReceipts: result.evidenceReceipts,

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

@@ -13,6 +13,9 @@ export interface OperatorDecisionSnapshot {
         readonly kind: string | undefined;
         readonly tombstone: boolean;
         readonly reason?: string;
+        /** OBS-1178: the park row's physical line and timestamp — the token a decision binds to. */
+        readonly line?: number;
+        readonly ts?: string;
     };
     readonly verbs: readonly string[];
     readonly diagnostic?: string;

package/dist/run/operator-summary.js

@@ -25,7 +25,9 @@ export function projectOperatorSummary(tasks, decisions) {
                 decisionRequired: verbs.length > 0,
                 ...(diagnostic !== undefined || park.reason !== undefined
                     ? { diagnostic: diagnostic ?? park.reason } : {}),
-                nextAction: verbs.length > 0 ? `Choose a decision: ${verbs.join(", ")}` : null,
+                nextAction: verbs.length > 0
+                    ? `Choose a decision: ${verbs.join(", ")}${park.line !== undefined && park.ts !== undefined ? ` (--park ${park.line}@${park.ts})` : ""}`
+                    : null,
             };
             if (!park.tombstone && park.kind === "infra" && task.missingCapability) {
                 const { capability, diagnostic: capabilityDiagnostic } = task.missingCapability;

package/dist/run/protocol.d.ts

@@ -66,10 +66,10 @@ export declare const GateEvidenceReceiptSchema: z.ZodObject<{
     termination: z.ZodObject<{
         kind: z.ZodEnum<{
             unknown: "unknown";
+            timeout: "timeout";
             signal: "signal";
             "not-started": "not-started";
             exit: "exit";
-            timeout: "timeout";
         }>;
         exitCode: z.ZodNullable<z.ZodNumber>;
         signal: z.ZodNullable<z.ZodString>;
@@ -222,6 +222,11 @@ export declare const RoleInvocationStartEventSchema: z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -240,6 +245,11 @@ export declare const RoleInvocationTerminalEventSchema: z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";
@@ -352,6 +362,11 @@ export declare const DecisionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
@@ -369,6 +384,11 @@ export declare const DecisionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";
@@ -473,6 +493,11 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
     event: z.ZodLiteral<"role-invocation-start">;
@@ -489,6 +514,11 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";

package/dist/run/protocol.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { GATE_NAMES } from "../graph/schema.js";
+import { EFFORTS, GATE_NAMES } from "../graph/schema.js";
 import { normalizeGateOutcome } from "./outcome.js";
 // T32 (F2): the decision protocol is deliberately smaller than the journal. Existing journals contain
 // many observational event types and must remain readable; only the five event names below assert a
@@ -133,6 +133,8 @@ const RoleInvocationIdentityDataSchema = z.object({
     adapter: NonEmptyStringSchema.optional(),
     model: NonEmptyStringSchema.optional(),
     vendor: NonEmptyStringSchema.optional(),
+    // OBS-1182: the effort the seat actually launched at; absent = the CLI's own default, never a level.
+    effort: z.enum(EFFORTS).optional(),
     evidence: EvidenceSchema.optional(),
 });
 const RoleInvocationStartDataSchema = RoleInvocationIdentityDataSchema.strict();

package/dist/run/supervision.d.ts

@@ -48,6 +48,7 @@ export interface SupervisionArm {
 export declare const supervisionArmPath: (repoRoot: string, tier: SupervisionTier) => string;
 /** Explicit arming acknowledges the current marker without deleting it. */
 export declare function newSupervisionArm(repoRoot: string, tier: SupervisionTier, armId?: string, initial?: boolean): SupervisionArm;
+export declare const supervisionPresencePath: (repoRoot: string, tier: SupervisionTier, id: string) => string;
 export declare function beatSupervision(repoRoot: string, tier: SupervisionTier, seat?: string, observation?: SupervisionBeatObservation, options?: {
     arm?: SupervisionArm;
     armId?: string;
@@ -69,7 +70,10 @@ export declare function supervisionStatus(repoRoot: string, tier: SupervisionTie
 export declare const readSupervision: (repoRoot: string, now?: number) => TierLiveness[];
 /** One line, one word per tier. Shared by both status surfaces so neither can render a state twice. */
 export declare const supervisionText: (tiers: readonly TierLiveness[], divider?: string) => string;
-/** A board's durable identity is independent of its short title and of other observers. */
+/** A board's durable identity is independent of its short title and of other observers.
+ *  `handle` is the terminal the claiming observer reports running in, when its host exports one: the
+ *  one fact that names the board's pane when the placing split's receipt never arrived (OBS-1172).
+ *  `retired` marks a tombstone a driver keeps in the record's place; it is never answered again. */
 export interface WatchBoardOwner {
     repo: string;
     runId: string;
@@ -80,6 +84,8 @@ export interface WatchBoardOwner {
     token: string;
     pid?: number;
     armId?: string;
+    handle?: string;
+    retired?: true;
 }
 export declare const WATCH_OWNER_ENV = "TICKMARKR_WATCH_OWNER";
 export declare function readWatchBoard(repo: string, runId: string): WatchBoardOwner | undefined;

package/dist/run/supervision.js

@@ -154,7 +154,7 @@ const supervisionObligationPath = (repoRoot, tier) => join(supervisionDir(repoRo
 // Freshness decides presence, never a process table (SUP-02): a watcher that is killed cannot remove
 // its own file, and an unremoved file ages past the same ceiling a beat does and stops counting.
 const presencePrefix = (tier) => `${tier}.live.`;
-const supervisionPresencePath = (repoRoot, tier, id) => join(supervisionDir(repoRoot), `${presencePrefix(tier)}${id}`);
+export const supervisionPresencePath = (repoRoot, tier, id) => join(supervisionDir(repoRoot), `${presencePrefix(tier)}${id}`);
 /** Every presence file on this tier, by name. Missing directory ⇒ nobody is present. */
 const presenceNames = (repoRoot, tier) => {
     try {
@@ -567,6 +567,8 @@ export const supervisionText = (tiers, divider = " · ") => `supervision: ${tier
     `${t.clearOwedSince ? ` CLEAR-OWED since ${t.clearOwedSince}` : ""}` +
     `${t.clearOwedUnreadable ? " CLEAR-OWED unreadable" : ""}`).join(divider)}`;
 export const WATCH_OWNER_ENV = "TICKMARKR_WATCH_OWNER";
+/** Orca exports each terminal's own handle into the processes it runs. */
+const TERMINAL_HANDLE_ENV = "ORCA_TERMINAL_HANDLE";
 const boardPath = (repo, runId) => join(supervisionDir(repo), `watch-board.${parseRunId(runId)}.json`);
 const boardMessagePath = (owner, kind) => {
     if (!/^[a-f0-9-]{36}$/.test(owner.token))
@@ -642,7 +644,8 @@ export function observeNamedRun(repo, runId, env = process.env) {
             const candidate = readWatchBoard(repo, runId);
             if (!candidate || candidate.token !== token || candidate.pid !== undefined)
                 throw new Error("watch ownership unknown; refusing narrator acknowledgement");
-            owner = { ...candidate, pid: process.pid, armId: armed.id };
+            const handle = env[TERMINAL_HANDLE_ENV]?.trim();
+            owner = { ...candidate, pid: process.pid, armId: armed.id, ...(handle ? { handle } : {}) };
             atomicRecord(boardPath(repo, runId), owner);
         }
     }

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;
 /**