tickmarkr 1.72.0 → 1.74.0

package/dist/drivers/herdr.js

@@ -10,6 +10,8 @@ export const TRAILER_WIDTH_MARGIN = 2; // cols below (floor + margin) refuse a r
 export const DELIVERY_ATTEMPTS = 3;
 const DELIVERY_VERIFY_TIMEOUT_MS = 2000; // per attempt — a paste that hasn't rendered in 2s is retyped
 const DELIVERY_READ_LINES = 80;
+const DELIVERY_SETTLE_READ_ATTEMPTS = 6;
+const DELIVERY_SETTLE_POLL_MS = 100;
 /** First-generation join direction from measured trailer-safe floor (43-MEASUREMENT.md). */
 export function workerSplitDirection(paneCols, safeFloor = TRAILER_SAFE_FLOOR_COLS, margin = TRAILER_WIDTH_MARGIN) {
     if (paneCols == null || paneCols <= 0)
@@ -25,8 +27,11 @@ export class HerdrDriver {
     // grouped slot()/close() mutate shared group state across awaits — serialize them so two
     // concurrent first members can never both create the group tab (mergeSerial idiom, daemon.ts)
     groupSerial = Promise.resolve();
-    // OBS-119: concurrent deliveries contend on herdr's send path — one chain per driver (mergeSerial idiom)
+    // OBS-120: canonical dispatch slots hold this chain from allocation through verified binding and
+    // delivery. Legacy/manual slots still serialize each delivery on the same chain (OBS-119).
     deliverySerial = Promise.resolve();
+    dispatchLeases = new WeakMap();
+    deliveredPanes = new WeakMap();
     // VIS-10: the run's workspace id, captured once at construction (the daemon inherits it from the
     // operator's env before the driver is built). Required at slot() time, never in the constructor —
     // pickDriver and its unit test construct HerdrDriver without env, so slot() is the trust gate.
@@ -47,6 +52,41 @@ export class HerdrDriver {
         this.deliverySerial = p.catch(() => undefined);
         return p;
     }
+    // OBS-120: ExecutorDriver exposes slot() and run() separately, so a canonical tickmarkr slot
+    // carries a lease across that API seam. The next dispatch cannot allocate until this slot's first
+    // run either delivers or fails. Allocation errors release immediately; no failed dispatch poisons
+    // the queue. The daemon calls run() directly after preparing the command for every owned slot.
+    reserveDispatch(allocate) {
+        let release;
+        const held = new Promise((resolve) => { release = resolve; });
+        const start = this.deliverySerial.then(() => undefined, () => undefined);
+        this.deliverySerial = start.then(() => held);
+        return start.then(async () => {
+            let slot;
+            try {
+                slot = await allocate();
+                this.dispatchLeases.set(slot, { release });
+                return slot;
+            }
+            catch (error) {
+                if (slot) {
+                    try {
+                        await this.close(slot);
+                    }
+                    catch { /* allocation already failed closed; cleanup is best-effort */ }
+                }
+                release();
+                throw error;
+            }
+        });
+    }
+    async verifyPaneIdentityBinding(slot) {
+        const paneId = await this.namedPaneId(slot.name);
+        if (paneId !== slot.id) {
+            throw new Error(`herdr pane identity binding verification failed for ${slot.name}: allocated ${slot.id}, resolved ${paneId ?? "none"} — refusing delivery`);
+        }
+        return paneId;
+    }
     // ponytail: narrow panes hard-wrap the input line — collapse whitespace before comparing.
     deliveryMatches(transcript, cmd) {
         const norm = (s) => s.replace(/\s+/g, "");
@@ -78,8 +118,12 @@ export class HerdrDriver {
             return null;
         }
     }
-    // pane ids compact when panes close — resolve fresh via the durable agent name (spec §5)
+    // Before delivery, resolve fresh via the durable name because pane ids can compact. After delivery,
+    // pin the verified target so early liveness cannot drift to a label rebound onto another pane.
     async paneId(slot) {
+        const delivered = this.deliveredPanes.get(slot);
+        if (delivered)
+            return delivered;
         return await this.namedPaneId(slot.name) ?? slot.id;
     }
     // VIS-09 P43-03: runtime width for the layout gate (43-MEASUREMENT.md licensing condition 2).
@@ -104,12 +148,18 @@ export class HerdrDriver {
         // reconcile.ts and this driver's own renameGroupTab/glyphFor decode role/taskId/attempt from
         // those shapes without a call-site migration; T2 retires this branch by always passing `owned`.
         const resolved = opts?.owned ? formatOwnedName(opts.owned) : name;
+        const allocate = opts?.group
+            ? () => this.serial(() => this.groupSlot(cwd, resolved, opts.group))
+            : () => this.tabSlot(cwd, resolved, opts?.label);
+        // Production dispatch names are canonical even when the gate call site supplies the already-
+        // formatted name rather than SlotOpts.owned. Hold one lease across slot() → run(); legacy/manual
+        // slots retain their existing allocation-only semantics for compatibility.
+        if (parseOwnedName(resolved))
+            return this.reserveDispatch(allocate);
         // group wins if both are set (a group tab is already stage-labeled; passing both is a caller bug).
         // label (without group) → dedicated labeled tab via tabSlot's third param: no groups-map entry, no
         // refcount, no groupSerial, no degrade latch — dedicated tabs have no shared state to guard (SUP-01).
-        if (opts?.group)
-            return this.serial(() => this.groupSlot(cwd, resolved, opts.group));
-        return this.tabSlot(cwd, resolved, opts?.label); // label undefined → defaults to name (today's behavior)
+        return allocate(); // label undefined → defaults to name (today's behavior)
     }
     // today's per-slot tab path, plus the VIS-04 orphan reap
     // label defaults to the slot name; group tabs pass the STAGE name instead — a first-member label
@@ -320,15 +370,40 @@ export class HerdrDriver {
     // cleared (C-u), and retyped, bounded; persistent corruption fails closed WITH the captured
     // transcript — the dispatch-time pincer the ledger asks for, not post-hoc `git:` archaeology.
     async run(slot, cmd) {
-        return this.deliveryQueue(() => this.deliver(slot, cmd));
+        const lease = this.dispatchLeases.get(slot);
+        if (lease) {
+            this.dispatchLeases.delete(slot);
+            try {
+                const paneId = await this.verifyPaneIdentityBinding(slot);
+                await this.deliver(slot, cmd, paneId);
+                this.deliveredPanes.set(slot, paneId);
+            }
+            finally {
+                lease.release();
+            }
+            return;
+        }
+        return this.deliveryQueue(async () => {
+            const paneId = await this.paneId(slot);
+            await this.deliver(slot, cmd, paneId);
+            this.deliveredPanes.set(slot, paneId);
+        });
     }
-    async deliver(slot, cmd) {
-        const pane = await this.paneId(slot);
+    async deliver(slot, cmd, pane) {
         let transcript = "";
         for (let attempt = 0; attempt < DELIVERY_ATTEMPTS; attempt++) {
             if (attempt > 0) {
-                // clear the corrupted input line before retyping; a failed clear must NOT be retyped onto —
-                // corrupt-prefix + clean-retype would concatenate and false-verify by containment
+                // A TUI may still be painting while the failed delivery is captured (OBS-135). Judge the
+                // line only after two consecutive pane reads agree; an already-stable frame returns on the
+                // first fresh read without a timer. A changing pane is bounded and preserves OBS-85's
+                // fail-closed error instead of guessing from an adapter fingerprint.
+                const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript);
+                transcript = settled.transcript;
+                if (!settled.ok) {
+                    throw new Error(`herdr delivery clear failed — refusing to retype onto a corrupted line (OBS-85); pane transcript:\n${transcript}`);
+                }
+                // Clear the corrupted input line before retyping; a failed clear must NOT be retyped onto —
+                // corrupt-prefix + clean-retype would concatenate and false-verify by containment.
                 const cleared = await this.herdr(`pane send-keys ${shq(pane)} C-u`, slot.cwd);
                 if (cleared.code !== 0)
                     throw new Error(`herdr delivery clear failed — refusing to retype onto a corrupted line (OBS-85); pane transcript:\n${transcript}`);
@@ -348,6 +423,21 @@ export class HerdrDriver {
         }
         throw new Error(`herdr delivery corrupted after ${DELIVERY_ATTEMPTS} attempts — enter never pressed (OBS-85); pane transcript:\n${transcript}`);
     }
+    async settleDeliveryLine(pane, cwd, initialTranscript) {
+        let transcript = initialTranscript;
+        for (let readAttempt = 0; readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS; readAttempt++) {
+            const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
+            if (read.code !== 0)
+                return { ok: false, transcript: read.stdout || transcript };
+            if (read.stdout === transcript)
+                return { ok: true, transcript };
+            transcript = read.stdout;
+            if (readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS - 1) {
+                await new Promise((resolve) => setTimeout(resolve, DELIVERY_SETTLE_POLL_MS));
+            }
+        }
+        return { ok: false, transcript };
+    }
     async deliveryReadMatches(pane, cmd, cwd) {
         const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
         return read.code === 0 && this.deliveryMatches(read.stdout, cmd);

package/dist/drivers/subprocess.d.ts

@@ -1,10 +1,10 @@
 import type { ExecutorDriver, NotifyOpts, Slot } from "./types.js";
 export declare const MAX_BUF: number;
 export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH"];
-/** Copy of env with herdr control-plane vars stripped. Daemon process.env is left alone. */
+/** Copy of worker env with the fork cap applied and herdr control-plane vars stripped. */
 export declare function sealHerdrEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Shell prefix that unsets herdr control vars in a pane/login shell (herdr seed + daemon setup). */
-export declare function herdrSealShellPrefix(): string;
+/** Pane/login-shell form of the same worker env seal (herdr seed + daemon setup). */
+export declare function herdrSealShellPrefix(env?: NodeJS.ProcessEnv): string;
 export declare class SubprocessDriver implements ExecutorDriver {
     id: string;
     interactive: boolean;

package/dist/drivers/subprocess.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { createWorktree } from "../run/git.js";
+import { shq } from "../adapters/types.js";
+import { createWorktree, DEFAULT_FORK_CAP, FORK_CAP_ENV } from "../run/git.js";
 // HARD-03: cap retained worker output so a chatty worker can't grow tickmarkr's heap unbounded.
 // 2MB is safe against BOTH consumers: the largest read() call site asks for 1000 lines
 // (daemon.ts:217/247), and every marker (TICKMARKR_RESULT, TICKMARKR_EXIT_<nonce>) is emitted at the
@@ -12,16 +13,20 @@ export const MAX_BUF = 2 * 1024 * 1024;
 // (and its own herdr driver CLI calls) keep the live session. Socket path is the wire; HERDR_ENV
 // is the "I am inside herdr" gate every agent skill checks before mutating panes.
 export const HERDR_CONTROL_VARS = ["HERDR_ENV", "HERDR_SOCKET_PATH"];
-/** Copy of env with herdr control-plane vars stripped. Daemon process.env is left alone. */
+/** Copy of worker env with the fork cap applied and herdr control-plane vars stripped. */
 export function sealHerdrEnv(env = process.env) {
     const out = { ...env };
+    if (!(FORK_CAP_ENV in out))
+        out[FORK_CAP_ENV] = DEFAULT_FORK_CAP;
     for (const k of HERDR_CONTROL_VARS)
         delete out[k];
     return out;
 }
-/** Shell prefix that unsets herdr control vars in a pane/login shell (herdr seed + daemon setup). */
-export function herdrSealShellPrefix() {
-    return HERDR_CONTROL_VARS.map((k) => `unset ${k}`).join("; ") + "; ";
+/** Pane/login-shell form of the same worker env seal (herdr seed + daemon setup). */
+export function herdrSealShellPrefix(env = process.env) {
+    const forkCap = sealHerdrEnv(env)[FORK_CAP_ENV] ?? DEFAULT_FORK_CAP;
+    return `export ${FORK_CAP_ENV}=${shq(forkCap)}; ` +
+        HERDR_CONTROL_VARS.map((k) => `unset ${k}`).join("; ") + "; ";
 }
 export class SubprocessDriver {
     id = "subprocess";

package/dist/gates/acceptance.js

@@ -172,6 +172,22 @@ function compressLines(lines) {
     }
     return parts.join(", ");
 }
+// OBS-134: whole-file deletions are already fully described by their path. Sending every removed line
+// spends the cap and judge context on content that cannot exist after the change. Added and modified
+// sections pass through byte-for-byte, so their anti-flooding budget is unchanged.
+function judgeRelevantDiff(diff) {
+    return diff.split(/(?=^diff --git )/m).map((section) => {
+        if (!/^deleted file mode /m.test(section))
+            return section;
+        const oldPath = /^--- (.+)$/m.exec(section)?.[1]
+            ?? /^Binary files (.+) and \/dev\/null differ$/m.exec(section)?.[1];
+        if (!oldPath || oldPath === "/dev/null")
+            return section;
+        const unquoted = oldPath.startsWith('"') && oldPath.endsWith('"') ? oldPath.slice(1, -1) : oldPath;
+        const path = unquoted.replace(/^a\//, "");
+        return `deleted file: ${path}\n`;
+    }).join("");
+}
 // A citation is valid evidence iff the cited line falls inside a changed hunk of the cited file (OBS-129:
 // changed-hunk span, not exact-added-line). A legacy free-text quote (string) keeps v1.64's substring
 // check — non-empty and present somewhere in the diff.
@@ -225,7 +241,9 @@ 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 { full: diff, forCap } = await fetchTaskDiff(worktree, baseRef);
+    const fetched = await fetchTaskDiff(worktree, baseRef);
+    const diff = judgeRelevantDiff(fetched.full);
+    const forCap = judgeRelevantDiff(fetched.forCap);
     const diffCap = opts.diffCap ?? DEFAULT_DIFF_CAP;
     const capFail = checkDiffCap("acceptance", forCap.length, diffCap, warn + detBlock);
     if (capFail)

package/dist/gates/llm.d.ts

@@ -26,6 +26,10 @@ export interface GateVia {
     nameFor: (role: "judge" | "review", adapter: string) => string;
     labelFor: (role: "judge" | "review") => string;
 }
+export declare function captureLlmOutput<T>(run: () => Promise<T>): Promise<{
+    value: T;
+    outputs: string[];
+}>;
 export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
 export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;
 export declare function runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<string>;

package/dist/gates/llm.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { randomBytes } from "node:crypto";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -82,6 +83,16 @@ export function rolePaneNameFromPrompt(prompt, fallback) {
         return gatePaneName("review", id, retry ? "-r1" : "");
     return fallback;
 }
+const llmOutputCapture = new AsyncLocalStorage();
+// OBS-132: acceptance.ts owns verdict parsing and is deliberately byte-untouched. This async-scoped
+// recorder lets run-gates observe the exact output that acceptance parsed without changing runLlm's
+// return value or leaking concurrent tasks into one another. Callers retain output only when the
+// resulting verdict is a production failure; healthy output is discarded in memory.
+export async function captureLlmOutput(run) {
+    const outputs = [];
+    const value = await llmOutputCapture.run(outputs, run);
+    return { value, outputs };
+}
 export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
     const pf = join(mkdtempSync(join(tmpdir(), "tickmarkr-llm-")), "prompt.md");
     writeFileSync(pf, prompt);
@@ -119,10 +130,12 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
     out = augmentFakeVerdictOutput(adapter, out, nonce, prompt);
     return out;
 }
-export function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
-    return via
+export async function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+    const out = await (via
         ? runViaDriver(adapter, model, prompt, cwd, via, timeoutMs)
-        : runHeadless(adapter, model, prompt, cwd, timeoutMs);
+        : runHeadless(adapter, model, prompt, cwd, timeoutMs));
+    llmOutputCapture.getStore()?.push(out);
+    return out;
 }
 export function extractJson(raw) {
     const fenced = [...raw.matchAll(/```json\s*\n([\s\S]*?)```/g)].at(-1);

package/dist/gates/run-gates.d.ts

@@ -2,7 +2,7 @@ import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerRe
 import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
 import { type Baseline } from "./baseline.js";
-import type { GateVia } from "./llm.js";
+import { type GateVia } from "./llm.js";
 import type { GateResult } from "./types.js";
 export type GateEvent = {
     phase: "start";

package/dist/gates/run-gates.js

@@ -5,9 +5,11 @@ import { GATE_NAMES } from "../graph/schema.js";
 import { acceptanceGate } from "./acceptance.js";
 import { compareToBaseline } from "./baseline.js";
 import { evidenceGate } from "./evidence.js";
+import { captureLlmOutput } from "./llm.js";
 import { marginalCostRank } from "../route/router.js";
 import { reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
+import { withJudgeInvocationEvidence } from "../run/journal.js";
 export async function runGates(task, ctx) {
     const results = [];
     let commits = [];
@@ -63,7 +65,27 @@ 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, diffCap: ctx.cfg.gates.diffCap });
+        const invocations = [];
+        const invokeJudge = async (adapter, model, via) => {
+            const started = Date.now();
+            const captured = await captureLlmOutput(() => acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter, model }, via, { testCmd: ctx.commands.test, diffCap: ctx.cfg.gates.diffCap }));
+            const channel = channelKey({ adapter: adapter.id, model });
+            const unparseable = captured.value.meta?.unparseable === true;
+            // acceptanceGate has exactly one runLlm call. Keep the map shape so a future deterministic early
+            // return (zero outputs) stays telemetry-free instead of manufacturing a judge invocation.
+            for (const output of captured.outputs) {
+                invocations.push({
+                    taskId: task.id,
+                    channel,
+                    outcome: unparseable ? "failed" : "done",
+                    judgeOutcome: unparseable ? "unparseable" : "parseable",
+                    durationMs: Date.now() - started,
+                    ...(unparseable ? { transcript: output } : {}),
+                });
+            }
+            return captured.value;
+        };
+        let a = await invokeJudge(judgeAdapter, ctx.cfg.judge.model, jvia);
         // 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
@@ -96,10 +118,10 @@ 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, diffCap: ctx.cfg.gates.diffCap });
+            a = await invokeJudge(retryAdapter, retry.model, retryJvia);
             a = { ...a, meta: { ...a.meta, judgeRetry: { flaked: flakedKey, retried: channelKey({ adapter: retry.adapter, model: retry.model }) } } };
         }
-        await record(a);
+        await withJudgeInvocationEvidence(invocations, () => record(a));
         if (failed())
             return { results, commits };
     }

package/dist/route/preference.d.ts

@@ -4,6 +4,7 @@ export interface Disallowed {
     by: "deny" | "allow";
     entry: string;
 }
+export type PreferenceRole = "worker" | "judge" | "review" | "consult";
 export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {
@@ -24,7 +25,7 @@ export declare function preferRanks(c: {
 export declare function disallowedBy(c: {
     adapter: string;
     model: string;
-}, routing: TickmarkrConfig["routing"]): Disallowed | null;
+}, routing: TickmarkrConfig["routing"], role?: PreferenceRole): Disallowed | null;
 export interface DenyPreferCollision {
     kind: "prefer" | "pin";
     shape: string;

package/dist/route/preference.js

@@ -36,10 +36,16 @@ export function preferRanks(c, cfg) {
     return out;
 }
 // entries in either list accept adapter id, model id, or adapter:model (grammar A1)
-export function disallowedBy(c, routing) {
+export function disallowedBy(c, routing, role = "worker") {
     const { allow, deny } = routing;
     const matches = (e) => e === c.adapter || e === c.model || e === channelKey(c);
-    const d = [...(deny?.adapters ?? []), ...(deny?.models ?? [])].find(matches);
+    const workerDeny = role === "worker" ? deny?.workers : undefined;
+    const d = [
+        ...(deny?.adapters ?? []),
+        ...(deny?.models ?? []),
+        ...(workerDeny?.adapters ?? []),
+        ...(workerDeny?.models ?? []),
+    ].find(matches);
     if (d)
         return { by: "deny", entry: d };
     if (allow) {

package/dist/run/daemon.d.ts

@@ -7,6 +7,7 @@ export interface RunOptions {
     resume?: boolean;
     supersedes?: string;
     graphChanged?: boolean;
+    retryFailed?: boolean;
     concurrency?: number;
     driver?: ExecutorDriver;
     adapters?: WorkerAdapter[];

package/dist/run/daemon.js

@@ -14,11 +14,12 @@ import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
 import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
+import { GATE_NAMES } from "../graph/schema.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { runEnvironment } from "./environment.js";
-import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
-import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
+import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId, phaseForGate, recordedTaskFailureKind } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
 import { nextChannel, route } from "../route/router.js";
@@ -229,6 +230,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // GATE-08 lesson at the humanGate guard: condition on the data, not the code path). Dead-code
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
+        const satisfiedGates = opts.resume ? journal.replaySatisfiedGates() : new Map();
         const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
         if (opts.resume) {
             // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
@@ -259,7 +261,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 });
             }
             baseline = JSON.parse(readFileSync(join(journal.dir, "baseline.json"), "utf8"));
+            const replayEvents = journal.read();
             for (const [id, st] of journal.replayStatuses()) {
+                if (opts.retryFailed && st === "failed" && recordedTaskFailureKind(replayEvents, id) === "dispatch") {
+                    graph = setStatus(graph, id, "pending");
+                    resume.delete(id);
+                    continue;
+                }
                 // operator release: a graph.json edit back to "pending" beats a replayed human/failed park (locked decision 12)
                 if ((st === "human" || st === "failed") && getTask(graph, id).status === "pending")
                     continue;
@@ -268,6 +276,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             journal.append("run-resume", undefined, {
                 pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
                 ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
+                ...(opts.retryFailed ? { retryFailed: true } : {}),
             });
         }
         else {
@@ -366,7 +375,10 @@ export async function runDaemon(repoRoot, opts = {}) {
         // merges are serialized — two concurrent `git merge`s in one worktree would corrupt each other
         let mergeChain = Promise.resolve();
         const mergeSerial = (taskBranch, t, gated) => {
-            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated));
+            const next = mergeChain.then(() => {
+                journal.phaseStart(t.id, "merge");
+                return mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated);
+            });
             mergeChain = next.catch(() => undefined);
             return next;
         };
@@ -526,6 +538,114 @@ export async function runDaemon(repoRoot, opts = {}) {
                 await park(t, `consult verdict: ${v.action} — ${v.notes}`, trigger, assignment, attempts, startMs, gateFails, consults, tokens, metered, retryMode); // decompose|human
                 return false;
             };
+            // OBS-130: an operator-approved gate-fail resumes from the persisted task branch, after the exact
+            // satisfied gate. No worker dispatch and no earlier gate/judge invocation occur on this path.
+            // replaySatisfiedGates() admits only an explicit task-approved ledger event, scoped by task+gate.
+            const satisfiedGate = satisfiedGates.get(t.id);
+            if (satisfiedGate) {
+                const taskBase = await integrationHead(intWt);
+                const taskBranch = `${branch}--${t.id}`;
+                const priorWt = worktreePath(repoRoot, taskBranch);
+                if (!existsSync(priorWt)) {
+                    throw new Error(`approved gate ${satisfiedGate} cannot resume: task worktree is missing`);
+                }
+                const commitsToCarry = await commitsAheadOf(taskBase, priorWt);
+                const wt = await driver.worktree(repoRoot, taskBranch, taskBase);
+                const carriedCommits = await cherryPickCommits(wt, commitsToCarry);
+                journal.append("worktree-recreation", t.id, { attempted: commitsToCarry, carried: carriedCommits });
+                if (!linkNodeModules(repoRoot, wt, { force: true })) {
+                    await park(t, "environmental: node_modules link could not be re-asserted before gates (OBS-47)", "setup", assignment, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                    return;
+                }
+                if (await npmDependencyManifestChanged(wt, taskBase)) {
+                    const installCommand = npmDependencyInstallCommand(wt);
+                    const installed = await sh(installCommand, repoRoot, 10 * 60_000);
+                    if (installed.code !== 0) {
+                        throw new Error(`dependency install failed (exit ${installed.code}): ${installed.stderr || installed.stdout}`);
+                    }
+                }
+                const workerEvent = [...journal.read()].reverse()
+                    .find((e) => e.event === "worker-result" && e.taskId === t.id);
+                if (!workerEvent)
+                    throw new Error(`approved gate ${satisfiedGate} cannot resume: worker result is missing`);
+                const priorResult = {
+                    ok: workerEvent.data.ok === true,
+                    summary: typeof workerEvent.data.summary === "string" ? workerEvent.data.summary : "",
+                    deviations: Array.isArray(workerEvent.data.deviations)
+                        ? workerEvent.data.deviations.filter((d) => typeof d === "string")
+                        : [],
+                    raw: "",
+                };
+                const gateAuthor = rs?.lastAssignment ?? assignment;
+                const satisfiedIndex = GATE_NAMES.indexOf(satisfiedGate);
+                const remainingGates = t.gates.filter((gate) => GATE_NAMES.indexOf(gate) > satisfiedIndex);
+                const resumedTask = { ...t, gates: remainingGates };
+                gateLoop: while (true) {
+                    const gated = await gitHead(wt);
+                    journal.phaseStart(t.id, "gates");
+                    const { results } = await runGates(resumedTask, {
+                        worktree: wt, baseRef: taskBase, result: priorResult, author: gateAuthor,
+                        commands, baseline, channels, adapters, cfg,
+                        via: cfg.visibility.llm === "pane"
+                            ? {
+                                driver: trackedDriver,
+                                keep: keepLlm,
+                                onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined,
+                                nameFor: (role) => formatOwnedName({ role, taskId: t.id, attempt: 0, runId }),
+                                labelFor: (role) => `${role.toUpperCase()} ${t.id}`,
+                            }
+                            : undefined,
+                        excludeReviewers: badReviewers,
+                        onGate: async (e) => {
+                            if (e.phase === "start") {
+                                journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total });
+                                return;
+                            }
+                            const g = e.result;
+                            journal.append("gate-result", t.id, {
+                                gate: g.gate, pass: g.pass, details: g.details,
+                                ...(g.meta?.skipped === true ? { skipped: true } : {}),
+                            });
+                            if (g.gate === "review" && !g.pass && /unparseable/.test(g.details)
+                                && typeof g.meta?.reviewer === "string") {
+                                badReviewers.push(g.meta.reviewer);
+                            }
+                        },
+                    });
+                    const approvedCommits = await commitsAheadOf(taskBase, wt);
+                    graph = addEvidence(graph, t.id, { commits: approvedCommits, gateResults: results });
+                    saveGraph(repoRoot, graph);
+                    if (!results.every((g) => g.pass)) {
+                        gateFails++;
+                        await park(t, "post-approval gate failed", "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    const m = await mergeSerial(taskBranch, t, gated);
+                    if (m.tipMoved) {
+                        journal.append("tip-moved", t.id, m.tipMoved);
+                        if (tipMoves++ === 0)
+                            continue gateLoop;
+                        await park(t, "task branch tip moved twice after gating", "tip-moved", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    if (!m.ok) {
+                        journal.append("merge-conflict", t.id, { conflict: m.conflict });
+                        await park(t, `merge conflict after approved gate: ${m.conflict ?? "unknown conflict"}`, "merge-conflict", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                        return;
+                    }
+                    graph = setStatus(graph, t.id, "done");
+                    saveGraph(repoRoot, graph);
+                    journal.append("task-done", t.id, { attempts: rs?.attempts ?? 0, assignment: gateAuthor });
+                    journal.append("merge", t.id, { branch: taskBranch, commit: await integrationHead(intWt) });
+                    journal.telemetry({
+                        taskId: t.id, shape: t.shape, adapter: gateAuthor.adapter, model: gateAuthor.model,
+                        channel: gateAuthor.channel, attempts: rs?.attempts ?? 0, outcome: "done",
+                        durationMs: Date.now() - startMs, firstAttemptOk: false, gateFails, consults, retryMode,
+                    });
+                    await reconcile({ spareLiveLlm: true });
+                    return;
+                }
+            }
             // Phase 46 (RES-01): start at the replayed attempt count; a replayed count ≥ MAX_ATTEMPTS parks via
             // the existing attempt-cap check below with zero new code. Fresh path: rs is undefined ⇒ 0.
             // v1.24 OBS-18: after task-approved{release:attempt-cap}, replay zeros attempts so this loop
@@ -594,6 +714,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 graph = setStatus(graph, t.id, "running");
                 saveGraph(repoRoot, graph);
                 journal.append("task-dispatch", t.id, { assignment, attempt, provenance: dispatchProvenance(r.provenance), retryMode });
+                journal.phaseStart(t.id, "worker", { attempt, assignment });
                 const taskBase = await integrationHead(intWt); // deps are merged → visible to this task
                 const taskBranch = `${branch}--${t.id}`; // "--": a ref can't nest under the existing integration branch (locked decision 10)
                 const priorWt = worktreePath(repoRoot, taskBranch);
@@ -1044,9 +1165,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                     await park(t, "environmental: node_modules link could not be re-asserted before gates (OBS-47)", "setup", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode);
                     return;
                 }
+                // OBS-126: workers cannot write the provisioned node_modules target outside their sandbox.
+                // Once the link is known-good, the daemon installs only attempts whose npm manifest differs
+                // from the integration-tip baseline. Keep lock/package manifests untouched: the worker's
+                // committed files are the deliverable, while this step only provisions the gate-visible tree.
+                if (await npmDependencyManifestChanged(wt, taskBase)) {
+                    const installCommand = npmDependencyInstallCommand(wt);
+                    const installed = await sh(installCommand, repoRoot, 10 * 60_000);
+                    if (installed.code !== 0) {
+                        throw new Error(`dependency install failed (exit ${installed.code}): ${installed.stderr || installed.stdout}`);
+                    }
+                }
                 const onGate = async (e) => {
-                    if (e.phase === "start")
+                    if (e.phase === "start") {
+                        journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total });
                         return;
+                    }
                     const g = e.result;
                     // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
                     // which channel flaked, which channel retried — so `tickmarkr journal`/report can distinguish "judge
@@ -1075,6 +1209,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let commits = [];
                 gateLoop: while (true) {
                     const gated = await gitHead(wt);
+                    journal.phaseStart(t.id, "gates");
                     ({ results, commits } = await runGates(t, {
                         worktree: wt, baseRef: taskBase, result, author: assignment,
                         commands, baseline, channels, adapters, cfg,

package/dist/run/git.d.ts

@@ -12,6 +12,8 @@ export declare function sh(cmd: string, cwd: string, timeoutMs?: number): Promis
 export declare function shGit(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shOk(cmd: string, cwd: string): Promise<string>;
 export declare function shGitOk(cmd: string, cwd: string): Promise<string>;
+export declare function npmDependencyManifestChanged(cwd: string, baselineRef: string): Promise<boolean>;
+export declare function npmDependencyInstallCommand(cwd: string): string;
 export declare function gitHead(cwd: string): Promise<string>;
 export declare const sanitizeBranch: (branch: string) => string;
 export declare const WORKTREES_DIR = "worktrees.noindex";