tickmarkr 2.6.2 → 2.6.3

package/dist/run/repair-selection.d.ts

@@ -2,9 +2,19 @@ import type { JournalEvent } from "./journal.js";
 export interface RepairSelectionDecision {
     selectTests: boolean;
     requiredFiles: string[];
-    reason: "no-test-failure" | "known-failing-files" | "legacy-test-failure" | "unattributed-test-failure" | "full-suite-failure";
+    reason: "no-test-failure" | "known-failing-files" | "legacy-test-failure" | "unattributed-test-failure";
 }
 type SelectionEvent = Pick<JournalEvent, "event" | "taskId" | "data">;
+/** OBS-1199: repair selection is on unless a config says otherwise, independent of the optional
+ * execution budget (which stays subprocess-only). Either explicit `false` turns it off. */
+export declare function repairSelectionEnabled(cfg?: {
+    executionPolicy?: {
+        repairSelection?: unknown;
+    };
+    gates?: {
+        repairSelection?: unknown;
+    };
+}): boolean;
 /** Diagnostic selection only: neither a narrow pass nor this decision can authorize integration.
  * Distrust and known failing files survive later green results, approvals and resume. A historical
  * ambiguous failure is never reinterpreted using a newly enabled policy. */

package/dist/run/repair-selection.js

@@ -1,3 +1,8 @@
+/** OBS-1199: repair selection is on unless a config says otherwise, independent of the optional
+ * execution budget (which stays subprocess-only). Either explicit `false` turns it off. */
+export function repairSelectionEnabled(cfg) {
+    return cfg?.executionPolicy?.repairSelection !== false && cfg?.gates?.repairSelection !== false;
+}
 /** These are literal repository-relative identities. Existence and selection support are checked
  * against the current worktree by the gate; this journal fold cannot establish either. */
 function fileIdentities(value) {
@@ -32,16 +37,19 @@ export function repairSelectionDecision(events, taskId, enabled) {
             distrust ??= "unattributed-test-failure";
             continue;
         }
-        // A replacement full-suite failure follows a passing screen in the current pipeline. No
-        // ordinary full-suite failure establishes that a selector safely covers the failed behavior.
-        if (data.fullSuite === true) {
-            distrust ??= "full-suite-failure";
-            continue;
-        }
-        const selected = fileIdentities(data.selectedTests);
+        // OBS-1199: a full-suite red counts only when it positively says it was full — the replacement
+        // after a screen (`fullSuite`), or an ordinary full run whose recorded selection decision says
+        // so — and names its failing files. Those files join every later screen even when no selector
+        // reaches them; the merge candidate still runs the complete suite. No attribution means full.
         const failing = fileIdentities(data.failingFiles);
-        if (!selected || !failing || failing.some((file) => !selected.includes(file))
-            || (data.fullSuite !== undefined && data.fullSuite !== false)) {
+        const selected = fileIdentities(data.selectedTests);
+        const decision = data.selectionDecision;
+        const replacement = data.fullSuite === true;
+        const ordinaryFull = data.fullSuite === undefined && data.selectedTests === undefined
+            && typeof decision === "object" && decision !== null && decision.scope === "full";
+        const screen = (data.fullSuite === undefined || data.fullSuite === false) && selected !== undefined
+            && failing !== undefined && failing.every((file) => selected.includes(file));
+        if (!failing || !(replacement || ordinaryFull || screen)) {
             distrust ??= "unattributed-test-failure";
             continue;
         }

package/dist/run/wall-budget.d.ts

@@ -0,0 +1,48 @@
+import type { JournalEvent } from "./journal.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 declare const WALL_PRIORITY: readonly ["interruption", "test", "semantics", "worker", "queue", "other-gate"];
+export type WallBucket = (typeof WALL_PRIORITY)[number];
+type PerBucket = Record<WallBucket, number>;
+export interface WallBudget {
+    wallMs: number;
+    exposedMs: PerBucket;
+    residualMs: number;
+    taskMs: PerBucket;
+    /** Gate-result rows by provenance. A declined gate never ran and is none of these. */
+    evidence: {
+        fresh: number;
+        replay: number;
+        reuse: number;
+        unknown: number;
+    };
+    /** Evidence that exists but carries no timing: rows without a duration, unmatched and interrupted starts. */
+    untimed: Record<WallBucket, {
+        unknown: number;
+        unmatched: number;
+        interrupted: number;
+    }>;
+}
+/** Undefined when the journal names no measurable window (no run-start, or unreadable timestamps). */
+export declare function wallBudget(events: readonly JournalEvent[]): WallBudget | undefined;
+/** Whole seconds past a minute, one decimal below ten seconds — never a rounded-away "0s" for a real span. */
+export declare const formatSpan: (ms: number) => string;
+/**
+ * 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 declare function wallBudgetFacts(b: WallBudget): Array<[label: string, fact: string]>;
+export declare const WALL_PRIORITY_TEXT: string;
+export {};

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/run-cockpit.js

@@ -334,7 +334,7 @@ export function taskProjectionText(row, journal = []) {
         `blocker ${blocker ? `${blocker.kind} ${at(evidence.blocker)}` : "none"}`,
         `next ${blocker?.nextAction == null ? fieldReading(undefined) : `${blocker.nextAction} ${at(evidence.nextAction)}`}`,
         ...(harvest?.suspectedStalledHarvest ? [`${STALL_MARKER} · launch ${at(evidence.launch)} · ${harvest.nudgeFailures} nudge failed ${at(evidence.nudge)} · ${harvest.pageCount} paged ${at(evidence.page)} · no worker-result`] : []),
-    ].reduce((text, part) => `${text} · ${part}`);
+    ].join(" · ");
 }
 /**
  * Identity, phase, and build are unrecorded until a dispatch. Append the blocker and next action
@@ -354,7 +354,7 @@ function undispatchedProjectionText(row, journal) {
         MISSING_EVIDENCE,
         ...(showBlocker ? [`blocker ${blocker.kind} ${at(evidence.blocker)}`] : []),
         ...(showNext ? [`next ${blocker.nextAction} ${at(evidence.nextAction)}`] : []),
-    ].reduce((text, part) => `${text} · ${part}`);
+    ].join(" · ");
 }
 /**
  * Correlate each already-derived field with the row that can have produced that value. This is

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

@@ -93,8 +93,9 @@ export interface TaskProjection {
     readonly build: ProjectionField;
     readonly blocker: ProjectionField;
     readonly nextAction: ProjectionField;
-    /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. OBS-1104: neverDispatched collapses that task's line. */
+    /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. */
     readonly stalled?: ProjectionField;
+    /** OBS-1104: a task with no recorded dispatch collapses its line to one missing-evidence clause. */
     readonly neverDispatched?: true;
 }
 export declare const STALL_MARKER = "\u26A0 stalled harvest suspected";

package/dist/tui/cockpit/run-view.js

@@ -251,8 +251,11 @@ export function projectRunTasks(snapshot, rows, graph, decisions, runId) {
         const blocker = { label: `blocker ${blk ? `${blk.kind}${blk.diagnostic ? ` · ${blk.diagnostic}` : ""}` : "none"}`, ...(blk && blockerRow ? { line: blockerRow.line } : {}) };
         const nextAction = { label: `next ${blk?.nextAction ?? "none"}`, ...(blk?.nextAction && blockerRow ? { line: blockerRow.line } : {}) };
         // OBS-1048 harvest, chronological: the newest worker-launch opens the attempt; a later worker-result retires it.
-        let launched, launchedAttempt, returned = false;
-        const nudges = [], pages = [];
+        let launched;
+        let launchedAttempt;
+        let returned = false;
+        const nudges = [];
+        const pages = [];
         // Finding 1: only rows of the launched attempt count; a row without an attempt belongs to it (derive.ts attemptHarvests).
         const ofLaunched = (d) => launched !== undefined && (ordinal(d.attempt) ?? launchedAttempt) === launchedAttempt;
         for (const r of own) {
@@ -389,15 +392,16 @@ function undispatchedProjectionLine(p) {
     ].join(" · ");
 }
 /**
- * Rows the projection panel paints. A never-dispatched clause is shorter than the field line it
- * replaces; the shell's content counter is the panel's wrapped height, and the pinned run frames
- * record that counter. Blank rows keep the block as tall as the field lines were.
+ * Rows the projection panel paints: each task's clause at its own wrapped height (OBS-1193). A
+ * never-dispatched clause is shorter than the field line it replaces, so the block is shorter too;
+ * the shell's content counter reads that real height and the pinned run frames record it.
  */
 function projectionBlockRows(projections, wrap) {
-    const shown = projections.flatMap((p) => wrap(projectionLine(p)).map((line, i) => ({ key: `${p.taskId}:${i}`, line, strong: p.stalled !== undefined && i === 0 })));
-    const prior = projections.flatMap((p) => wrap(recordedProjectionLine(p)));
-    const pad = Math.max(0, prior.length - shown.length);
-    return [...shown, ...Array.from({ length: pad }, (_, i) => ({ key: `projection-pad:${i}`, line: " ", strong: false }))];
+    return projections.flatMap((p) => wrap(projectionLine(p)).map((line, i) => ({
+        key: `${p.taskId}:${i}`,
+        line,
+        strong: p.stalled !== undefined && i === 0,
+    })));
 }
 /** The Run body: the approved board (BD-1) over the fold, then the selected task's detail panels. */
 export function RunView({ snapshot, rows, page, graph, decisions, session, columns, run, now = Date.now }) {

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

@@ -73,6 +73,8 @@ export type ParkedDecision = {
     readonly tombstone: boolean;
     /** OBS-1178: the park's `<line>@<ts>` token — the confirmed write binds to it via `--park`. */
     readonly park?: string;
+    /** OBS-1202: a stall park's recorded reap failure — the one stall park recheck may release. */
+    readonly reapFailure?: string;
 };
 /** The parks a verb can release — the rows the surface draws live verbs on. */
 export declare function actionableDecisions(decisions: readonly ParkedDecision[]): readonly ParkedDecision[];

package/dist/tui/cockpit/setup-cockpit.js

@@ -607,6 +607,7 @@ export function deriveParkedDecisions(journal) {
             failedGate,
             tombstone: isTombstonePark(kind, reason),
             ...(typeof parked?.ts === "string" ? { park: bindingToken({ line: lines[parkedIndex], ts: parked.ts }) } : {}),
+            ...(kind === "stall" && typeof parked?.data.reapFailure === "string" ? { reapFailure: parked.data.reapFailure } : {}),
         });
     }
     return decisions;
@@ -623,6 +624,9 @@ export function initialSetupDecisionsSession() {
 export function setupDecisionVerbs(decision) {
     if (decision.tombstone)
         return [];
+    // OBS-1202: the production table's census-recovery row; an ordinary stall stays approve-only.
+    if (decision.kind === "stall" && decision.reapFailure !== undefined)
+        return ["approve", "recheck"];
     if (decision.kind !== "gate-fail")
         return ["approve"];
     if (decision.failedGate === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -81,6 +81,7 @@
         "scripts/emit-schema.ts",
         "scripts/probe-rig.mjs",
         "scripts/run-ci-vitest.sh",
+        "scripts/vitest-lease.ts",
         "specs/export-selftest.spec.md"
       ],
       "prefixes": [

package/schema/config.schema.json

@@ -10,7 +10,6 @@
           "type": "boolean"
         },
         "repairSelection": {
-          "default": false,
           "type": "boolean"
         },
         "taskExecutionLimitMs": {
@@ -619,6 +618,14 @@
           "exclusiveMinimum": 0,
           "maximum": 9007199254740991
         },
+        "evidenceQuotaBytes": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        },
+        "repairSelection": {
+          "type": "boolean"
+        },
         "byShape": {
           "type": "object",
           "propertyNames": {

package/skills/tickmarkr-loop/SKILL.md

@@ -129,7 +129,13 @@ Run offers only validated park verbs: human/attempt-cap/other non-gate parks all
 infra allows approve or `--recheck`; review gate-fail allows `--waive`, `--uphold` or
 `--recheck`; other gate-fail allows waive/recheck. Waive satisfies only the identified
 failed gate, uphold funds a fixed attempt carrying review findings, and recheck reruns the
-declared battery without satisfying a gate. Attempt-cap approval resets the budget while
+declared battery without satisfying a gate. A stall park that recorded a `reapFailure`
+(unreadable or surviving worker census) allows approve or `--recheck --park <line>@<ts>`:
+recheck re-verifies that attempt's owned census and gates its harvested commits with no
+worker only with an explicitly recorded empty survivors array (`[]`) — a missing,
+unreadable or surviving census
+re-parks the stall under a new token — while plain approve dispatches a worker. An
+ordinary stall park (no `reapFailure`) stays approve-only; `--recheck` refuses it. Attempt-cap approval resets the budget while
 retaining routing exclusions. Tombstones and failures without identified gate evidence
 are diagnostic-only. Decisions cannot be undone; stale or duplicate decisions refuse.
 

package/skills/tickmarkr-overseer/scripts/classify-vitest-log.sh

@@ -44,7 +44,10 @@ awk -v esc="$esc" '
     gsub(/\^\[\[[0-9;]*m/, "", line); gsub(esc "\\[[0-9;]*m", "", line)
     sub(/^[^\t]*\t[^\t]*\t[0-9T:.-]+Z[ ]?/, "", line)
   }
-  line ~ /Test timed out|Error: Hook timed out/ { timedout++ }
+  # The Vitest timeout message carries its millisecond count; a test that PRINTS a fingerprint normalized
+  # to #ms (the daemon OBS-1106 notifications) is output, not a timed-out test. A real timeout also fails
+  # its test, so the summary failed count still reds it.
+  line ~ /(Test|Hook) timed out in [0-9]+ ?ms/ { timedout++ }
   line ~ /ERROR: Coverage for .* does not meet .*threshold/ { coverage++ }
   line ~ /^npm (error|ERR!) signal / { signals++ }
   line ~ /^(⎯)+ Unhandled Errors (⎯)+[ \t]*$/ { if (armed) close_block(); opening = 1; next }