tickmarkr 1.38.0 → 1.41.0

package/dist/gates/acceptance.d.ts

@@ -12,6 +12,7 @@ export interface JudgeVerdict {
 }
 export interface AcceptanceGateOpts {
     testCmd?: string;
+    diffCap?: number;
 }
 export declare function acceptanceGate(task: Task, worktree: string, baseRef: string, judge: {
     adapter: WorkerAdapter;

package/dist/gates/acceptance.js

@@ -1,8 +1,8 @@
 import { channelKey, shq } from "../adapters/types.js";
+import { DEFAULT_DIFF_CAP } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { sh, shOk } from "../run/git.js";
 import { extractJson, runLlm } from "./llm.js";
-const DIFF_CAP = 60_000; // judge sees diff + criteria only, and not unboundedly (spec §12)
 const isCommand = (a) => typeof a === "object" && a.oracle === "command";
 const isTest = (a) => typeof a === "object" && a.oracle === "test";
 const isJudge = (a) => typeof a === "string" || (typeof a === "object" && a.oracle === "judge");
@@ -57,7 +57,12 @@ export async function acceptanceGate(task, worktree, baseRef, judge, via, opts =
     const warn = onlyJudge
         ? "WARNING: only judge oracles — no deterministic command/test oracle guards this task (deterministic preferred, spec §2).\n"
         : "";
-    const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
+    const diff = await shOk(`git diff '${baseRef}..HEAD'`, worktree);
+    const diffCap = opts.diffCap ?? DEFAULT_DIFF_CAP;
+    if (diff.length > diffCap) {
+        return { gate: "acceptance", pass: false,
+            details: warn + detBlock + `diff exceeds verifiable cap (${diff.length} > ${diffCap}) — split the task, or raise gates.diffCap` };
+    }
     const prompt = `TICKMARKR-JUDGE
 You are a strict acceptance judge. Decide whether the diff satisfies EVERY acceptance criterion.
 Judge only what the diff proves — plausible-but-wrong must fail. Do not award partial credit.
@@ -87,6 +92,21 @@ Respond with ONLY this JSON (no prose before or after):
             details: warn + detBlock + "judge output unparseable — failing closed",
             meta: { unparseable: true, judge: channelKey({ adapter: judge.adapter.id, model: judge.model }) } };
     }
-    const lines = v.criteria.map((c) => `${c.met ? "✓" : "✗"} ${c.criterion}: ${c.reason}`);
-    return { gate: "acceptance", pass: v.pass, details: warn + detBlock + (lines.join("\n") || (v.pass ? "judge passed" : "judge failed")) };
+    const inconsistencies = [];
+    if (v.criteria.length !== judgeItems.length) {
+        inconsistencies.push(`judge verdict inconsistent: criteria count mismatch — expected ${judgeItems.length}, received ${v.criteria.length}`);
+    }
+    v.criteria.forEach((c, i) => {
+        if (!c || typeof c !== "object" || c.met !== true) {
+            inconsistencies.push(`judge verdict inconsistent: criteria[${i}].met must be true`);
+        }
+    });
+    const pass = v.pass === true && inconsistencies.length === 0;
+    const lines = v.criteria.map((c, i) => c && typeof c === "object"
+        ? `${c.met ? "✓" : "✗"} ${c.criterion}: ${c.reason}`
+        : `✗ criteria[${i}]: invalid criterion`);
+    if (!v.pass)
+        lines.push("judge verdict pass=false");
+    lines.push(...inconsistencies);
+    return { gate: "acceptance", pass, details: warn + detBlock + (lines.join("\n") || "judge passed") };
 }

package/dist/gates/baseline.js

@@ -6,20 +6,21 @@ import { sh } from "../run/git.js";
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
 // baselines stored by pre-hardening code.
 const ANSI_RE = /\x1b\[[\d;#]*[A-Za-z]/g;
-// ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest) counts as a pass line — other
-// runners' pass markers (PASS, ok) stay fingerprintable; extend the regex when a real one bites
-const PASS_LINE_RE = /^\s*(?:[\w@./-]+:\s*)*[✓✔]/;
+// ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest), or tickmarkr's own run
+// summary, counts as a pass line — other runners' pass markers (PASS, ok) stay fingerprintable
+const PASS_LINE_RE = /^\s*(?:(?:[\w@./-]+:\s*)*[✓✔]|(?:\[tickmarkr\]\s+)?(?:tickmarkr\s+[\w.-]+:\s+)?(?:\d+|#)\s+done,\s+(?:\d+|#)\s+failed(?:,\s+(?:\d+|#)\s+awaiting human)?\b)/;
 // HYG-08 (D-01, incident run-20260711-154920): a failing test went unnamed for 3 attempts because details
 // headlined benign fingerprint-diff noise. These anchors harvest the runner's OWN failure naming from fresh
 // output to headline it. \s is fine in a TS regex — the BSD [[:space:]] rule binds shell grep only.
-const FAIL_ANCHOR_RE = /^\s*FAIL\s+/; // vitest/jest: " FAIL  <file> > <suite> > <test>"
+// OBS-42: vitest's diagnostic failure headings are shared anchors for baseline and tip verification.
+const FAIL_ANCHOR_RE = /^\s*(?:FAIL\s+|[^\w]*(?:Unhandled Errors|Uncaught Exception)\b)/;
 const SUMMARY_FAIL_RE = /^\s*Tests?\s+(?:Files?\s+)?\d+\s+failed/; // " Tests  N failed | M passed (T)"
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
 export function fingerprint(output) {
     const lines = output
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
-        .filter((l) => !PASS_LINE_RE.test(l) && /\b(error|fail(ed|ure|ing)?)\b/i.test(l))
+        .filter((l) => !PASS_LINE_RE.test(l) && (FAIL_ANCHOR_RE.test(l) || /\b(error|fail(ed|ure|ing)?)\b/i.test(l)))
         .map(normalizeLine);
     return [...new Set(lines)];
 }
@@ -84,7 +85,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         }
         const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
         const known = new Set((baseline.commands[name]?.fingerprints ?? []).map(renormalize));
-        const fresh = fingerprint(raw).filter((f) => !known.has(f));
+        // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
+        const fresh = fingerprint(raw).filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
         if (!fresh.length && (baseline.commands[name]?.exitCode ?? 1) === 0) {
             results.push({
                 gate: name,

package/dist/gates/review.js

@@ -1,5 +1,5 @@
 import { channelKey } from "../adapters/types.js";
-import { TIER_RANK } from "../config/config.js";
+import { DEFAULT_DIFF_CAP, TIER_RANK } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
@@ -27,7 +27,6 @@ export function pickReviewer(author, channels, exclude = []) {
         .filter((c) => c.vendor !== authorChannel.vendor && modelId(c.model) !== modelId(author.model) && !exclude.includes(channelKey(c)))
         .sort((a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b))[0] ?? null);
 }
-const DIFF_CAP = 60_000;
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers) {
     if (task.complexity < cfg.review.complexityThreshold) {
         return { gate: "review", pass: true, details: `skipped — complexity ${task.complexity} < threshold ${cfg.review.complexityThreshold}`, meta: { skipped: true } };
@@ -38,7 +37,12 @@ export async function reviewGate(task, worktree, baseRef, author, channels, adap
             ? { gate: "review", pass: false, details: "no cross-vendor reviewer available (diversity rule); set review.required:false to waive" }
             : { gate: "review", pass: true, details: "WARNING: no cross-vendor reviewer available — review waived by config" };
     }
-    const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
+    const diff = await shOk(`git diff '${baseRef}..HEAD'`, worktree);
+    const diffCap = cfg.gates.diffCap ?? DEFAULT_DIFF_CAP;
+    if (diff.length > diffCap) {
+        return { gate: "review", pass: false,
+            details: `diff exceeds verifiable cap (${diff.length} > ${diffCap}) — split the task, or raise gates.diffCap` };
+    }
     const prompt = `TICKMARKR-REVIEW
 You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
 Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
@@ -56,14 +60,14 @@ Respond with ONLY this JSON:
 {"approve": true|false, "issues": ["..."]}
 `;
     const raw = await runLlm(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? { driver: via.driver, keep: via.keep, onSlot: via.onSlot, name: via.nameFor("review", reviewer.adapter), label: via.labelFor("review") } : undefined, 
-    // frontier reviewers routinely need >5min on a DIFF_CAP-sized diff, and `claude -p` buffers all
+    // frontier reviewers routinely need >5min on a configured-cap-sized diff, and `claude -p` buffers all
     // output until completion — runLlm's 300s default killed reviews mid-flight, returning empty
     // stdout that read as "unparseable" and escalated to re-implementation of green code
     // (run-20260709-104447 P87-09). ponytail: literal 15min; make it cfg.review.timeoutMs if a
     // second knob-turner appears.
     900_000);
     const v = extractJson(raw);
-    if (!v || typeof v.approve !== "boolean") {
+    if (!v || typeof v.approve !== "boolean" || !Array.isArray(v.issues)) {
         return {
             gate: "review",
             pass: false,
@@ -71,10 +75,25 @@ Respond with ONLY this JSON:
             meta: { reviewer: channelKey(reviewer) },
         };
     }
+    const issues = v.issues;
+    const inconsistencies = [];
+    issues.forEach((issue, i) => {
+        if (typeof issue !== "string")
+            inconsistencies.push(`review verdict inconsistent: issues[${i}] must be a string`);
+    });
+    if (v.approve && issues.length) {
+        inconsistencies.push("review verdict inconsistent: approve=true requires issues to be empty");
+    }
+    else if (!v.approve && !issues.length) {
+        inconsistencies.push("review verdict inconsistent: approve=false requires at least one issue");
+    }
+    const pass = v.approve === true && inconsistencies.length === 0;
+    const lines = issues.map((issue) => `- ${typeof issue === "string" ? issue : JSON.stringify(issue)}`);
+    lines.push(...inconsistencies);
     return {
         gate: "review",
-        pass: v.approve,
-        details: `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${v.approve ? "approved" : "requested changes"}${v.issues?.length ? "\n" + v.issues.map((i) => `- ${i}`).join("\n") : ""}`,
+        pass,
+        details: `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${pass ? "approved" : v.approve ? "approval rejected" : "requested changes"}${lines.length ? "\n" + lines.join("\n") : ""}`,
         meta: { reviewer: channelKey(reviewer) },
     };
 }

package/dist/gates/run-gates.js

@@ -63,7 +63,7 @@ export async function runGates(task, ctx) {
             : undefined;
         // v1.19 (T2): testCmd threads the detected test runner to the gate so named-test oracles run
         // deterministically (filtered via -t) before any LLM judge dispatch.
-        let a = await acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: judgeAdapter, model: ctx.cfg.judge.model }, jvia, { testCmd: ctx.commands.test });
+        let a = await acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: judgeAdapter, model: ctx.cfg.judge.model }, jvia, { testCmd: ctx.commands.test, diffCap: ctx.cfg.gates.diffCap });
         // GATE-09: an unparseable judge verdict retries the JUDGE exactly once on a failover channel — never
         // the worker (run-20260711-185020 P43-03 L70-72 billed a judge flake as a worker attempt). The flaked
         // first verdict NEVER enters results (no false gate-result journal event, no operator notify, no stale
@@ -89,7 +89,7 @@ export async function runGates(task, ctx) {
                 ? { driver: ctx.via.driver, keep: ctx.via.keep, onSlot: ctx.via.onSlot, name: ctx.via.nameFor("judge", retryAdapter.id) + "-r1", label: ctx.via.labelFor("judge") }
                 : undefined;
             // the retry IS a second acceptanceGate call: one code path, one parser, zero new parse leniency.
-            a = await acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: retryAdapter, model: retry.model }, retryJvia, { testCmd: ctx.commands.test });
+            a = await acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: retryAdapter, model: retry.model }, retryJvia, { testCmd: ctx.commands.test, diffCap: ctx.cfg.gates.diffCap });
             a = { ...a, meta: { ...a.meta, judgeRetry: { flaked: flakedKey, retried: channelKey({ adapter: retry.adapter, model: retry.model }) } } };
         }
         await record(a);

package/dist/graph/schema.d.ts

@@ -77,6 +77,7 @@ export declare const TaskSchema: z.ZodObject<{
         escalate: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     humanGate: z.ZodDefault<z.ZodBoolean>;
+    timeoutMinutes: z.ZodOptional<z.ZodNumber>;
     status: z.ZodDefault<z.ZodEnum<{
         pending: "pending";
         running: "running";
@@ -161,6 +162,7 @@ export declare const RunGraphSchema: z.ZodObject<{
             escalate: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         humanGate: z.ZodDefault<z.ZodBoolean>;
+        timeoutMinutes: z.ZodOptional<z.ZodNumber>;
         status: z.ZodDefault<z.ZodEnum<{
             pending: "pending";
             running: "running";

package/dist/graph/schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 export const SHAPES = ["plan", "spec", "implement", "tests", "docs", "migration", "ui", "refactor", "chore"];
 export const STATUSES = ["pending", "running", "gated", "failed", "done", "human"];
 export const GATE_NAMES = ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
+const MANDATORY_GATES = ["build", "test", "lint", "evidence", "scope"];
 export const TIERS = ["cheap", "mid", "frontier"];
 // v1.19 acceptance oracles: command (exit code), test (named test), judge (LLM, free-text rubric).
 // A plain string is the read-old/write-new compat form — semantically a judge oracle (spec §2).
@@ -51,7 +52,19 @@ export const TaskSchema = z.object({
         reason: z.string().optional(),
     }))
         .optional(),
-    gates: z.array(z.enum(GATE_NAMES)).default(["build", "test", "lint", "evidence", "scope", "acceptance", "review"]),
+    gates: z
+        .array(z.enum(GATE_NAMES))
+        .default(["build", "test", "lint", "evidence", "scope", "acceptance", "review"])
+        .superRefine((gates, ctx) => {
+        for (const gate of MANDATORY_GATES) {
+            if (!gates.includes(gate)) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: `${gate} is a mandatory fail-closed gate invariant and cannot be omitted from task gates`,
+                });
+            }
+        }
+    }),
     routingHints: z
         .object({
         pin: z.object({ via: z.string(), model: z.string() }).optional(),
@@ -61,6 +74,8 @@ export const TaskSchema = z.object({
     })
         .optional(),
     humanGate: z.boolean().default(false),
+    // v1.39 OBS-37b: per-task worker window override; absent ⇒ config taskTimeoutMinutes.
+    timeoutMinutes: z.number().positive().optional(),
     status: z.enum(STATUSES).default("pending"),
     evidence: z
         .object({

package/dist/run/consult.d.ts

@@ -5,8 +5,11 @@ import type { GateResult } from "../gates/types.js";
 export interface ConsultVerdict {
     action: "retry" | "reroute" | "decompose" | "human";
     notes: string;
+    reason?: string;
+    guidance?: string;
     excludeAdapter?: string;
 }
+export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export interface Dossier {
     taskId: string;
     trigger: string;

package/dist/run/consult.js

@@ -3,6 +3,21 @@ import { join } from "node:path";
 import { getAdapter } from "../adapters/registry.js";
 import { extractJson, gatePaneName } from "../gates/llm.js";
 import { sh } from "./git.js";
+const MAX_RETRY_GUIDANCE_LINES = 10;
+function guidanceParts(text) {
+    return text.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((s) => s.trim()).filter(Boolean);
+}
+// OBS-37a: retry worker prompts get structured bullets only — never the consult's raw notes prose
+// (herdr false-blocked when consult verdict text was echoed verbatim in a cursor worker prompt).
+export function renderRetryGuidance(v) {
+    const lines = [`Action: ${v.action}`];
+    if (v.reason)
+        lines.push(`Reason: ${v.reason}`);
+    const body = v.guidance ?? (v.reason ? "" : v.notes);
+    for (const part of guidanceParts(body))
+        lines.push(part);
+    return lines.slice(0, MAX_RETRY_GUIDANCE_LINES).map((l) => `- ${l}`).join("\n");
+}
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
 export function buildDossierPrompt(d) {
     return `TICKMARKR-CONSULT
@@ -32,7 +47,7 @@ trust dialog, broken install) — not when a single model produced bad code. Omi
 reroutes so other models of the same adapter remain eligible.
 
 Respond with ONLY this JSON:
-{"action": "retry" | "reroute" | "decompose" | "human", "notes": "one short paragraph of guidance", "excludeAdapter"?: "<adapter-id>"}
+{"action": "retry" | "reroute" | "decompose" | "human", "reason": "why this action", "guidance": "imperative steps for the worker (newline-separated ok)", "excludeAdapter"?: "<adapter-id>"}
 `;
 }
 let consultSeq = 0;
@@ -76,5 +91,14 @@ opts = {}) {
     // zero-match expansion as channel-level reroute.
     const raw = v.excludeAdapter;
     const excludeAdapter = typeof raw === "string" && raw.length > 0 ? raw : undefined;
-    return { action: v.action, notes: String(v.notes ?? ""), ...(excludeAdapter ? { excludeAdapter } : {}) };
+    const reason = typeof v.reason === "string" ? v.reason : undefined;
+    const guidance = typeof v.guidance === "string" ? v.guidance : undefined;
+    const notes = String(v.notes ?? guidance ?? reason ?? "");
+    return {
+        action: v.action,
+        notes,
+        ...(reason ? { reason } : {}),
+        ...(guidance ? { guidance } : {}),
+        ...(excludeAdapter ? { excludeAdapter } : {}),
+    };
 }

package/dist/run/daemon.js

@@ -10,7 +10,7 @@ import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands } from "../gates/baseline.js";
 import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
-import { consult } from "./consult.js";
+import { consult, renderRetryGuidance } from "./consult.js";
 import { cleanupRunWorktrees, gitHead, sh } from "./git.js";
 import { Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
@@ -159,6 +159,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         };
         const execTask = async (t) => {
             const startMs = Date.now();
+            const taskTimeoutMinutes = t.timeoutMinutes ?? cfg.taskTimeoutMinutes;
             if (t.humanGate && !approved.has(t.id)) {
                 // GATE-08: the condition is the APPROVAL, never the code path. `!opts.resume` (or any run-phase
                 // term) would silently dispatch every unapproved gate that becomes ready during a resume — pinned
@@ -252,11 +253,13 @@ export async function runDaemon(repoRoot, opts = {}) {
             const applyVerdict = async (v, attempts, trigger) => {
                 journal.append("consult-verdict", t.id, {
                     action: v.action, notes: v.notes,
+                    ...(v.reason ? { reason: v.reason } : {}),
+                    ...(v.guidance ? { guidance: v.guidance } : {}),
                     ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
                 });
                 await driver.notify(`tickmarkr ${runId}: ${t.id} consult verdict: ${v.action}`, { tier: "attention" });
                 if (v.action === "retry") {
-                    feedback = v.notes || feedback;
+                    feedback = renderRetryGuidance(v) || feedback;
                     return true;
                 }
                 if (v.action === "reroute") {
@@ -404,7 +407,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     finished = false;
                     exitCode = null;
                     output = "";
-                    const deadline = Date.now() + cfg.taskTimeoutMinutes * 60_000;
+                    const deadline = Date.now() + taskTimeoutMinutes * 60_000;
                     while (Date.now() < deadline) {
                         const sliceStart = Date.now();
                         const slice = Math.min(BLOCKED_POLL_MS, deadline - sliceStart);
@@ -473,11 +476,21 @@ export async function runDaemon(repoRoot, opts = {}) {
                 else {
                     const inv = adapter.invoke(t, wt, assignment, { promptFile });
                     await driver.run(slot, `${inv.command}; ${exitMarkerCmd}`);
-                    finished = await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, cfg.taskTimeoutMinutes * 60_000, { regex: true });
+                    finished = await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, taskTimeoutMinutes * 60_000, { regex: true });
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
                 }
-                if (keepOpen)
+                // SPEND-01 interactive metering race: the harvest loop breaks on the trailer, but the worker
+                // shell may still be running post-trailer bookkeeping (session-store flush, fake usage stamp,
+                // exit wrapper). Print mode already waits for TICKMARKR_EXIT, which follows that tail; drain
+                // interactive attempts to the same exit marker before close and the post-hoc usage disk read
+                // so a writer never races the reader (real CLIs can flush usage asynchronously after the trailer).
+                if (interactive && finished && !exitRe.test(output)) {
+                    await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, 2_000, { regex: true });
+                }
+                // keepPanes retains visible context, not a timed-out subprocess tree. Close before consult/retry
+                // can recreate the worktree; Herdr and subprocesses that reached their exit marker stay unchanged.
+                if (keepOpen && (finished || driver.id !== "subprocess"))
                     keptSlots.push(slot);
                 else
                     await driver.close(slot);
@@ -536,7 +549,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     journal.telemetry({ taskId: t.id, shape: t.shape, adapter: assignment.adapter, model: assignment.model, channel: assignment.channel, attempts: attempt + 1, outcome: "failed", durationMs: 0, overrun: true, retryMode });
                     const v = await runConsult("stall", output, exitCode !== null && interactive
                         ? `worker process exited (code ${exitCode}) without a trailer`
-                        : `no completion marker within ${cfg.taskTimeoutMinutes}m`, []);
+                        : `no completion marker within ${taskTimeoutMinutes}m`, []);
                     if (await applyVerdict(v, attempt + 1, "stall"))
                         continue;
                     return;
@@ -710,7 +723,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // OBS-34: post-merge integration-tip verify — strict exit codes, no baseline forgiveness.
         const lastMergedTask = [...journal.read()].reverse().find((e) => e.event === "merge" && e.taskId)?.taskId;
         if (summary.done.length > 0 && Object.keys(commands).length > 0) {
-            const tipResults = await verifyIntegrationTip(intWt, commands);
+            const tipResults = await verifyIntegrationTip(intWt, commands, journal.dir);
             let tipFailed = false;
             for (const r of tipResults) {
                 if (r.pass) {
@@ -722,6 +735,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         cmd: r.cmd,
                         exitCode: r.exitCode,
                         fingerprints: r.fingerprints,
+                        artifact: r.artifact,
                         lastMergedTask,
                     });
                     tipFailed = true;

package/dist/run/git.d.ts

@@ -16,4 +16,5 @@ export declare function cleanupRunWorktrees(repo: string, branch: string, opts:
 }): Promise<void>;
 export declare function resolveIntegrationBranch(_repo: string, branch: string): Promise<string>;
 export declare function createWorktree(repo: string, branch: string, baseRef: string): Promise<string>;
+export declare function linkNodeModules(repo: string, dir: string): void;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;

package/dist/run/git.js

@@ -78,7 +78,7 @@ export async function createWorktree(repo, branch, baseRef) {
 }
 // best-effort: devDep-based gates (tsx, vitest) shell out root-anchored and ENOENT in a bare
 // fresh worktree (OBS-27); failure here must never fail worktree creation
-function linkNodeModules(repo, dir) {
+export function linkNodeModules(repo, dir) {
     const src = join(repo, "node_modules");
     const dest = join(dir, "node_modules");
     if (!existsSync(src) || existsSync(dest))

package/dist/run/merge.d.ts

@@ -6,6 +6,7 @@ export interface TipVerifyResult {
     exitCode: number;
     fingerprints: string[];
     details: string;
+    artifact?: string;
 }
 export declare function integrationBranch(cfg: TickmarkrConfig, runId: string): string;
 export declare function ensureIntegration(repo: string, branch: string, baseRef: string): Promise<string>;
@@ -18,4 +19,4 @@ export declare function mergeTask(intWt: string, taskBranch: string, message: st
         branchTip: string;
     };
 }>;
-export declare function verifyIntegrationTip(intWt: string, commands: Record<string, string>): Promise<TipVerifyResult[]>;
+export declare function verifyIntegrationTip(intWt: string, commands: Record<string, string>, runDir: string): Promise<TipVerifyResult[]>;

package/dist/run/merge.js

@@ -1,9 +1,9 @@
-import { existsSync } from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { fingerprint } from "../gates/baseline.js";
 import { tickmarkrDir } from "../graph/graph.js";
-import { gitHead, resolveIntegrationBranch, sh, shOk } from "./git.js";
+import { gitHead, linkNodeModules, resolveIntegrationBranch, sh, shOk } from "./git.js";
 export function integrationBranch(cfg, runId) {
     return `${cfg.integrationBranchPrefix}${runId}`;
 }
@@ -11,15 +11,16 @@ const sanitize = (branch) => branch.replace(/[^\w.-]+/g, "-");
 export async function ensureIntegration(repo, branch, baseRef) {
     branch = await resolveIntegrationBranch(repo, branch);
     const dir = join(tickmarkrDir(repo), "worktrees", sanitize(branch));
-    if (existsSync(join(dir, ".git")))
-        return dir; // resume: keep existing tip
-    const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
-    if (exists) {
-        await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
-    }
-    else {
-        await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+    if (!existsSync(join(dir, ".git"))) {
+        const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
+        if (exists) {
+            await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
+        }
+        else {
+            await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+        }
     }
+    linkNodeModules(repo, dir);
     return dir;
 }
 export function integrationHead(intWt) {
@@ -44,18 +45,22 @@ export async function mergeTask(intWt, taskBranch, message, gatedCommit) {
     return { ok: false, conflict };
 }
 // OBS-34: strict exit-code verify on the integration tip — no baseline forgiveness.
-export async function verifyIntegrationTip(intWt, commands) {
+export async function verifyIntegrationTip(intWt, commands, runDir) {
     const results = [];
     for (const [gate, cmd] of Object.entries(commands)) {
         const r = await sh(cmd, intWt);
-        const raw = (r.stdout + "\n" + r.stderr).split(intWt).join("");
+        const raw = r.stdout + "\n" + r.stderr;
+        const artifact = r.code !== 0 ? join(runDir, `tip-verify-${gate}.log`) : undefined;
+        if (artifact)
+            writeFileSync(artifact, raw);
         results.push({
             gate,
             cmd,
             pass: r.code === 0,
             exitCode: r.code,
-            fingerprints: r.code !== 0 ? fingerprint(raw) : [],
+            fingerprints: r.code !== 0 ? fingerprint(raw.split(intWt).join("")) : [],
             details: r.code === 0 ? "exit 0" : `exit ${r.code}`,
+            ...(artifact ? { artifact } : {}),
         });
     }
     return results;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.38.0",
+  "version": "1.41.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",

package/schema/rungraph.schema.json

@@ -244,6 +244,10 @@
             "default": false,
             "type": "boolean"
           },
+          "timeoutMinutes": {
+            "type": "number",
+            "exclusiveMinimum": 0
+          },
           "status": {
             "default": "pending",
             "type": "string",

package/skills/tickmarkr-auto/SKILL.md

@@ -12,12 +12,16 @@ Use this to execute a requested sequence of repository specs. It is SDD-agnostic
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR and run the loop below.
-- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a verified send, then supervise it as OVERSEER.
-- **Primary session without an orchestrator:** rename your own tab OVERSEER, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
+- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
 
 Outside a multi-agent terminal environment, run the loop directly.
 
+## Stand-down (mission end and retirement)
+
+On each mission's terminal state, after the record commit and operator notification: the orchestrator stops every monitor and background task it started, prints one final stand-down line, and leaves nothing queued in its input box. A finished session with an armed watcher or pre-filled input is a loaded gun.
+
 ## Invariants
 
 - Never run two tickmarkr runs in the same repository concurrently.
@@ -30,9 +34,30 @@ Outside a multi-agent terminal environment, run the loop directly.
 
 Run every requested target in order without seeking routine confirmation. Stop only for a blocked agent interaction, a genuinely unresolved stalled task, a designed human gate, or a failed run that needs a human decision. Diagnose from the journal and evidence first; self-release and resume only after fixing and verifying a harness defect.
 
+## Binary preflight (before compile or run)
+
+Before `tickmarkr compile` or `tickmarkr run`, compare the installed binary against the repository's `package.json` version:
+
+1. Run `tickmarkr version` (one line, machine-parseable).
+2. Read the `version` field from the repository's `package.json`.
+3. If the binary is **older on major.minor** than the repo (e.g. binary `1.36.x` vs repo `1.38.x`), **stop immediately** and tell the operator to update the global install (`npm i -g tickmarkr@latest`) or link the repo binary. Do not compile, plan, or run on hope.
+
+A stale binary silently skips daemon gates shipped in newer releases — the v1.38 run exposed this when a global `1.36.0` binary missed the daemon tip-verify gate entirely (OBS-38). Preflight failure is always stop-and-report; never proceed-and-hope.
+
+## Verified handoffs (agent-to-agent messaging)
+
+When relaying missions between agents in a multi-agent terminal, **never use bare send-text** (`herdr agent send` / pane send-text) — it writes text without pressing Enter, so handoffs sit unsubmitted (OBS-39).
+
+Use one of:
+
+- `herdr pane run <pane> "<message>"` — text plus Enter in the target shell
+- `herdr notification show "<message>"` — OS-level delivery for the operator
+
+After sending, **confirm delivery** by reading the target pane and verifying the message landed (input empty, agent status `working`, or notification acknowledged). Never report "briefed" or "relayed" without read-back confirmation.
+
 ## Per-spec loop
 
-1. **Prepare** — confirm the target list, check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
+1. **Prepare** — confirm the target list. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
 4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than polling agents. Resolve blocked interactions in the relevant agent session.

package/skills/tickmarkr-loop/SKILL.md

@@ -11,9 +11,9 @@ Use this for any spec that `tickmarkr compile` accepts. It is SDD-agnostic: use
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR and run the loop below.
-- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a verified send, then supervise it as OVERSEER.
-- **Primary session without an orchestrator:** rename your own tab OVERSEER, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
+- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has [stood down](#stand-down-mission-end-and-retirement) and close its tab.
 
 Outside a multi-agent terminal environment, run the loop directly.
 
@@ -29,11 +29,37 @@ Outside a multi-agent terminal environment, run the loop directly.
 
 Proceed through the loop without seeking routine confirmation. Stop only for a blocked agent interaction, a genuinely unresolved stalled task, or a designed human gate. Diagnose from the journal and available evidence before escalating; if a harness defect is fixed and verified, resume the run.
 
+## Binary preflight (before compile or run)
+
+Before `tickmarkr compile` or `tickmarkr run`, compare the installed binary against the repository's `package.json` version:
+
+1. Run `tickmarkr version` (one line, machine-parseable).
+2. Read the `version` field from the repository's `package.json`.
+3. If the binary is **older on major.minor** than the repo (e.g. binary `1.36.x` vs repo `1.38.x`), **stop immediately** and tell the operator to update the global install (`npm i -g tickmarkr@latest`) or link the repo binary. Do not compile, plan, or run on hope.
+
+A stale binary silently skips daemon gates shipped in newer releases — the v1.38 run exposed this when a global `1.36.0` binary missed the daemon tip-verify gate entirely (OBS-38). Preflight failure is always stop-and-report; never proceed-and-hope.
+
+## Verified handoffs (agent-to-agent messaging)
+
+When relaying missions between agents in a multi-agent terminal, **never use bare send-text** (`herdr agent send` / pane send-text) — it writes text without pressing Enter, so handoffs sit unsubmitted (OBS-39).
+
+Use one of:
+
+- `herdr pane run <pane> "<message>"` — text plus Enter in the target shell
+- `herdr notification show "<message>"` — OS-level delivery for the operator
+
+After sending, **confirm delivery** by reading the target pane and verifying the message landed (input empty, agent status `working`, or notification acknowledged). Never report "briefed" or "relayed" without read-back confirmation.
+
+## Stand-down (mission end and retirement)
+
+- **Orchestrator, on terminal state** (green, failed, or parked), after the record commit and operator notification: stop every monitor and background task you started, print one final stand-down line, and leave NOTHING queued in your input box. A finished session with an armed watcher or pre-filled input is a loaded gun — a retired v1.40 orchestrator sat idle with "merge … tag, publish" unsent in its input; one stray Enter would have shipped a duplicate release.
+- **Supervisor, when a mission completes** (and always before spawning the next orchestrator): verify the orchestrator stood down, then close its tab. The journal, execution record, OBS ledger, and memory hold the story; pane scrollback is disposable. Never leave a retired agent idle with watchers armed.
+
 ## The loop
 
-1. **Prepare** — start from the requested spec. Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
+1. **Prepare** — start from the requested spec. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
 4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than repeatedly polling agents. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
 5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal AND the tip verify is not "failed". Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
-6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.
+6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).