tickmarkr 2.5.3 → 2.5.5

package/dist/run/merge.js

@@ -2,8 +2,10 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { ceilingKillResult, classifyFreshRunnerOutput, classifyRunnerOutput, fileCountDeficit, waitForCalmWindow, effectiveCeilingMs, fingerprint, freshFailures, } from "../gates/baseline.js";
+import { evaluateManifestedTest, isVitestTestCommand } from "../gates/test-manifest.js";
+import { computeVerificationIdentity, formatReusedDetails, getVerdictStore, getWorktreeTree, resolveStateDir, isInfraResult, } from "../gates/cache.js";
 import { tickmarkrDir } from "../graph/graph.js";
-import { describeCapacity, gitHead, linkNodeModules, resolveIntegrationBranch, sameCapacity, sh, shGit, shGitOk, WORKTREES_DIR } from "./git.js";
+import { describeCapacity, gitHead, linkNodeModules, resolveIntegrationBranch, resolvedCapacity, sameCapacity, sh, shGit, shGitOk, WORKTREES_DIR } from "./git.js";
 export function integrationBranch(cfg, runId) {
     return `${cfg.integrationBranchPrefix}${runId}`;
 }
@@ -120,6 +122,11 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline) {
         }
         return results;
     }
+    const stateDir = resolveStateDir(intWt, runDir);
+    const store = getVerdictStore(stateDir);
+    // Publish only after the entire verification completes. The daemon kills a cancelled
+    // verifier process, so completed early gates must remain in memory until then.
+    const pending = new Map();
     for (const [gate, cmd] of gatesToRun) {
         if (runStartCommands !== undefined) {
             const expectedCmd = gate === "test"
@@ -150,6 +157,73 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline) {
         const entry = gate === "test" && (hasTipCommand || (!identity.test && identity.tipTest))
             ? baseline?.commands.tipTest
             : baseline?.commands[gate];
+        // A distinct tipTest selects a different forgiveness entry even when the command
+        // converges with the task command. Include that effective entry in the identity.
+        const verificationBaseline = baseline ? { commands: { ...baseline.commands } } : undefined;
+        if (verificationBaseline) {
+            if (entry)
+                verificationBaseline.commands[gate] = entry;
+            else
+                delete verificationBaseline.commands[gate];
+        }
+        // A tip verifier may reuse only a completed green from its own scope.
+        const id = await computeVerificationIdentity({
+            worktree: intWt,
+            gate,
+            scope: "tip",
+            command: cmd,
+            baseline: verificationBaseline,
+            selectedSet: undefined,
+            capacity: resolvedCapacity(),
+        });
+        // Persistent reuse requires the run's durable journal. Without it there is no
+        // recorded cycle provenance to reconcile with the caller's capacity checks.
+        const hit = journalFound ? store.get(id) : undefined;
+        if (hit && id && hit.pass && !isInfraResult(hit)) {
+            results.push({
+                gate,
+                cmd,
+                pass: hit.pass,
+                exitCode: hit.exitCode ?? 0,
+                fingerprints: hit.meta?.fingerprints ?? [],
+                ...(hit.meta?.forgiven ? { forgiven: true } : {}),
+                details: formatReusedDetails(hit.details, id),
+                ...(hit.meta?.reportPath ? { reportPath: hit.meta.reportPath } : {}),
+                ...(hit.meta?.spawnedCommand ? { spawnedCommand: hit.meta.spawnedCommand } : {}),
+                ...(hit.meta?.artifact ? { artifact: hit.meta.artifact } : {}),
+            });
+            continue;
+        }
+        if (id && journalFound)
+            pending.set(gate, id);
+        // VL-1: tip verify and standalone verify read the SAME invocation-bound report the gate would —
+        // a detected vitest test command never reaches the stdout-count/file-count path below (this
+        // gate's own manifest is always the FULL suite; verify has no selected screen to hold). A
+        // scripted test command that is not the detected runner falls through unchanged.
+        if (gate === "test" && isVitestTestCommand(cmd, intWt)) {
+            const outcome = await evaluateManifestedTest(cmd, intWt, {
+                baselineDurations: entry?.fileDurations,
+                longestFile: entry?.longestFile,
+                overallCeilingMs: effectiveCeilingMs(entry),
+                artifactDir: runDir,
+            });
+            const artifact = join(runDir, `tip-verify-${gate}.log`);
+            if (!outcome.pass)
+                writeFileSync(artifact, outcome.details);
+            results.push({
+                gate,
+                cmd,
+                pass: outcome.pass,
+                exitCode: outcome.exitCode,
+                reportPath: outcome.reportPath,
+                spawnedCommand: outcome.meta.spawnedCommand,
+                fingerprints: outcome.meta.failingTests ?? [],
+                details: outcome.details,
+                ...(outcome.classification ? { cause: outcome.classification } : {}),
+                ...(outcome.pass ? {} : { artifact }),
+            });
+            continue;
+        }
         // OBS-534: the ceiling is the BATTERY's, derived by effectiveCeilingMs from the same baseline entry
         // this loop already reads for forgiveness two lines down — never the flat DEFAULT_SHELL_TIMEOUT_MS
         // `sh` defaults to. A suite whose capture measured 600007ms carries a recorded 1800021ms ceiling;
@@ -216,7 +290,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline) {
         const pass = !deficit && (r.code === 0 || greenTeardown || forgiven);
         if (!pass)
             writeFileSync(artifact, raw);
-        results.push({
+        const tipResult = {
             gate,
             cmd,
             pass,
@@ -233,7 +307,21 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline) {
             ...(forgiven && !deficit ? { forgiven: true } : {}),
             ...(cause ? { cause } : {}),
             ...(pass ? {} : { artifact }),
-        });
+        };
+        results.push(tipResult);
+    }
+    // Recheck through the Git runner before publishing: cancellation disables further
+    // spawns in the daemon child, and a command that changed the tree invalidates reuse.
+    const completedTree = pending.size ? await getWorktreeTree(intWt) : undefined;
+    for (const result of results) {
+        const id = pending.get(result.gate);
+        if (id && id.tree === completedTree && !isInfraResult(result)) {
+            store.set(id, { ...result, meta: {
+                    fingerprints: result.fingerprints, forgiven: result.forgiven,
+                    reportPath: result.reportPath, spawnedCommand: result.spawnedCommand,
+                    artifact: result.artifact,
+                } });
+        }
     }
     return results;
 }

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

@@ -30,11 +30,19 @@ export interface OperatorTask {
     evidence?: EvidenceIdentity;
     mergeEvidence?: EvidenceIdentity;
     gates: Record<string, OperatorGate>;
+    /** BD-1: the board's per-task counters — latest dispatch channel, review verdicts drawn, human parks. */
+    channel?: string;
+    reviewRounds: number;
+    parks: number;
 }
 export interface OperatorSnapshot {
     sequence: number;
     observedAt: number;
     lastEventAt?: string;
+    firstEventAt?: string;
+    /** BD-1 header counts: run-resume and escalation rows seen. */
+    resumes: number;
+    escalations: number;
     lifecycle: "PENDING" | "RUNNING" | "PARTIAL" | "APPROVED" | "COMPLETE" | "UNKNOWN";
     label: string;
     green: boolean;
@@ -63,6 +71,9 @@ export declare class OperatorStateFold {
     private approved;
     private tipFailed;
     private lastEventAt?;
+    private firstEventAt?;
+    private resumes;
+    private escalations;
     private passed;
     private total;
     apply(record: OperatorRecord): void;

package/dist/run/operator-state.js

@@ -16,11 +16,19 @@ export class OperatorStateFold {
     approved = false;
     tipFailed = false;
     lastEventAt;
+    firstEventAt;
+    resumes = 0;
+    escalations = 0;
     passed = 0;
     total = 0;
     apply(record) {
         const { event: e } = record;
         this.lastEventAt = e.ts;
+        this.firstEventAt ??= e.ts;
+        if (e.event === "run-resume")
+            this.resumes++;
+        if (e.event === "escalation")
+            this.escalations++;
         const ref = identity(record);
         if (e.event === "run-start" || e.event === "run-resume") {
             if (e.event === "run-start" && !this.start) {
@@ -72,6 +80,9 @@ export class OperatorStateFold {
             t.path = typeof e.data.worktree === "string" ? e.data.worktree : typeof e.data.cwd === "string" ? e.data.cwd : undefined;
             t.pane = typeof e.data.pane === "string" ? e.data.pane : undefined;
             t.alarmMs = typeof e.data.alarmMs === "number" ? e.data.alarmMs : undefined;
+            const a = e.data.assignment;
+            if (a && typeof a.adapter === "string" && typeof a.model === "string")
+                t.channel = `${a.adapter}:${a.model}`;
         }
         if (e.event === "task-done")
             t.state = "completed";
@@ -85,6 +96,7 @@ export class OperatorStateFold {
             t.state = "failed";
         if (e.event === "task-human") {
             t.state = "human";
+            t.parks++;
             t.parkKind = typeof e.data.kind === "string" ? e.data.kind : undefined;
         }
         if (e.event === "task-blocked")
@@ -98,6 +110,8 @@ export class OperatorStateFold {
         if (typeof gate === "string" && GATE_NAMES.includes(gate)) {
             if (e.event === "gate-start")
                 t.gates[gate] = { state: "running", evidence: ref };
+            if (e.event === "gate-result" && gate === "review")
+                t.reviewRounds++;
             if (e.event === "gate-result")
                 t.gates[gate] = {
                     state: e.data.disabled === true ? "disabled" : e.data.skipped === true ? "not-run" : e.data.pass === true ? "passed" : e.data.pass === false ? "failed" : "unknown", evidence: ref,
@@ -107,7 +121,7 @@ export class OperatorStateFold {
     task(id) {
         let t = this.tasks.get(id);
         if (!t) {
-            t = { id, state: "unknown", merged: false, dispatches: 0, gates: emptyGates() };
+            t = { id, state: "unknown", merged: false, dispatches: 0, reviewRounds: 0, parks: 0, gates: emptyGates() };
             this.tasks.set(id, t);
         }
         return t;
@@ -117,7 +131,7 @@ export class OperatorStateFold {
         const comparable = this.comparableTo(hash);
         const ids = comparable ? [...graph.tasks.map(t => t.id), ...[...this.tasks.keys()].filter(id => !graph.tasks.some(t => t.id === id))] : [...this.tasks.keys()];
         const tasks = ids.map(id => {
-            const t = this.tasks.get(id) ?? { id, state: "unknown", merged: false, dispatches: 0, gates: emptyGates() };
+            const t = this.tasks.get(id) ?? { id, state: "unknown", merged: false, dispatches: 0, reviewRounds: 0, parks: 0, gates: emptyGates() };
             return { ...t, title: comparable ? graph.tasks.find(g => g.id === id)?.title : undefined, gates: Object.fromEntries(Object.entries(t.gates).map(([g, cell]) => [g, { ...cell }])) };
         });
         const buckets = Object.fromEntries(bucketNames.map(k => [k, this.end?.buckets[k] === undefined ? undefined : [...this.end.buckets[k]]]));
@@ -134,7 +148,7 @@ export class OperatorStateFold {
             && bucketNames.every(k => buckets[k]?.length === 0);
         const lifecycle = !readable || !this.start ? "UNKNOWN" : this.active ? "RUNNING" : this.approved ? "APPROVED" : green ? "COMPLETE" : this.end ? "PARTIAL" : "PENDING";
         return {
-            sequence, observedAt, lastEventAt: this.lastEventAt, lifecycle,
+            sequence, observedAt, lastEventAt: this.lastEventAt, firstEventAt: this.firstEventAt, resumes: this.resumes, escalations: this.escalations, lifecycle,
             label: this.approved ? "approved; resume required" : lifecycle,
             green, currentTip, comparable, comparison: comparable ? "matching graph" : "not comparable",
             merged,

package/dist/tui/cockpit/board.d.ts

@@ -0,0 +1,96 @@
+import { type RunGraph } from "../../graph/schema.js";
+import type { OperatorSnapshot } from "../../run/operator-state.js";
+/** The prototype's palette (tasks-redesign.mjs:24-30): xterm-256 indices, stated once. */
+export declare const BOARD_PALETTE: {
+    readonly chrome: 238;
+    readonly mute: 243;
+    readonly body: 252;
+    readonly faint: 240;
+    readonly accent: 75;
+    readonly pass: 71;
+    readonly fail: 174;
+    readonly warn: 179;
+    readonly park: 140;
+};
+/** The seven gates, declaration order; every cell is exactly CELL columns wide. */
+export declare const BOARD_GATES: readonly ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
+export declare const BOARD_CELL = 3;
+export declare const BOARD_AREA_W = 16;
+export declare const BOARD_DEPS_W = 14;
+export declare const BOARD_NOTE_RESERVE = 28;
+export declare const BOARD_FIXED: number;
+export declare const BOARD_EFFORT_BAR_MAX = 46;
+/** The board's own key hints — only the ones the Run view handles; nothing advertised is inert. */
+export declare const BOARD_KEYS: readonly ["↑↓ move", "↵ task detail", "q quit"];
+/** Width band the Run view draws in (RULING-231-19 §2: ≥150 full · 110–149 note wraps · <110 stack). */
+export type BoardBand = "full" | "wrap" | "stacked";
+export declare const boardBand: (columns: number) => BoardBand;
+export declare const stripBoardAnsi: (s: string) => string;
+/** ANSI-aware clip at `n` visible cells (prototype `clip`), cut on a grapheme boundary so a
+ * double-cell glyph never crosses the limit and an emoji is never emitted as a lone surrogate;
+ * a clipped line closes its own colour. */
+export declare function clipBoard(s: string, n: number): string;
+export declare const BOARD_AREA_ORDER: string[];
+/** {codes, unmapped} — abstentions applied, set semantics, misses reported rather than dropped. */
+export declare function areasFor(files: readonly string[]): {
+    codes: string[];
+    unmapped: string[];
+};
+export interface BoardInput {
+    readonly runId: string;
+    readonly snapshot: OperatorSnapshot;
+    readonly graph?: Pick<RunGraph, "tasks">;
+    /** The clock the header's elapsed/ago fields read. */
+    readonly now: number;
+    /** A live daemon holds this run's lock. */
+    readonly live?: boolean;
+    /** The task the focus marker sits on; absent draws the prototype's plain indent. */
+    readonly selection?: string;
+    /** Footer key hints, joined the prototype's way; `false` leaves the footer to the caller (see boardFooter). */
+    readonly keys?: readonly string[] | false;
+    readonly colour?: boolean;
+}
+/** One task row, in the parts the Run view recomposes per width band. */
+export interface BoardRow {
+    readonly id: string;
+    /** indent (or the focus marker) + id + area + deps + title */
+    readonly head: string;
+    /** the seven gate cells */
+    readonly strip: string;
+    /** channel + attempts */
+    readonly tail: string;
+    /** `◍ parked ×n · ↻ n review rounds · ✖ gate` / `waiting on …` / `in flight`, joined by ` · ` */
+    readonly note: string;
+    /** The note's segments, so a band can wrap it across continuation rows without cutting one. */
+    readonly noteParts: readonly string[];
+}
+export interface BoardFrame {
+    /** Header through the gate header rule, in the prototype's order. */
+    readonly top: readonly string[];
+    readonly rows: readonly BoardRow[];
+    /** Header row parts, aligned to the row parts. */
+    readonly gateHeader: {
+        readonly head: string;
+        readonly strip: string;
+        readonly tail: string;
+    };
+    /** Legend, retired ids, rule, effort fold, footer. */
+    readonly bottom: readonly string[];
+    readonly width: number;
+    readonly lbl: number;
+    readonly chan: number;
+}
+/** The prototype's frame, sectioned. `renderBoard` joins it row for row. */
+export declare function boardFrame(input: BoardInput, width: number): BoardFrame;
+/** The footer row: the key hints in chrome, the prototype's leading space kept. */
+export declare const boardFooter: (keys: readonly string[], colour?: boolean) => string;
+/** The prototype's frame as lines, one row per task, unclipped — exactly what the design signed off. */
+export declare function renderBoard(input: BoardInput, width: number): string[];
+/**
+ * The Run view's three width bands over the same frame: full draws the prototype's rows; wrap
+ * puts a note that does not fit on its own second row; stacked draws the gate cells, channel and
+ * attempts under the row so nothing is truncated away.
+ */
+export declare function renderBoardLines(input: BoardInput, width: number): string[];
+/** Pack note segments greedily into rows of `avail` cells; a segment wider than a row splits at the cell. */
+export declare function wrapNote(parts: readonly string[], sep: string, firstAvail: number, avail: number): string[];