tickmarkr 2.5.6 → 2.5.8

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

@@ -20,6 +20,15 @@ export interface TestReportCompletion {
         failed: number;
         skipped: number;
     };
+    /** Bounded (4096 bytes) runner evidence per failed test — diff, actual/expected or stack head.
+     * Never part of the failure's identity: `failures` alone feeds details and fingerprints. */
+    evidence?: FailureEvidence[];
+}
+export interface FailureEvidence {
+    test: string;
+    text: string;
+    truncated?: true;
+    unavailable?: true;
 }
 /** The runner's own machine report — requested/started/completed are the runner's claims about ITSELF. */
 export interface TestReport {
@@ -36,6 +45,9 @@ export interface TestReport {
     certificate?: {
         at: number;
         exitCode: number;
+        /** Unhandled and module collection errors observed by the reporter; absent on older reports. */
+        errors?: number;
+        diagnostics?: string[];
     };
 }
 /** Reads and structurally validates the report; a missing or malformed file is `undefined` — never a partial parse. */

package/dist/gates/test-manifest.js

@@ -103,6 +103,12 @@ export function toManifestPath(file, cwd) {
     catch { /* cwd unreadable — best effort with the given path */ }
     return relative(resolvedCwd, file).split(sep).join("/");
 }
+function isFailureEvidence(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const e = v;
+    return typeof e.test === "string" && typeof e.text === "string";
+}
 function isTestReportShape(v) {
     if (typeof v !== "object" || v === null)
         return false;
@@ -228,10 +234,12 @@ export function verifyManifestReport(opts) {
     const failedCompletions = Object.entries(report.completed).filter(([, c]) => c.status === "failed");
     const failingFiles = failedCompletions.map(([file]) => file).sort();
     const failures = failedCompletions.flatMap(([, c]) => c.failures?.length ? c.failures : ["<unnamed failure>"]);
+    // Parsed defensively: a malformed entry is dropped, never a verdict change — evidence is diagnostics only.
+    const failureEvidence = failedCompletions.flatMap(([, c]) => Array.isArray(c.evidence) ? c.evidence.filter(isFailureEvidence) : []);
     if (failures.length)
         return { kind: "work", pass: false,
             details: `test report names failing fingerprint(s):\n${failures.join("\n")}`,
-            meta: { classification: "regression", failingTests: failures, failingFiles, processExit: exitCode } };
+            meta: { classification: "regression", failingTests: failures, failingFiles, processExit: exitCode, failureEvidence } };
     if (exitCode === undefined) {
         return {
             kind: "fail-closed",
@@ -448,11 +456,29 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
         });
         const verdict = verifyManifestReport({ manifest: files, nonce, exitCode: invoked.exitCode,
             report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs });
+        // Preserve the validator's verdict and classification; runner evidence only explains it.
+        const stdoutPath = join(dir, `test-runner-stdout-${nonce}.log`);
+        const stderrPath = join(dir, `test-runner-stderr-${nonce}.log`);
+        const stdoutTail = Buffer.from(invoked.stdout).subarray(-16 * 1024);
+        const stderrTail = Buffer.from(invoked.stderr).subarray(-16 * 1024);
+        writeFileSync(stdoutPath, stdoutTail);
+        writeFileSync(stderrPath, stderrTail);
+        const report = invoked.report?.nonce === nonce ? invoked.report : undefined;
+        const neverStarted = report ? files.filter(file => !(file in report.started)).length : "unknown";
+        const errors = report?.certificate?.errors;
+        const reporterErrors = typeof errors === "number" && Number.isInteger(errors) && errors >= 0 ? errors : "unknown";
+        const reportedDiagnostics = report?.certificate?.diagnostics;
+        const runnerErrors = Array.isArray(reportedDiagnostics) ? reportedDiagnostics.filter(error => typeof error === "string") : [];
+        const diagnostics = !verdict.pass
+            ? `\nclassification: ${verdict.meta.classification ?? "unknown"}; runner-level diagnostic: never-started ${neverStarted}; reporter errors ${reporterErrors}`
+                + [...runnerErrors,
+                    stdoutTail.toString(), stderrTail.toString()].filter(Boolean).map(text => `\n${text}`).join("")
+            : "";
         return { pass: verdict.pass, kind: verdict.kind,
-            details: verdict.details + (!invoked.report && invoked.stderr ? `\nvitest reporter: ${invoked.stderr}` : ""),
+            details: verdict.details + diagnostics,
             classification: verdict.meta.classification,
             meta: { ...verdict.meta, nonce, manifest: files, manifestPath, listingCommand: invocation.listing, verification,
-                spawnedCommand, processExit: invoked.exitCode, pid: invoked.pid },
+                spawnedCommand, processExit: invoked.exitCode, pid: invoked.pid, stdoutPath, stderrPath },
             exitCode: invoked.exitCode ?? -1, reportPath };
     }
     catch (error) {

package/dist/gates/test-reporter.js

@@ -11,6 +11,24 @@ export default class TickmarkrReporter {
     this.cwd = realpathSync(process.cwd());
   }
   file(module) { return relative(this.cwd, module.moduleId).split(sep).join('/'); }
+  // Bounded assertion evidence, kept BESIDE the failure fingerprint and never inside it: the
+  // fingerprint is the failure's identity (the repeated-failure cap compares it), the evidence is
+  // what the runner knew and the message elided. ONE 4096-byte budget per failed test, shared by
+  // all of its errors (expect.soft yields several); never invented.
+  evidence(test, errors) {
+    const parts = [];
+    for (const e of errors) {
+      if (e && typeof e.diff === 'string' && e.diff) parts.push(e.diff);
+      else for (const k of ['actual', 'expected']) if (e && e[k] !== undefined && e[k] !== null) parts.push(k + ': ' + (typeof e[k] === 'string' ? e[k] : JSON.stringify(e[k])));
+      if (e && typeof e.stack === 'string' && e.stack) parts.push(e.stack.split('\n').slice(0, 8).join('\n'));
+    }
+    if (!parts.length) return { test, text: '', unavailable: true };
+    const full = parts.join('\n').replace(/\x1b\[[0-9;]*m/g, '');
+    if (Buffer.byteLength(full) <= 4096) return { test, text: full };
+    let text = full.slice(0, 4096);
+    while (Buffer.byteLength(text) > 4096) text = text.slice(0, -1);
+    return { test, text, truncated: true };
+  }
   save() {
     writeFileSync(this.path + '.tmp', JSON.stringify(this.report));
     renameSync(this.path + '.tmp', this.path);
@@ -27,6 +45,7 @@ export default class TickmarkrReporter {
     const file = this.file(module);
     const failed = module.state() === 'failed';
     const failures = [];
+    const evidence = [];
     // R41: count test bodies by their own state so a module whose every test was skipped (a
     // describe.skipIf gate) is recorded as SKIPPED — present in the lifecycle, but never as
     // executed test-body success. 'passed'/'failed' executed; anything else did not run.
@@ -37,6 +56,8 @@ export default class TickmarkrReporter {
         tests.failed++;
         if (failed) {
           const errors = test.result().errors || [];
+          const name = file + ' > ' + test.fullName;
+          evidence.push(this.evidence(name, errors));
           failures.push(...(errors.length ? errors.map(e => 'FAIL ' + file + ' > ' + test.fullName + ': ' + e.message) : ['FAIL ' + file + ' > ' + test.fullName]));
         }
       } else if (state === 'passed') tests.passed++;
@@ -45,12 +66,17 @@ export default class TickmarkrReporter {
     if (failed && !failures.length) failures.push('FAIL ' + file);
     const status = failed ? 'failed' : tests.passed + tests.failed === 0 ? 'skipped' : 'passed';
     if (file in this.report.completed) this.report.duplicateCompletions.push(file);
-    this.report.completed[file] = { at: Date.now(), status, failures, tests };
+    this.report.completed[file] = { at: Date.now(), status, failures, tests, ...(evidence.length ? { evidence } : {}) };
     this.save();
   }
   onTestRunEnd(modules, errors, reason) {
     const failed = reason === 'failed' || errors.length > 0 || Object.values(this.report.completed).some(c => c.status === 'failed');
-    this.report.certificate = { at: Date.now(), exitCode: failed ? 1 : 0 };
+    // Collection failures can reach run end without a module start/end event. Keep their
+    // identity as diagnostics, without inventing lifecycle records or changing the verdict.
+    const loadErrors = modules.flatMap(module => module.errors().map(e => this.file(module) + ': ' + e.message));
+    this.report.certificate = { at: Date.now(), exitCode: failed ? 1 : 0,
+      errors: errors.length + loadErrors.length,
+      diagnostics: [...loadErrors, ...errors.map(e => [e.testPath, e.name, e.message].filter(Boolean).join(': '))] };
     this.save();
   }
 }

package/dist/graph/graph.d.ts

@@ -21,6 +21,8 @@ export interface OnDiskSpecHash {
  * evidence for failed recompiles, while moved/deleted source files need not strand a compiled graph.
  */
 export declare function onDiskSpecHash(_repoRoot: string, graph: RunGraph): OnDiskSpecHash | undefined;
+/** A task's definition minus its files[] (and run state): what a scope amendment must NOT move (OBS-1073). */
+export declare function taskDefinitionFingerprint(task: Task): string;
 export declare function graphDefinitionHash(g: RunGraph): string;
 export declare function taskContentDigest(task: Pick<Task, "goal" | "files" | "acceptance">): string;
 export declare function tickmarkrDir(repoRoot: string): string;

package/dist/graph/graph.js

@@ -80,6 +80,11 @@ export function onDiskSpecHash(_repoRoot, graph) {
 // single comparator in journal.ts (engagementComparable) so the journal↔graph join is decided once.
 // ponytail: sha256 truncated to 16 hex — stable, grep-friendly; promote to full digest only if a
 // collision ever bites (engagement ids are not a trust boundary, collisions just force a re-run).
+/** A task's definition minus its files[] (and run state): what a scope amendment must NOT move (OBS-1073). */
+export function taskDefinitionFingerprint(task) {
+    const { status: _status, evidence: _evidence, files: _files, ...def } = task;
+    return createHash("sha256").update(JSON.stringify(def)).digest("hex").slice(0, 16);
+}
 export function graphDefinitionHash(g) {
     const definitions = g.tasks.map(({ status: _status, evidence: _evidence, ...def }) => def);
     return createHash("sha256").update(JSON.stringify({ version: g.version, spec: g.spec, tasks: definitions })).digest("hex").slice(0, 16);

package/dist/graph/schema.d.ts

@@ -19,12 +19,22 @@ export declare const AcceptanceItemSchema: z.ZodUnion<readonly [z.ZodString, z.Z
     oracle: z.ZodLiteral<"test">;
     test: z.ZodString;
     text: z.ZodOptional<z.ZodString>;
+    landing: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     oracle: z.ZodLiteral<"judge">;
     text: z.ZodString;
 }, z.core.$strip>]>;
 export type AcceptanceItem = z.infer<typeof AcceptanceItemSchema>;
 export declare function renderAcceptanceItem(item: AcceptanceItem): string;
+export declare const PinSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"literal">;
+    text: z.ZodString;
+    glob: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fixture">;
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type Pin = z.infer<typeof PinSchema>;
 export declare const TaskSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
@@ -52,6 +62,7 @@ export declare const TaskSchema: z.ZodObject<{
         oracle: z.ZodLiteral<"test">;
         test: z.ZodString;
         text: z.ZodOptional<z.ZodString>;
+        landing: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         oracle: z.ZodLiteral<"judge">;
         text: z.ZodString;
@@ -61,6 +72,14 @@ export declare const TaskSchema: z.ZodObject<{
         confidence: z.ZodOptional<z.ZodNumber>;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    pins: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"literal">;
+        text: z.ZodString;
+        glob: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fixture">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "kind">>>;
     gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         build: "build";
         test: "test";
@@ -144,6 +163,7 @@ export declare const RunGraphSchema: z.ZodObject<{
             oracle: z.ZodLiteral<"test">;
             test: z.ZodString;
             text: z.ZodOptional<z.ZodString>;
+            landing: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             oracle: z.ZodLiteral<"judge">;
             text: z.ZodString;
@@ -153,6 +173,14 @@ export declare const RunGraphSchema: z.ZodObject<{
             confidence: z.ZodOptional<z.ZodNumber>;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        pins: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"literal">;
+            text: z.ZodString;
+            glob: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixture">;
+            paths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>], "kind">>>;
         gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             build: "build";
             test: "test";

package/dist/graph/schema.js

@@ -19,7 +19,9 @@ export const ORACLES = ["command", "test", "judge"];
 export const AcceptanceItemSchema = z.union([
     z.string().min(1),
     z.object({ oracle: z.literal("command"), command: z.string().min(1), text: z.string().min(1).optional() }),
-    z.object({ oracle: z.literal("test"), test: z.string().min(1), text: z.string().min(1).optional() }),
+    // v2.5.8 T8 (OBS-1064): landing = the collectable suite path a test criterion lands in, declared
+    // beside the verbatim title (never inside it). Optional; compile enforces the collectable glob.
+    z.object({ oracle: z.literal("test"), test: z.string().min(1), text: z.string().min(1).optional(), landing: z.string().min(1).optional() }),
     z.object({ oracle: z.literal("judge"), text: z.string().min(1) }),
 ]);
 // Shared text rendering of one acceptance item — every consumer (worker prompt, acceptance gate,
@@ -33,6 +35,15 @@ export function renderAcceptanceItem(item) {
         return item.text ?? `test: ${item.test}`;
     return item.text; // judge — bare text, byte-identical to a plain-string judge criterion
 }
+// v2.5.8 T7 (agreement C2): declared pin obligations — a LIMITED AUTHORING CONTRACT, not an assertion
+// analyzer. literal = an exact text plus the glob it is pinned in (every matching file holding the text
+// is obligated); fixture = a path set whose every matching file is itself obligated (byte-pinned output
+// the change will move) and which carries no literal text. Declared here because z.object strips
+// undeclared keys on every load.
+export const PinSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("literal"), text: z.string().min(1), glob: z.string().min(1) }),
+    z.object({ kind: z.literal("fixture"), paths: z.array(z.string().min(1)).min(1) }),
+]);
 export const TaskSchema = z.object({
     // ids land in git branch names and herdr pane names — branch-safe characters only, bounded
     // length (refs hit filesystem limits), and never "--" (the task-branch separator, locked
@@ -59,6 +70,7 @@ export const TaskSchema = z.object({
         reason: z.string().optional(),
     }))
         .optional(),
+    pins: z.array(PinSchema).optional(),
     gates: z
         .array(z.enum(GATE_NAMES))
         .default(["build", "test", "lint", "evidence", "scope", "acceptance", "review"])

package/dist/run/activity.d.ts

@@ -1,4 +1,5 @@
 import { type JournalEvent } from "./journal.js";
+import { type CommandReceipt, type TrackedJournalRow } from "./protocol.js";
 export interface ActivityTask {
     id: string;
     gates: readonly string[];
@@ -13,3 +14,30 @@ export interface ActivitySnapshot {
     cells: Map<string, string>;
 }
 export declare function foldActivity(events: JournalEvent[], tasks: readonly ActivityTask[]): ActivitySnapshot;
+/** Recorded evidence, not a probe of whether a subprocess is still alive. */
+export type BuildActivity = {
+    state: "start-unrecorded" | "awaiting-command";
+} | {
+    state: CommandReceipt["outcome"] | "unresolved";
+    receipt: CommandReceipt;
+};
+export interface TaskActivityProjection {
+    taskId: string;
+    /** Journal attempt label (zero based), absent until an attempt is recorded. */
+    attempt?: number;
+    state: "unconfirmed" | "preparing" | "implementing" | "returned-for-verification" | "validating" | "reviewing" | "merging" | "terminal";
+    /** Concurrent gates retain separate entries; state alone is only a summary. */
+    phases: {
+        gate: string;
+        state: "validating" | "reviewing";
+    }[];
+    build: BuildActivity;
+}
+/**
+ * Pure, evidence-only successor to foldActivity. Feed Journal.readTracked() and the owning run ID;
+ * sourceIndex supplies journal order, never wall time. Unattributed legacy rows belong to their
+ * tracked run and current attempt/round. They cannot prove identities absent from the journal.
+ * A new gates phase opens a round; completed gates cannot reopen within that round. No declared
+ * gate order, graph status, or successful verdict predicts a later phase.
+ */
+export declare function projectActivity(runId: string, rows: readonly TrackedJournalRow[], tasks: readonly ActivityTask[]): Map<string, TaskActivityProjection>;

package/dist/run/activity.js

@@ -1,4 +1,5 @@
 import { formatJournalNarration } from "./journal.js";
+import { readCommandReceipt } from "./protocol.js";
 const channelOf = (assignment) => {
     const a = assignment;
     return typeof a?.adapter === "string" && typeof a.model === "string" ? `${a.adapter}:${a.model}` : "unknown channel";
@@ -94,3 +95,196 @@ export function foldActivity(events, tasks) {
     const last = events.at(-1);
     return { ...(last ? { now: formatJournalNarration(last) } : {}), cells };
 }
+const activityRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const activityOrdinal = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+/**
+ * Pure, evidence-only successor to foldActivity. Feed Journal.readTracked() and the owning run ID;
+ * sourceIndex supplies journal order, never wall time. Unattributed legacy rows belong to their
+ * tracked run and current attempt/round. They cannot prove identities absent from the journal.
+ * A new gates phase opens a round; completed gates cannot reopen within that round. No declared
+ * gate order, graph status, or successful verdict predicts a later phase.
+ */
+export function projectActivity(runId, rows, tasks) {
+    const states = new Map(tasks.map((task) => [task.id, {
+            projection: { taskId: task.id, state: "unconfirmed", phases: [], build: { state: "start-unrecorded" } },
+            round: 0,
+            closed: new Set(),
+            invocations: new Set(),
+            workerReturned: false,
+            suspended: false,
+            redispatch: false,
+            dispatchedSinceRound: false,
+            adoptRoundAttempt: false,
+        }]));
+    for (const row of [...rows].sort((a, b) => a.sourceIndex - b.sourceIndex)) {
+        if (row.runId !== runId || row.kind === "protocol-issue")
+            continue;
+        // Compatibility readers normalize missing legacy attempts to zero. Retain the physical
+        // payload here so that absence still means the currently recorded attempt.
+        const raw = row.raw;
+        if (!activityRecord(raw) || typeof raw.event !== "string" || !activityRecord(raw.data))
+            continue;
+        const data = raw.data;
+        if (typeof data.runId === "string" && data.runId !== runId)
+            continue;
+        if (raw.event === "run-resume" || raw.event === "run-end") {
+            for (const st of states.values()) {
+                const p = st.projection;
+                if (p.build.state === "started" && "receipt" in p.build) {
+                    p.build = { state: "unresolved", receipt: p.build.receipt };
+                }
+                for (const phase of p.phases)
+                    st.closed.add(phase.gate);
+                p.phases = [];
+                if (p.state !== "terminal")
+                    p.state = "unconfirmed";
+                st.suspended = true;
+                st.redispatch = raw.event === "run-resume";
+                st.dispatchedSinceRound = false;
+                st.adoptRoundAttempt = false;
+            }
+            continue;
+        }
+        if (typeof raw.taskId !== "string")
+            continue;
+        const st = states.get(raw.taskId);
+        if (!st)
+            continue;
+        const p = st.projection;
+        const attempt = activityOrdinal(data.attempt);
+        if (attempt !== undefined && p.attempt !== undefined && attempt < p.attempt)
+            continue;
+        if (raw.event === "task-dispatch") {
+            const nextAttempt = attempt ?? 0;
+            if (p.attempt === nextAttempt && !st.redispatch)
+                continue;
+            p.attempt = nextAttempt;
+            p.state = "preparing";
+            p.phases = [];
+            p.build = { state: "start-unrecorded" };
+            st.closed.clear();
+            st.workerReturned = false;
+            st.suspended = false;
+            st.redispatch = false;
+            st.dispatchedSinceRound = true;
+            st.adoptRoundAttempt = false;
+            continue;
+        }
+        const round = activityOrdinal(data.gateRound);
+        if (round !== undefined && round !== st.round)
+            continue;
+        const roundGate = (raw.event === "gate-result" || raw.event === "gate-phase-start"
+            || raw.event === "phase-start") && typeof data.gate === "string"
+            && !st.suspended && !st.closed.has(data.gate);
+        if (attempt !== undefined && p.attempt !== undefined && attempt !== p.attempt
+            && !(st.adoptRoundAttempt && roundGate))
+            continue;
+        if (st.adoptRoundAttempt && roundGate && attempt !== undefined) {
+            p.attempt = attempt;
+            st.adoptRoundAttempt = false;
+        }
+        if (p.attempt === undefined && attempt !== undefined)
+            p.attempt = attempt;
+        if (["task-done", "task-failed", "task-human", "task-approved", "merge"].includes(raw.event)) {
+            p.state = "terminal";
+            p.phases = [];
+            st.suspended = true;
+            continue;
+        }
+        // Only an explicit new battery may re-enter verification after a resume or completed task.
+        if (raw.event === "phase-start" && data.phase === "gates") {
+            st.round++;
+            // Resume verification has no dispatch and labels the round with the dispatch count,
+            // rather than the last worker's attempt. Its first attributed gate/receipt owns the label.
+            st.adoptRoundAttempt = !st.dispatchedSinceRound;
+            st.dispatchedSinceRound = false;
+            st.closed.clear();
+            p.phases = [];
+            p.build = { state: "start-unrecorded" };
+            if (p.state === "terminal")
+                p.state = "unconfirmed";
+            st.suspended = false;
+            continue;
+        }
+        if (raw.event === "build-receipt" || raw.event === "build-result") {
+            // The emitter adds gate/reason metadata beside the strict command receipt.
+            const { gate: _gate, reason: _reason, freshBuildRan: _fresh, ...payload } = data;
+            const parsed = readCommandReceipt(payload);
+            if (parsed.kind !== "receipt")
+                continue;
+            const receipt = parsed.receipt;
+            if (receipt.outcome === "started" && !receipt.confirmedStart)
+                continue;
+            const identity = receipt.attribution;
+            if (identity.runId !== runId || identity.taskId !== p.taskId
+                || identity.gateRound !== st.round)
+                continue;
+            if (identity.attempt < (p.attempt ?? 0)
+                || (!st.adoptRoundAttempt && identity.attempt !== (p.attempt ?? 0)))
+                continue;
+            const previous = "receipt" in p.build ? p.build.receipt : undefined;
+            const same = previous?.attribution.invocation === identity.invocation;
+            if (same) {
+                if (p.build.state !== "started" && p.build.state !== "unresolved")
+                    continue;
+                if (receipt.outcome === "started")
+                    continue;
+            }
+            else {
+                if (st.suspended || st.closed.has("build") || st.invocations.has(identity.invocation))
+                    continue;
+                // A late terminal cannot displace a newer invocation. No-start outcomes are themselves
+                // complete receipts and need no preceding start; a first terminal remains useful evidence.
+                if (previous && receipt.confirmedStart && receipt.outcome !== "started")
+                    continue;
+            }
+            st.invocations.add(identity.invocation);
+            if (st.adoptRoundAttempt) {
+                p.attempt = identity.attempt;
+                st.adoptRoundAttempt = false;
+            }
+            p.build = { state: receipt.outcome, receipt };
+            continue;
+        }
+        if (st.suspended)
+            continue;
+        if (raw.event === "worker-launch" && !st.workerReturned && p.phases.length === 0
+            && (p.state === "preparing" || p.state === "unconfirmed"))
+            p.state = "implementing";
+        if (raw.event === "worker-result" && !st.workerReturned && p.phases.length === 0) {
+            st.workerReturned = true;
+            p.state = "returned-for-verification";
+        }
+        if (raw.event === "phase-start" && data.phase === "merge") {
+            for (const phase of p.phases)
+                st.closed.add(phase.gate);
+            p.phases = [];
+            p.state = "merging";
+            st.workerReturned = true;
+            continue;
+        }
+        if (raw.event === "gate-result" && typeof data.gate === "string") {
+            st.workerReturned = true;
+            // Infrastructure skips have no verdict; a retry may start again in this round.
+            if (typeof data.pass === "boolean" || (data.skipped !== true && data.infra !== true))
+                st.closed.add(data.gate);
+            if (data.gate === "build" && p.build.state === "awaiting-command")
+                p.build = { state: "start-unrecorded" };
+            p.phases = p.phases.filter((phase) => phase.gate !== data.gate);
+            if (p.state !== "merging")
+                p.state = p.phases[0]?.state ?? "unconfirmed";
+        }
+        if ((raw.event === "phase-start" || raw.event === "gate-phase-start")
+            && typeof data.gate === "string" && !st.closed.has(data.gate) && p.state !== "merging") {
+            const gate = data.gate;
+            if (!p.phases.some((phase) => phase.gate === gate)) {
+                p.phases.push({ gate, state: gate === "review" ? "reviewing" : "validating" });
+            }
+            st.workerReturned = true;
+            p.state = p.phases[0].state;
+            if (gate === "build" && p.build.state === "start-unrecorded")
+                p.build = { state: "awaiting-command" };
+        }
+    }
+    return new Map([...states].map(([id, st]) => [id, st.projection]));
+}

package/dist/run/daemon.d.ts

@@ -4,8 +4,18 @@ import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
+import { type RunGraph } from "../graph/schema.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export declare function closeLiveSlot(liveSlots: Set<Slot>, driver: Pick<ExecutorDriver, "close">, slot: Slot): Promise<void>;
+/** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
+export interface DispatchObservation {
+    slotId: string;
+    command: string;
+    dispatchId: string;
+    outcome: "accepted" | "not-accepted";
+    authoritative: true;
+}
+export declare function heldWorkerTransport(driver: ExecutorDriver, slot: Slot, dispatchId: string, held: (data: Record<string, unknown>) => void, sleep?: (ms: number) => Promise<void>): Pick<ExecutorDriver, "run" | "read" | "status" | "waitOutput" | "waitAgentStatus">;
 export declare function setAttemptHardTimeoutMsForTests(ms: number): void;
 export declare function resetAttemptHardTimeoutMsForTests(): void;
 export { harvestCpuFlatWindowMs, resetHarvestCpuFlatMsForTests, setHarvestCpuFlatMsForTests, workerTreeCpuMs, } from "./stall.js";
@@ -49,6 +59,8 @@ export interface RunSummary {
     pending: string[];
     blocked: string[];
     tipVerify?: "passed" | "failed";
+    /** additive beside the legacy tipVerify enum: HOW the close's latest verification cycle earned its verdict */
+    tipProof?: TipProof;
     lastMergedTask?: string;
     /** T14: did every approval this run accepted actually get enacted, or did the run end over one? */
     approvalDisposition?: "complete" | "outstanding";
@@ -156,6 +168,21 @@ export declare function resetHarvestSilentMsForTests(): void;
 export declare const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries committed work; the worker emitted no TICKMARKR_RESULT trailer";
 /** T4 (OBS-266): identity of the command SET a tip verify ran — a changed command is a different verify. */
 export declare function commandsHash(commands: Record<string, string>): string;
+export interface TipProof {
+    kind: "fresh" | "reused" | "failed" | "incomplete";
+    /** the commit the cycle's start row spoke for */
+    tip?: string;
+}
+/**
+ * OBS-1077 close rider: what the engagement's LATEST verification cycle proved — its
+ * `tip-verify-start` row and what followed, never a commit comparison. Exactly one kind per close:
+ * fresh (every tip command ran AND passed), reused (an eligible cached cycle carried forward),
+ * failed, or incomplete (cancelled, cut short, mixed or undelimited). Nothing before the start row
+ * is read, so an unfinished cycle inherits nothing from an earlier green one.
+ */
+export declare function runEndTipProof(events: readonly JournalEvent[]): TipProof;
+/** The close notification's statement of the proof — one clause per kind. */
+export declare function formatTipProof(p: TipProof): string;
 /**
  * OBS-34's strict tip verify, but it stops re-paying for an unmoved tip (~334m corpus-wide; 69.5m in
  * one park-heavy run whose 18 resume cycles merged nothing new). The verify journals the SHA it
@@ -185,4 +212,5 @@ export declare function liveSuiteCount(repoRoot: string): Promise<number>;
 /** Test seam — exercise the production observer's total read bound with a small real tree. */
 export declare function setObserveBudgetBytesForTests(bytes: number): void;
 export declare function resetObserveBudgetBytesForTests(): void;
+export declare function recordFatalRunEnd(journal: Journal, runId: string, branch: string, err: unknown, graph?: RunGraph, phase?: string): TipProof | undefined;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;