tickmarkr 2.5.5 → 2.5.7

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/consult.js

@@ -164,10 +164,11 @@ opts = {}) {
             out = r.stdout + r.stderr;
         }
         else {
-            // Preserve the adapter contract for CLIs that cannot seed their TUI: supported adapters use
-            // the interactive form, while a declared null keeps the existing visible print fallback.
-            const command = adapter.interactiveCommand(promptFile, seatModel)
-                ?? adapter.headlessCommand(promptFile, seatModel);
+            // OBS-1009: the pane runs the HEADLESS command. A seeded interactive session answers on screen
+            // but never exits, so the exit trailer after it never runs, the wait runs to the stall cap and
+            // the 300-line read is a TUI frame. The headless command exits, the trailer prints, and the
+            // pane is harvested through dewrap exactly like a judge or review seat.
+            const command = adapter.headlessCommand(promptFile, seatModel);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,

package/dist/run/daemon.d.ts

@@ -6,6 +6,17 @@ 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";
 export interface RunOptions {
     runId?: string;