tickmarkr 2.5.6 → 2.5.7

package/dist/gates/test-reporter.js

@@ -50,7 +50,12 @@ export default class TickmarkrReporter {
   }
   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/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

@@ -6,6 +6,15 @@ import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.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";