tickmarkr 2.5.0 → 2.5.2

package/dist/adapters/fake.d.ts

@@ -25,6 +25,7 @@ export declare class FakeAdapter implements WorkerAdapter {
     private scriptPath;
     id: string;
     vendor: string;
+    busyFrameMarkers: readonly import("./types.js").BusyFrameMarker[];
     trustDialog: TrustDialog;
     private script;
     private attempts;

package/dist/adapters/fake.js

@@ -1,12 +1,13 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseWorkerResult } from "./prompt.js";
-import { shq, TokenUsageSchema } from "./types.js";
+import { OPENCODE_BUSY_FRAME_MARKERS, shq, TokenUsageSchema } from "./types.js";
 // ponytail: deterministic scripted adapter — the whole integration suite runs on it, zero tokens.
 export class FakeAdapter {
     scriptPath;
     id = "fake";
     vendor = "fake-a";
+    busyFrameMarkers = OPENCODE_BUSY_FRAME_MARKERS;
     // v1.89 T1 / OBS-414: the scripted adapter runs `bash -c` — it has no TUI, so no prompt of any
     // kind can render. Daemon tests that exercise the auto-answer seam assign a captured declaration
     // to this field explicitly; that assignment is the falsifier for the claim made here.

package/dist/adapters/opencode.d.ts

@@ -1,3 +1,4 @@
 import { type WorkerAdapter } from "./types.js";
 export declare function parseOpencodeModels(raw: string): string[];
+export { OPENCODE_BUSY_FRAME_MARKERS } from "./types.js";
 export declare const opencode: WorkerAdapter;

package/dist/adapters/opencode.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, MODEL_ID_RE, OPENCODE_BUSY_FRAME_MARKERS, shq, TokenUsageSchema } from "./types.js";
 // v1.5 MODEL-01: pure parser for `opencode models` (one provider/model id per line, no header).
 // Live-verified 2026-07-10, opencode 1.17.15. Lines are already the seed id format; drop blanks.
 export function parseOpencodeModels(raw) {
@@ -13,9 +13,12 @@ export function parseOpencodeModels(raw) {
         .filter((l) => l.length > 0)
         .filter((id) => MODEL_ID_RE.test(id));
 }
+// Keep the adapter export available without making the fake adapter import probe code.
+export { OPENCODE_BUSY_FRAME_MARKERS } from "./types.js";
 export const opencode = {
     id: "opencode",
     vendor: "mixed",
+    busyFrameMarkers: OPENCODE_BUSY_FRAME_MARKERS,
     probeCwd: "neutral",
     probe: async () => probeVersion("opencode"),
     channels: (cfg) => channelsFromConfig("opencode", cfg),

package/dist/adapters/types.d.ts

@@ -150,6 +150,19 @@ export declare function matchesInputBox(paneText: string, inputBox: InputBox): b
 export declare function matchesEmptyInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function matchesOccupiedInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function missingInputStateDeclarations(inputBox: InputBox | undefined): string[];
+export interface BusyFrameMarker {
+    name: string;
+    match(paneText: string): boolean;
+}
+export declare const OPENCODE_BUSY_FRAME_MARKERS: readonly BusyFrameMarker[];
+export declare class SettledTrailerTracker {
+    private readonly markers;
+    private idleSamples;
+    readonly busyMarkersSeen: Set<string>;
+    settled: boolean;
+    constructor(markers: readonly BusyFrameMarker[]);
+    sample(paneText: string, trailer: boolean): boolean;
+}
 export interface WorkerAdapter {
     id: string;
     vendor: string;
@@ -174,6 +187,7 @@ export interface WorkerAdapter {
     trust?(repoRoot: string): TrustVerdict;
     trustDialog: TrustDialog;
     inputBox?: InputBox;
+    busyFrameMarkers?: readonly BusyFrameMarker[];
     hardcodedFlags?: {
         binary: string;
         flags: string[];

package/dist/adapters/types.js

@@ -207,6 +207,31 @@ export function missingInputStateDeclarations(inputBox) {
         missing.push("occupiedMatch");
     return missing;
 }
+// OBS-957 capture retained under fixtures/opencode (the captured UI identifies as omp).
+// Anchor activity glyphs to chrome/tool rows so a quoted spinner in a summary is harmless.
+export const OPENCODE_BUSY_FRAME_MARKERS = [
+    { name: "unchecked TODO", match: (text) => /(?:^|\n)[^\n]*[├└]─[^\n]*☐/.test(text) || /(?:^|\n)\s*[-*] \[ \]/.test(text) },
+    { name: "in-flight tool", match: (text) => /(?:^|\n)\s*⎋ [^\n]+/.test(text) },
+    { name: "spinner", match: (text) => /(?:^|\n)(?:[╭│][─ ]*|\s*)[⠁-⣿](?:\s|$)/.test(text) },
+];
+export class SettledTrailerTracker {
+    markers;
+    idleSamples = 0;
+    busyMarkersSeen = new Set();
+    settled = false;
+    constructor(markers) {
+        this.markers = markers;
+    }
+    sample(paneText, trailer) {
+        const busy = this.markers.filter((marker) => marker.match(paneText));
+        if (trailer)
+            for (const marker of busy)
+                this.busyMarkersSeen.add(marker.name);
+        this.idleSamples = trailer && busy.length === 0 ? this.idleSamples + 1 : 0;
+        this.settled = this.idleSamples >= 2;
+        return this.settled;
+    }
+}
 export function channelsFromConfig(adapterId, cfg) {
     const e = cfg.tiers[adapterId];
     if (!e)

package/dist/cli/commands/approve.js

@@ -114,7 +114,7 @@ export function approvalRunOwner(cwd, runId) {
 /** The one sentence that says who enacts this release and what it buys. */
 export function approvalEnactment(token, run) {
     if (run.live) {
-        return `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}`;
+        return `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}, including in the approval window or by cancelling an in-progress tip verify`;
     }
     if (run.blockingRunId) {
         return `release recorded; live run \`${run.blockingRunId}\` holds the repository lock, so resume \`${run.runId}\` after it ends to ${APPROVAL_ENACTS[token]}`;

package/dist/cli/commands/doctor.d.ts

@@ -162,6 +162,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
     gates: {
         build?: string | undefined;
         test?: string | undefined;
+        tipTest?: string | undefined;
         lint?: string | undefined;
         diffCap?: number | undefined;
         byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {
@@ -278,6 +279,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
     gates: {
         build?: string | undefined;
         test?: string | undefined;
+        tipTest?: string | undefined;
         lint?: string | undefined;
         diffCap?: number | undefined;
         byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,5 @@
+export type DetectedHost = "herdr" | "orca" | "subprocess";
+export declare function detectedHost(env?: NodeJS.ProcessEnv): DetectedHost;
 /** Test seam mirroring FleetIO: production callers omit it and get the process streams. */
 export type InitIO = {
     input?: NodeJS.ReadStream;

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
+import { parse as parseYaml } from "yaml";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
@@ -113,7 +114,7 @@ A run is green only when ALL of these hold: the run-end event exists in the jour
 
 ### Verified handoffs
 
-When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the target pane afterward; never report "relayed" without read-back.
+When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the TARGET composer afterward; if the sent text still sits unsubmitted after ~15 s, send-keys enter to that pane once and read again (OBS-975); never report "relayed" without read-back.
 
 ### Orient before you act — this block may be the ONLY guidance your host loaded
 
@@ -218,7 +219,14 @@ const describeDrift = (d) => [
 // should not be asked again just because a copy drifted. Staleness is a different question with a
 // different answer (`--agent --force`), and it is reported by name on every init path below.
 const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
-const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : orcaHostDetected() ? "orca" : "auto";
+export function detectedHost(env = process.env) {
+    if (env.HERDR_ENV === "1")
+        return "herdr";
+    if (orcaHostDetected(env))
+        return "orca";
+    return "subprocess";
+}
+const wizardDriverDefault = () => "auto";
 function packageName(cwd) {
     try {
         const parsed = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
@@ -323,6 +331,7 @@ async function runInitWizard(cwd, input, output) {
             visibilityLlm: DEFAULT_CONFIG.visibility.llm,
             offerSkills: !skillsInstalled(cwd),
             skillsDefault: existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd),
+            detectedHost: detectedHost(),
         },
         input,
         output,
@@ -368,8 +377,37 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     }
     const repoConfigPath = join(tickmarkrDir(cwd), "config.yaml");
     const repoConfigExists = existsSync(repoConfigPath);
-    if (repoConfigExists)
-        notes.push(`kept existing ${repoConfigPath}`);
+    if (repoConfigExists) {
+        if (values.force) {
+            const currentRaw = readFileSync(repoConfigPath, "utf8");
+            let parsedDriver;
+            try {
+                const parsed = parseYaml(currentRaw);
+                if (typeof parsed?.driver === "string")
+                    parsedDriver = parsed.driver;
+            }
+            catch {
+                // malformed: fall back to regex
+            }
+            if (!parsedDriver) {
+                const m = currentRaw.match(/^\s*driver:\s*([^\s#]+)/m);
+                if (m)
+                    parsedDriver = m[1];
+            }
+            const host = detectedHost();
+            if (parsedDriver && parsedDriver === host) {
+                const rewritten = currentRaw.replace(new RegExp(`^(\\s*driver:\\s*)${parsedDriver}\\b.*$`, "m"), `$1auto            # auto — resolves to ${host} here`);
+                writeFileSync(repoConfigPath, rewritten);
+                notes.push(`rewrote driver: ${parsedDriver} to auto in ${repoConfigPath}`);
+            }
+            else {
+                notes.push(`kept existing ${repoConfigPath}`);
+            }
+        }
+        else {
+            notes.push(`kept existing ${repoConfigPath}`);
+        }
+    }
     const specPath = join(cwd, SCAFFOLD_SPEC);
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
@@ -417,7 +455,9 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
                 // so costs one clause; everything else stops here. Esc and ctrl+c both land here.
                 return `init: wizard quit — nothing further run (scaffolding kept: ${notes.filter((n) => n.startsWith("wrote")).length} file(s) written above). Re-run tickmarkr init to continue.`;
             }
-            writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
+            const host = detectedHost();
+            const renderedConfig = configTemplate(wizard.overlay).replace(/^driver: auto$/m, `driver: auto            # auto — resolves to ${host} here`);
+            writeFileSync(repoConfigPath, renderedConfig);
             notes.push(`wrote ${repoConfigPath}`);
             if (wizard.installSkills) {
                 await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
@@ -462,7 +502,7 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     const next = nextSteps(cwd, SCAFFOLD_SPEC);
     if (!visual())
         return `${notes.join("\n")}\n${doc}\n${next}\n${ENVIRONMENTS_FOOTER}`;
-    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
+    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended|rewrote)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
     const footerRows = ENVIRONMENTS_FOOTER.split("\n").slice(1).map((line) => {
         const separator = line.indexOf(" — ");
         return kvRow(line.slice(2, separator), line.slice(separator + 1), 12);

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -7,7 +7,7 @@ import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
-import { loadGraph } from "../../graph/graph.js";
+import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -15,7 +15,7 @@ import { staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -40,7 +40,10 @@ const stylizePlan = (out) => {
 const fleetCanCrossVendorReview = (channels) => {
     for (let i = 0; i < channels.length; i++)
         for (let j = 0; j < channels.length; j++)
-            if (i !== j && channels[i].vendor !== channels[j].vendor && modelId(channels[i].model) !== modelId(channels[j].model))
+            if (i !== j
+                && channels[i].vendor !== channels[j].vendor
+                && modelProvider(channels[i].model, channels[i].vendor) !== modelProvider(channels[j].model, channels[j].vendor)
+                && modelId(channels[i].model) !== modelId(channels[j].model))
                 return true;
     return false;
 };
@@ -121,6 +124,43 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
     const g = loadGraph(cwd);
+    const gHash = graphDefinitionHash(g);
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    let matchingEvents;
+    let matchingRunId;
+    if (existsSync(runsRoot)) {
+        const locked = runLockRunId(cwd);
+        const candidates = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+        const ordered = locked && candidates.includes(locked)
+            ? [locked, ...candidates.filter((id) => id !== locked).reverse()]
+            : candidates.reverse();
+        for (const runId of ordered) {
+            try {
+                const events = Journal.open(cwd, runId).read();
+                if (recordedGraphDefinitionHash(events) === gHash) {
+                    matchingEvents = events;
+                    matchingRunId = runId;
+                    break;
+                }
+            }
+            catch {
+                // ignore unreadable or torn journals
+            }
+        }
+    }
+    const hasRun = matchingEvents !== undefined;
+    const reviewHistory = matchingEvents
+        ? matchingEvents
+            .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
+            .map((event) => event.data.reviewer)
+        : [];
+    // OBS-947 repair: a resumed run re-dispatches only tasks whose replayed status is pending (or that the
+    // journal never mentions). done, failed and human are all skipped alike, so rendering their preview
+    // picks must not advance the shared reviewHistory — a phantom draw wraps the LRU and makes a later
+    // pending task print the ranked-first seat while the journal's actual next draw is a later channel.
+    const taskStatuses = matchingRunId ? Journal.open(cwd, matchingRunId).replayStatuses() : new Map();
     const oracleRefusals = new Map();
     const oracleAdvisories = new Map();
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
@@ -306,10 +346,22 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         const policy = effectiveReviewPolicy(task.files, cfg.review);
         if (policy === "judge-only")
             return { line: "none — reviewPolicy judge-only: declared leaf paths", cost: 0 };
-        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor);
+        let rotationSeat = 1;
+        let rotationCount = 0;
+        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor, reviewHistory, (seat, count) => { rotationSeat = seat; rotationCount = count; });
         if (!reviewer)
             return { line: "none — no cross-vendor reviewer available", cost: 0 };
-        return { line: `${channelKey(reviewer)} — reviewPolicy full`, cost: seatCost(reviewer) };
+        // Advance the simulated rotation only for tasks the run would actually dispatch next — the same
+        // rule as readyTasks (src/graph/graph.ts): pending, with every dependency already done. A pending
+        // task behind a parked/failed/pending dependency cannot run, so it consumes no draw (RULING-229-14).
+        const isPending = (id) => { const s = taskStatuses.get(id); return s === undefined || s === "pending"; };
+        const ready = isPending(task.id) && task.deps.every((d) => taskStatuses.get(d) === "done");
+        if (hasRun && ready)
+            reviewHistory.push(channelKey(reviewer));
+        const rotationNote = rotationCount > 1
+            ? (hasRun ? ` (seat ${rotationSeat} of ${rotationCount})` : ` (seat 1 of ${rotationCount} — rotation applies at run time)`)
+            : "";
+        return { line: `${channelKey(reviewer)}${rotationNote} — reviewPolicy full`, cost: seatCost(reviewer) };
     };
     const routed = [];
     for (const t of g.tasks) {

package/dist/cli/commands/report.js

@@ -268,7 +268,9 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
                         pass = "pass (same-provider — independence not established)";
                     }
                 }
-                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}`);
+                const resolved = gate === "review" && g.data.pass === true && Array.isArray(g.data.resolved)
+                    ? g.data.resolved.filter((id) => typeof id === "string") : [];
+                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}${resolved.length ? `; resolved: ${resolved.join(", ")}` : ""}`);
             }
             for (const row of leg2) {
                 const pass = row.data.pass === true ? "pass" : row.data.pass === false ? "fail" : EM;

package/dist/cli/commands/run.d.ts

@@ -4,6 +4,11 @@ import { type JournalEvent } from "../../run/journal.js";
  *  it is a phase counter, while a phase-start CARRYING a gate is the gate start the rail draws. */
 export declare const TTY_NOISE_EVENTS: readonly ["worker-contact", "worker-status"];
 type RailTone = "pass" | "fail" | "attention" | "active" | "neutral";
+/** Approval-close lifecycle labels extend the established closed rail vocabulary. */
+export declare const APPROVAL_RAIL_ROWS: Record<string, {
+    label: string;
+    tone: RailTone;
+}>;
 /** Closed retained set: the short operator label and the row's default tone. Labels are the rail's
  *  own vocabulary — a raw journal event name is what this surface exists to stop printing. A `pass`
  *  or `ok` datum on the event overrides the default tone, so one gate row can read either way.

package/dist/cli/commands/run.js

@@ -33,6 +33,12 @@ const RAIL_TONES = {
     active: { glyph: GLYPHS.pointer, paint: LIVE.running },
     neutral: { glyph: GLYPHS.neutral, paint: LIVE.chrome },
 };
+/** Approval-close lifecycle labels extend the established closed rail vocabulary. */
+export const APPROVAL_RAIL_ROWS = {
+    "approval-window-start": { label: "approval window", tone: "attention" },
+    "approval-window-expired": { label: "approval window expired", tone: "attention" },
+    "tip-verify-cancelled": { label: "tip verify cancelled", tone: "attention" },
+};
 /** Closed retained set: the short operator label and the row's default tone. Labels are the rail's
  *  own vocabulary — a raw journal event name is what this surface exists to stop printing. A `pass`
  *  or `ok` datum on the event overrides the default tone, so one gate row can read either way.
@@ -116,8 +122,13 @@ export const RAIL_ROWS = {
     // gate starts and verdicts
     "phase-start": { label: "gate start", tone: "active" },
     "gate-result": { label: "gate", tone: "pass" },
+    "baseline-wait": { label: "baseline wait", tone: "active" },
+    "suite-budget": { label: "suite budget", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
     "judge-retry": { label: "judge retry", tone: "attention" },
+    "review-no-verdict": { label: "review unavailable", tone: "attention" },
+    "review-pool-demotion": { label: "review seat demoted", tone: "attention" },
+    "review-infra-retry": { label: "review infra retry", tone: "attention" },
     "review-retry": { label: "review retry", tone: "attention" },
     // repairs and escalations
     "repair-dispatch": { label: "repair", tone: "attention" },
@@ -304,6 +315,11 @@ const RAIL_PROJECTION = {
         ? `gated ${d.gatedCommit.slice(0, 12)}, tip ${d.branchTip.slice(0, 12)}`
         : undefined,
     "trust-auto-answer": (d) => typeof d.adapter === "string" ? `${d.adapter}${typeof d.phase === "string" ? ` ${d.phase}` : ""}` : undefined,
+    // SB-1: the census the ceiling released beside, and the budget the round ran under versus the one it
+    // would have had on an empty census — none of `{count, occupancyCap, conservativeCap}` is on the ladder
+    "suite-budget": (d) => typeof d.count === "number" && typeof d.conservativeCap === "number" && typeof d.occupancyCap === "number"
+        ? `beside ${d.count}, cap ${d.conservativeCap} not ${d.occupancyCap}`
+        : undefined,
 };
 // The row's text: the formatter's detail first, then the salient fields that detail could not carry.
 // Appending (never prefixing) keeps the operator's prose at the front of the row, so the clip a
@@ -330,7 +346,7 @@ const clipCells = (text, cells) => cells <= 0 ? "" : cellWidth(text) <= cells ?
 export function narrationRow(event, runId, columns = process.stdout.columns ?? 80) {
     if (TTY_NOISE_EVENTS.includes(event.event))
         return null;
-    const row = RAIL_ROWS[event.event];
+    const row = APPROVAL_RAIL_ROWS[event.event] ?? RAIL_ROWS[event.event];
     if (!row)
         return null;
     if (event.event === "phase-start" && typeof event.data.gate !== "string")

package/dist/compile/native.js

@@ -847,6 +847,9 @@ acceptance is required on every task (a nested list of observable outcomes).
       hard value anywhere in the domain, the criterion asserts a universal that may be FALSE ABOUT THE
       WORLD — bound it or say where it stops holding, rather than demanding a value that does not exist.
 
+    - A millisecond ceiling in a test is a BUDGET for the SLOWEST RUNNER.
+      Any ceiling under one second must carry a SLOWEST-RUNNER note and a member that OVERRUNS it.
+
   PICK THE CRITERION FORM FROM WHO COULD BE WRONG:
     - When the WORKER could be wrong because it can choose the value, use "test:" and pin the exact
       literal it could otherwise choose; an example selected by its implementer proves only itself.

package/dist/config/config.d.ts

@@ -240,6 +240,7 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
     gates: z.ZodObject<{
         build: z.ZodOptional<z.ZodString>;
         test: z.ZodOptional<z.ZodString>;
+        tipTest: z.ZodOptional<z.ZodString>;
         lint: z.ZodOptional<z.ZodString>;
         diffCap: z.ZodOptional<z.ZodNumber>;
         byShape: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -339,6 +340,11 @@ export type InitConfigOverlay = {
         llm?: TickmarkrConfig["visibility"]["llm"];
     };
 };
+/**
+ * Default config overlay template.
+ * Seam: gates.test defines the per-task gate and baseline test command;
+ * gates.tipTest optionally defines the integration tip verify test command (defaults to gates.test).
+ */
 export declare function configTemplate(overlay?: InitConfigOverlay): string;
 export { FLEET_OVERLAY_KEYS, fleetEditableEquals, fleetRepoOverlayFromDelta, renderFleetOverlayWrite, repoOverlayYaml, serializeFleetOverlay, unifiedYamlDiff, } from "./fleet-overlay.js";
 export type { FleetOverlayWrite } from "./fleet-overlay.js";

package/dist/config/config.js

@@ -337,6 +337,7 @@ export const TickmarkrConfigSchema = z.object({
     gates: z.object({
         build: z.string(),
         test: z.string(),
+        tipTest: z.string(),
         lint: z.string(),
         diffCap: z.number().int().positive(),
         byShape: z.partialRecord(z.enum(SHAPES), ShapeGateParticipationSchema).optional(),
@@ -756,6 +757,11 @@ export function overlayBytesLoadError(repoRoot, bytes, opts = {}) {
         return e.message;
     }
 }
+/**
+ * Default config overlay template.
+ * Seam: gates.test defines the per-task gate and baseline test command;
+ * gates.tipTest optionally defines the integration tip verify test command (defaults to gates.test).
+ */
 export function configTemplate(overlay) {
     const base = `# tickmarkr config overlay — merges over built-in defaults (repo beats global beats defaults)
 # concurrency: 3

package/dist/drivers/subprocess.d.ts

@@ -3,9 +3,8 @@ export declare const MAX_BUF: number;
 export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH", "ORCA_TERMINAL_HANDLE", "ORCA_PANE_KEY", "ORCA_TAB_ID"];
 /**
  * Copy of worker env with the fork cap applied and host control-plane vars stripped.
- * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
- * same machine the gate shells do, so both seams have to read the same run-owned number rather
- * than a flat constant. The operator's own export still wins.
+ * Workers retain the run's concurrency-derived cap (resolvedForkCap), independently of
+ * verification's suite-window budget. The operator's own export still wins.
  */
 export declare function sealHerdrEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Pane/login-shell form of the same host-neutral worker env seal (herdr seed + daemon setup). */

package/dist/drivers/subprocess.js

@@ -22,9 +22,8 @@ export const HERDR_CONTROL_VARS = [
 ];
 /**
  * Copy of worker env with the fork cap applied and host control-plane vars stripped.
- * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
- * same machine the gate shells do, so both seams have to read the same run-owned number rather
- * than a flat constant. The operator's own export still wins.
+ * Workers retain the run's concurrency-derived cap (resolvedForkCap), independently of
+ * verification's suite-window budget. The operator's own export still wins.
  */
 export function sealHerdrEnv(env = process.env) {
     const out = { ...env };

package/dist/gates/baseline.d.ts

@@ -31,6 +31,8 @@ export interface BaselineCommand {
     durationMs?: number;
     /** Sum of the per-file durations named by the runner; null when its output names none. */
     fileDurationSumMs?: number | null;
+    /** Total files reported by the runner summary; null when unavailable. */
+    fileCount?: number | null;
     /** fileDurationSumMs / durationMs — average implied file concurrency, not a configured fork count. */
     impliedParallelism?: number | null;
     /** The slowest per-file entry named by the runner; null when per-file timing is unavailable. */
@@ -158,6 +160,7 @@ export declare function detectVacuousOracles(cwd: string, tasks: ReadonlyArray<{
 }>): Promise<VacuousOracleWarning[]>;
 export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: {
     rerunOf?: HostStarvedRerun;
+    infraRerun?: HostStarvedRerun;
 }): Promise<GateResult[]>;
 export interface HostStarvedRerun {
     durationMs: number;
@@ -178,4 +181,10 @@ interface CalmWindow {
 }
 export declare function setCalmWindowForTests(over: Partial<CalmWindow>): void;
 export declare function resetCalmWindowForTests(): void;
+export declare function waitForCalmWindow(): Promise<number>;
+/** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */
+export declare function runnerFileCount(raw: string): number | null;
+export declare function fileCountDeficit(entry: BaselineCommand | undefined, raw: string): string | undefined;
+/** Both readers classify fresh evidence first, retaining the whole-output guard against infra forgiveness. */
+export declare function classifyFreshRunnerOutput(entry: BaselineCommand | undefined, raw: string, code: number): FailureClassification | undefined;
 export {};