tickmarkr 2.1.9 → 2.2.1

package/dist/gates/run-gates.js

@@ -583,6 +583,14 @@ export async function runGates(task, ctx) {
         // eligible seat keeps the ORIGINAL result so the recorded cause stays truthful (OBS-196).
         if (rv.meta?.unparseable === true && typeof rv.meta.reviewer === "string") {
             const flaked = rv.meta.reviewer;
+            const emptyOutput = rv.meta.cause === "empty-output";
+            if (emptyOutput) {
+                await ctx.onGate?.({
+                    phase: "note", gate: "review", name: "reviewer-empty-output",
+                    payload: { reviewer: flaked, bytes: typeof rv.meta.bytes === "number" ? rv.meta.bytes : 0 },
+                    result: { ...rv, meta: { ...rv.meta, skipped: true } },
+                });
+            }
             const retryVia = ctx.via
                 ? { ...ctx.via, nameFor: (role, adapter) => ctx.via.nameFor(role, adapter) + "-r1" }
                 : undefined;
@@ -593,7 +601,7 @@ export async function runGates(task, ctx) {
                     ...second,
                     // `details` is lifted onto the journal's gate-result row; meta.reviewRetry is not. Keep the
                     // re-route visible in the result text a reader actually opens, including on a red retry.
-                    details: `review re-route: ${flaked} produced no parseable verdict; replaced by ${retried}\n${second.details}`,
+                    details: `review re-route: ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
                     meta: { ...second.meta, reviewRetry: { flaked, retried } },
                 };
             }

package/dist/run/consult.d.ts

@@ -9,6 +9,9 @@ export interface ConsultVerdict {
     reason?: string;
     guidance?: string;
     excludeAdapter?: string;
+    adapter?: string;
+    model?: string;
+    vendor?: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -36,5 +39,9 @@ export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: Work
     runId?: string;
     channels?: Array<{
         adapter: string;
+        model?: string;
+        vendor?: string;
+        channel?: "sub" | "api";
+        tier?: string;
     }>;
 }): Promise<ConsultVerdict>;

package/dist/run/consult.js

@@ -205,6 +205,17 @@ opts = {}) {
     // the same rule as every prefer entry — and disallowedBy carries the full deny grammar (adapter,
     // model, or adapter:model), so a model-scoped deny cannot slip past an adapter-id-only read.
     const allowedSeats = seats.filter((s) => disallowedBy(s, cfg.routing, "consult") === null);
+    const seatIdentity = (seat) => {
+        let vendor = opts.channels?.find((candidate) => candidate.adapter === seat.adapter && candidate.model === seat.model)?.vendor;
+        if (!vendor) {
+            try {
+                const adapter = getAdapter(seat.adapter, adapters);
+                vendor = adapter.channels(cfg).find((channel) => channel.model === seat.model)?.vendor ?? adapter.vendor;
+            }
+            catch { /* an unknown adapter still gets explicit unknown provenance */ }
+        }
+        return { adapter: seat.adapter, model: seat.model, vendor: vendor ?? "unknown" };
+    };
     if (!allowedSeats.length) {
         const d = disallowedBy(seats[seats.length - 1], cfg.routing, "consult");
         return {
@@ -216,11 +227,14 @@ opts = {}) {
         try {
             const parsed = await invokeSeat(seat.adapter, seat.model, i);
             if (parsed.verdict)
-                return parsed.verdict;
+                return { ...parsed.verdict, ...seatIdentity(seat) };
         }
         catch {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
         }
     }
-    return { action: "human", notes: "consult verdict unparseable — failing safe to human" };
+    return {
+        action: "human",
+        notes: "consult verdict unparseable — failing safe to human",
+    };
 }

package/dist/run/daemon.d.ts

@@ -1,5 +1,6 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
+import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
@@ -13,6 +14,7 @@ export interface RunOptions {
     retryFailed?: boolean;
     concurrency?: number;
     driver?: ExecutorDriver;
+    driverOverride?: DriverChoice;
     adapters?: WorkerAdapter[];
     globalDir?: string;
     mode?: RoutingMode;
@@ -49,12 +51,16 @@ export interface RunSummary {
     outstandingApprovals?: string[];
 }
 /**
- * T14: approvals the run accepted and never acted on. `approved` above is built ONCE at startup —
- * deliberately, replay determinism depends on it — so an approval written while the daemon is live is
- * inert for that run. Without this the run-end record stated only buckets and tipVerify, both
- * accurate, over a milestone that was silently incomplete: run …230 ended tipVerify "passed" with two
- * upheld approvals and zero subsequent dispatches. Scored per task on its NEWEST approval: a later
- * approval is the live decision, and the events that answer it are the ones after it.
+ * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
+ * built ONCE at startup — replay determinism depends on it — but a live approval is no longer inert:
+ * the boundary sweep in the task loop releases what lands while the daemon runs, so an approval
+ * written mid-run is normally enacted by this run. ONE window survives, and it is the reason this
+ * fold still exists: an approval accepted after the task loop exits — during tip verify, before the
+ * run-end sample below — meets no further boundary, so nothing can release it before this run ends.
+ * Without this the run-end record stated only buckets and tipVerify, both accurate, over a milestone
+ * that was silently incomplete: run …230 ended tipVerify "passed" with two upheld approvals and zero
+ * subsequent dispatches. Scored per task on its NEWEST approval: a later approval is the live
+ * decision, and the events that answer it are the ones after it.
  */
 export declare function outstandingApprovals(events: JournalEvent[]): string[];
 export declare function formatSummary(s: RunSummary): string;

package/dist/run/daemon.js

@@ -1,8 +1,9 @@
+import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { shq } from "../adapters/types.js";
-import { appendFileSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, readSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { stringify } from "yaml";
 import { classifyDeadChannel, NO_TRAILER_SUMMARY, trailerPattern, UNPARSEABLE_TRAILER_SUMMARY, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../adapters/registry.js";
@@ -11,17 +12,20 @@ import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { collateralHits } from "../compile/collateral.js";
 import { DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
 import { DeliveryReadinessError } from "../drivers/herdr.js";
+import { driverEvidence } from "../drivers/index.js";
 import { herdrSealShellPrefix, SubprocessDriver } from "../drivers/subprocess.js";
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
 import { runGates } from "../gates/run-gates.js";
+import { filesGlob } from "../graph/files-glob.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES } from "../graph/schema.js";
+import { distFingerprint } from "../cli/commands/version.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { runEnvironment } from "./environment.js";
 import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, sameCapacity, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
-import { activeRetryBan, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingReviewFindings, pendingRepairFindings, phaseForGate, readPriorRunEvidence, recordedTaskFailureKind, renderStructuredReviewFinding, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, structuredFindings, upheldFeedbackByTask } from "./journal.js";
+import { activeRetryBan, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingConsultGuidance, outstandingReviewFindings, pendingRepairFindings, phaseForGate, readPriorRunEvidence, recordedTaskFailureKind, renderStructuredReviewFinding, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, structuredFindings, upheldFeedbackByTask } from "./journal.js";
 import { isDiffCapPark } from "../gates/review.js";
 import { acquireApprovalSerialization, acquireRunLock, isPidLive, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
@@ -76,12 +80,16 @@ const DISPATCH_ENACTMENT = new Set(["task-dispatch", "repair-dispatch"]);
 // for the task is worktree-recreation. That event is causal for this path, not incidental.
 const GATE_SATISFIED_ENACTMENT = "worktree-recreation";
 /**
- * T14: approvals the run accepted and never acted on. `approved` above is built ONCE at startup —
- * deliberately, replay determinism depends on it — so an approval written while the daemon is live is
- * inert for that run. Without this the run-end record stated only buckets and tipVerify, both
- * accurate, over a milestone that was silently incomplete: run …230 ended tipVerify "passed" with two
- * upheld approvals and zero subsequent dispatches. Scored per task on its NEWEST approval: a later
- * approval is the live decision, and the events that answer it are the ones after it.
+ * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
+ * built ONCE at startup — replay determinism depends on it — but a live approval is no longer inert:
+ * the boundary sweep in the task loop releases what lands while the daemon runs, so an approval
+ * written mid-run is normally enacted by this run. ONE window survives, and it is the reason this
+ * fold still exists: an approval accepted after the task loop exits — during tip verify, before the
+ * run-end sample below — meets no further boundary, so nothing can release it before this run ends.
+ * Without this the run-end record stated only buckets and tipVerify, both accurate, over a milestone
+ * that was silently incomplete: run …230 ended tipVerify "passed" with two upheld approvals and zero
+ * subsequent dispatches. Scored per task on its NEWEST approval: a later approval is the live
+ * decision, and the events that answer it are the ones after it.
  */
 export function outstandingApprovals(events) {
     const newest = new Map();
@@ -687,6 +695,202 @@ function compareWorktrees(before, after) {
         return "unreadable";
     return before.signature === after.signature ? "unchanged" : "changed";
 }
+const CONTEXT_GLOB_CHARS = /[*?{[]/;
+const MATERIALIZED_CONTEXT_BYTES = 256 * 1024 * 1024;
+function containedIn(root, path) {
+    const fromRoot = relative(resolve(root), resolve(path));
+    return fromRoot === "" || (fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`) && !isAbsolute(fromRoot));
+}
+function normalizeContextPath(entry) {
+    if (entry.includes("\0"))
+        return undefined;
+    const repositoryPath = entry.replace(/\\/g, "/");
+    if (posix.isAbsolute(repositoryPath) || repositoryPath.split("/").includes(".."))
+        return undefined;
+    const normalized = posix.normalize(repositoryPath).replace(/\/+$/, "");
+    if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../"))
+        return undefined;
+    return normalized;
+}
+function workerFilesystemEntries(worktree) {
+    const entries = [];
+    const visit = (dir, prefix) => {
+        let dirents;
+        try {
+            dirents = readdirSync(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            const rel = relative(worktree, dir).split(sep).join(posix.sep) || ".";
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`context filesystem observation failed at ${rel}: ${message}`);
+        }
+        for (const dirent of dirents) {
+            if (dirent.name === ".git")
+                continue;
+            const rel = prefix ? `${prefix}/${dirent.name}` : dirent.name;
+            entries.push(rel);
+            if (dirent.isDirectory())
+                visit(join(dir, dirent.name), rel);
+        }
+    };
+    visit(worktree, "");
+    return entries;
+}
+function exactContextResolvesInWorktree(entry, normalized, worktree) {
+    const fullPath = join(worktree, normalized);
+    try {
+        const stat = lstatSync(fullPath);
+        if (stat.isSymbolicLink())
+            return false;
+        if (stat.isDirectory())
+            return true;
+        return !/\/+$/.test(entry) && stat.isFile() && worktreeHeadHasRegularBlob(worktree, normalized);
+    }
+    catch (error) {
+        if (["EACCES", "ELOOP", "ENOENT", "ENOTDIR", "EPERM"].includes(error.code ?? ""))
+            return false;
+        throw error;
+    }
+}
+function patternContextResolvesInWorktree(normalized, worktree) {
+    const match = filesGlob(normalized);
+    return workerFilesystemEntries(worktree).some((path) => match(path));
+}
+function regularBlobObjectId(repoRoot, ref, normalized) {
+    let tree = "";
+    try {
+        tree = execFileSync("git", ["-C", repoRoot, "ls-tree", "-z", ref, "--", normalized], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+        });
+    }
+    catch {
+        return undefined;
+    }
+    const row = tree.split("\0")
+        .filter(Boolean)
+        .map((line) => /^(\d{6}) (\w+) ([0-9a-f]+)\t([\s\S]*)$/.exec(line))
+        .find((match) => match?.[4] === normalized);
+    if (!row || row[2] !== "blob" || (row[1] !== "100644" && row[1] !== "100755"))
+        return undefined;
+    return row[3];
+}
+function worktreeHeadHasRegularBlob(worktree, normalized) {
+    return regularBlobObjectId(worktree, "HEAD", normalized) !== undefined;
+}
+function committedRegularBlob(repoRoot, normalized) {
+    const objectId = regularBlobObjectId(repoRoot, "HEAD", normalized);
+    if (!objectId)
+        return undefined;
+    try {
+        const bytes = execFileSync("git", ["-C", repoRoot, "cat-file", "blob", objectId], {
+            encoding: "buffer",
+            maxBuffer: MATERIALIZED_CONTEXT_BYTES,
+        });
+        return { bytes };
+    }
+    catch {
+        return undefined;
+    }
+}
+function materializedContextDestination(root, task, attempt, normalized) {
+    const key = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+    const leaf = basename(normalized).replace(/[^A-Za-z0-9._-]/g, "_") || "context";
+    const destination = join(root, task.id, `a${attempt}`, `${key}-${leaf}`);
+    if (!containedIn(root, destination))
+        throw new Error(`materialized context destination escapes context subtree: ${normalized}`);
+    return destination;
+}
+function ensureDirectoryWithoutSymlink(path) {
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        mkdirSync(path, { mode: 0o700 });
+        stat = lstatSync(path);
+    }
+    if (stat.isSymbolicLink())
+        throw new Error(`materialized context destination ancestor is a symlink: ${path}`);
+    if (!stat.isDirectory())
+        throw new Error(`materialized context destination ancestor is not a directory: ${path}`);
+}
+function ensureContainedContextParent(root, destination) {
+    const rootAbs = resolve(root);
+    const destAbs = resolve(destination);
+    if (!containedIn(rootAbs, destAbs))
+        throw new Error("materialized context destination escapes context subtree");
+    const parent = dirname(destAbs);
+    ensureDirectoryWithoutSymlink(rootAbs);
+    const relParent = relative(rootAbs, parent);
+    let current = rootAbs;
+    for (const segment of relParent.split(sep).filter(Boolean)) {
+        current = join(current, segment);
+        ensureDirectoryWithoutSymlink(current);
+    }
+    if (!containedIn(realpathSync(rootAbs), realpathSync(parent))) {
+        throw new Error("materialized context destination realpath escapes context subtree");
+    }
+}
+function writeContainedContextFile(root, destination, bytes) {
+    if (!containedIn(root, destination))
+        throw new Error("materialized context destination escapes context subtree");
+    ensureContainedContextParent(root, destination);
+    const fd = openSync(destination, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW, 0o600);
+    try {
+        writeFileSync(fd, bytes);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+async function materializeContextEntry(repoRoot, worktree, contextRoot, task, attempt, entry) {
+    const normalized = normalizeContextPath(entry);
+    if (!normalized)
+        return { kind: "missing", path: entry, reason: "invalid-path" };
+    if (exactContextResolvesInWorktree(entry, normalized, worktree))
+        return { kind: "keep", entry };
+    const blob = committedRegularBlob(repoRoot, normalized);
+    if (blob) {
+        const destination = materializedContextDestination(contextRoot, task, attempt, normalized);
+        writeContainedContextFile(contextRoot, destination, blob.bytes);
+        return { kind: "materialized", entry: destination, normalized, destination, bytes: blob.bytes.length };
+    }
+    if (CONTEXT_GLOB_CHARS.test(entry)) {
+        if (patternContextResolvesInWorktree(normalized, worktree))
+            return { kind: "keep", entry };
+        return { kind: "missing", path: entry, reason: "unresolved-pattern" };
+    }
+    if (/\/+$/.test(entry))
+        return { kind: "missing", path: entry, reason: "unresolved-pattern" };
+    return { kind: "missing", path: entry, reason: "no-committed-regular-blob" };
+}
+async function taskWithMaterializedContext(repoRoot, journal, worktree, task, attempt) {
+    if (task.context.length === 0)
+        return task;
+    const contextRoot = resolve(journal.dir, "context");
+    const context = [];
+    for (const entry of task.context) {
+        const prepared = await materializeContextEntry(repoRoot, worktree, contextRoot, task, attempt, entry);
+        if (prepared.kind === "missing") {
+            journal.append("context-missing", task.id, { path: prepared.path, reason: prepared.reason });
+        }
+        else {
+            context.push(prepared.entry);
+            if (prepared.kind === "materialized") {
+                journal.append("context-materialized", task.id, {
+                    path: entry,
+                    normalized: prepared.normalized,
+                    destination: prepared.destination,
+                    bytes: prepared.bytes,
+                });
+            }
+        }
+    }
+    return { ...task, context };
+}
 async function cherryPickCommits(wt, commits) {
     const carried = [];
     for (const hash of commits) {
@@ -975,10 +1179,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                 journal.append("lock-reclaimed", undefined, lock.reclaimed); // HARD-02 audit trail
             }
             // GATE-08 (v1.12): the humanGate guard consults this run's journaled approvals, not just the compiled
-            // flag. Built ONCE at startup from the journal; a fresh run's journal is empty ⇒ empty set ⇒ unapproved
-            // gates park exactly as today. (D-02 step 3 — the load-bearing change: a command + event WITHOUT this
-            // guard change ships a no-op; the task replays to pending, re-enters execTask, and re-parks.)
-            const approved = new Set(journal.read().filter((e) => e.event === "task-approved" && e.taskId).map((e) => e.taskId));
+            // flag. Startup approvals seed the first scheduling pass; live approvals are folded at task
+            // boundaries below so a sibling can release parked work without waiting for run-end + resume.
+            const approvalStartupEvents = journal.read();
+            const approved = new Set(approvalStartupEvents.filter((e) => e.event === "task-approved" && e.taskId).map((e) => e.taskId));
+            let approvalSweepCursor = approvalStartupEvents.length;
             const commands = detectGateCommands(repoRoot, cfg);
             let baseRef;
             let baseline;
@@ -986,9 +1191,9 @@ export async function runDaemon(repoRoot, opts = {}) {
             // Empty Map on fresh runs — every seed below conditions on resume.get(t.id), never on opts.resume (the
             // 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 replayedGateResults = resumeLifecycleOpen
+            let resume = opts.resume ? journal.replayResumeState() : new Map();
+            let satisfiedGates = opts.resume ? journal.replaySatisfiedGates() : new Map();
+            let replayedGateResults = resumeLifecycleOpen
                 ? journal.replayCurrentAttemptGateResults()
                 : new Map();
             // T7: the capacity THIS session resolved — read inside the run's fork budget, so it is the number
@@ -1052,11 +1257,25 @@ export async function runDaemon(repoRoot, opts = {}) {
                 baseRef = await gitHead(repoRoot);
                 baseline = await captureBaseline(repoRoot, commands);
                 writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
+                writeFileSync(join(journal.dir, "graph.json"), readFileSync(join(tickmarkrDir(repoRoot), "graph.json")));
                 // v1.70 T2: environment identity beside the graph/branch identity — running tickmarkr version,
                 // loaded-config hash, and the probed CLI version of each adapter holding a channel in the run,
                 // gathered through the existing probe/config-load paths (no second mechanism).
                 const environment = runEnvironment(cfg, channels, health);
-                journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, environment, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
+                journal.append("run-start", undefined, {
+                    pid: process.pid, baseRef, commands, channels: channels.map(channelKey),
+                    channelsByRole: {
+                        worker: pools.worker.map(channelKey),
+                        judge: pools.judge.map(channelKey),
+                        review: pools.review.map(channelKey),
+                        consult: pools.consult.map(channelKey),
+                    },
+                    driver: driver.id,
+                    driverEvidence: driverEvidence(cfg, driver, opts.driverOverride),
+                    distFingerprint: distFingerprint(),
+                    branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source,
+                    environment, ...(prior ? { supersedes: prior.runId } : {}),
+                }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
                 runStarted = true;
                 // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
                 // names a successor that has no journal. Append-only — the prior journal is never rewritten.
@@ -1093,8 +1312,8 @@ export async function runDaemon(repoRoot, opts = {}) {
             try {
                 watchSlot = await driver.narrator?.(repoRoot, watchCommand(runId), runId);
             }
-            catch {
-                /* cosmetic-only — the run proceeds without a live surface */
+            catch (error) {
+                journal.append("watch-placement-failed", undefined, { error: error instanceof Error ? error.message : String(error) });
             }
             const intWt = await ensureIntegration(repoRoot, branch, baseRef);
             // v1.1 visibility: role-named slots; panes persist per keepPanes (attempt = v1 close-after-harvest)
@@ -1169,6 +1388,14 @@ export async function runDaemon(repoRoot, opts = {}) {
             };
             // gateFails/consults are execTask-scoped counters passed in so a park row is a rich verified-failure
             // observation (e.g. ladder-exhausted + gateFails:4); every task-human row has a closed kind, never prose alone.
+            const gateFailApprovalReason = (taskId, identity, includeUphold = false) => {
+                const commands = [
+                    `tickmarkr approve ${runId} ${taskId} --waive`,
+                    `tickmarkr approve ${runId} ${taskId} --recheck`,
+                    ...(includeUphold ? [`tickmarkr approve ${runId} ${taskId} --uphold`] : []),
+                ];
+                return `${identity} — release with ${commands.map((command) => `\`${command}\``).join(" or ")}`;
+            };
             const park = async (t, reason, kind, assignment, attempts, startMs, gateFails = 0, consults = 0, tokens, metered = 0, retryMode = "fresh", details = {}) => {
                 graph = setStatus(graph, t.id, "human");
                 saveGraph(repoRoot, graph);
@@ -1228,6 +1455,38 @@ export async function runDaemon(repoRoot, opts = {}) {
                 }
                 return false;
             };
+            const sweepLiveApprovals = () => {
+                const events = journal.read();
+                const approvals = events.slice(approvalSweepCursor)
+                    .filter((e) => e.event === "task-approved" && e.taskId);
+                approvalSweepCursor = events.length;
+                if (approvals.length === 0)
+                    return;
+                resume = journal.replayResumeState();
+                satisfiedGates = journal.replaySatisfiedGates();
+                replayedGateResults = resumeLifecycleOpen
+                    ? journal.replayCurrentAttemptGateResults()
+                    : new Map();
+                let changed = false;
+                for (const e of approvals) {
+                    const taskId = e.taskId;
+                    approved.add(taskId);
+                    if (e.data.release !== GATE_SATISFIED_RELEASE)
+                        replayedGateResults.delete(taskId);
+                    try {
+                        const task = getTask(graph, taskId);
+                        if (task.status === "human" || task.status === "failed") {
+                            graph = setStatus(graph, taskId, "pending");
+                            changed = true;
+                        }
+                    }
+                    catch {
+                        // Unknown task in a stale journal: approval replay is inert, like the other journal folds.
+                    }
+                }
+                if (changed)
+                    saveGraph(repoRoot, graph);
+            };
             const execTask = async (t) => {
                 const startMs = Date.now();
                 const taskTimeoutMinutes = t.timeoutMinutes ?? cfg.taskTimeoutMinutes;
@@ -1543,6 +1802,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const applyVerdict = async (v, attempts, trigger) => {
                     journal.append("consult-verdict", t.id, {
                         action: v.action, notes: v.notes,
+                        adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
                         ...(v.reason ? { reason: v.reason } : {}),
                         ...(v.guidance ? { guidance: v.guidance } : {}),
                         ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
@@ -1766,6 +2026,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                                     return;
                                 }
+                                if (e.phase === "note") {
+                                    journal.append(e.name, t.id, e.payload);
+                                    return;
+                                }
                                 const g = e.result;
                                 inParallelOrder(g.gate, () => {
                                     journalGateResult(g);
@@ -1801,7 +2065,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             // feedback from those rows. Only an operator-authorized gate release parks on a new red.
                             if (!satisfiedGate)
                                 break gateLoop;
-                            await park(t, "post-approval gate failed", "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
+                            await park(t, gateFailApprovalReason(t.id, "post-approval gate failed", results.some((g) => g.gate === "review" && gateFailed(g))), "gate-fail", gateAuthor, rs?.attempts ?? 0, startMs, gateFails, consults, tokens, metered, retryMode);
                             return;
                         }
                         const m = await mergeSerial(taskBranch, t, gated);
@@ -1859,7 +2123,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // survives the reset and governs only those further rounds. Absence preserves the module default.
                     const reviewRoundCap = approvedReviewRoundCeiling(journal.read(), t.id) ?? REVIEW_ROUND_CAP;
                     if (attempt > 0 && reviewRoundsDrawn() >= reviewRoundCap) {
-                        await park(t, `review round cap (${reviewRoundCap}) reached this engagement — \`tickmarkr approve\` accepts the diff past review; \`tickmarkr approve --uphold\` funds one fixed attempt carrying the findings`, "gate-fail", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
+                        await park(t, gateFailApprovalReason(t.id, `review round cap (${reviewRoundCap}) reached this engagement`, true), "gate-fail", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
                         return;
                     }
                     // OBS-57: a demoted channel must not be re-dispatched on consult retry or provider requeue.
@@ -1895,7 +2159,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             gate: banned, from: channelKey(assignment), to: next ? channelKey(next) : null,
                         });
                         if (!next) {
-                            await park(t, `identical ${banned} failure twice this engagement — an identical retry is banned and no untried channel is left`, "gate-fail", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
+                            await park(t, gateFailApprovalReason(t.id, `identical ${banned} failure twice this engagement — an identical retry is banned and no untried channel is left`), "gate-fail", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
                             return;
                         }
                         assignment = next;
@@ -1964,6 +2228,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                             })].join("\n");
                         feedback = feedback ? `${feedback}\n\n${brief}` : brief;
                     }
+                    const carriedConsultGuidance = outstandingConsultGuidance(journaledSoFar, t.id);
+                    if (carriedConsultGuidance) {
+                        const consultBrief = renderRetryGuidance({ ...carriedConsultGuidance, notes: "" });
+                        if (consultBrief && !feedback.includes(consultBrief)) {
+                            feedback = feedback ? `${feedback}\n\n${consultBrief}` : consultBrief;
+                        }
+                    }
                     retryMode = repairFindings
                         ? "repair"
                         : priorSession
@@ -1992,6 +2263,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     journal.append("task-dispatch", t.id, {
                         assignment, attempt, provenance: dispatchProvenance(r.provenance), retryMode,
                         ...(outstandingFindings.length > 0 ? { carriedFindings: outstandingFindings } : {}),
+                        ...(carriedConsultGuidance ? { carriedConsultGuidance } : {}),
                     });
                     journal.phaseStart(t.id, "worker", { attempt, assignment });
                     const taskBase = await integrationHead(intWt); // deps are merged → visible to this task
@@ -2091,7 +2363,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                             return;
                         }
                     }
-                    const promptFile = writePrompt(journal.dir, t, attempt, feedback, nonce);
+                    const promptTask = await taskWithMaterializedContext(repoRoot, journal, wt, t, attempt);
+                    const promptFile = writePrompt(journal.dir, promptTask, attempt, feedback, nonce);
                     // OBS-56: state the non-interactive, one-pass finish contract and the OBS-54 stall budget in every
                     // worker prompt, not only consult retry guidance. Prepended so prompt.ts's completion trailer stays last.
                     const workerContract = `## Harness contract\n- This harness is non-interactive: make one continuous pass; do not stop for questions or follow-up input.\n- You have a ${taskTimeoutMinutes} minute stall window. The gates run the full suite for you — never spend this window on one; commit your work and emit the completion trailer inside it.\n- Each test: acceptance criterion must exist as a vitest test whose OWN title (the leaf, not counting enclosing describe titles) is the criterion string verbatim — never shortened, never decorated. Nesting under describe() is allowed.`; // OBS-64; OBS-511: leaf-title rule stated where the worker reads it; OBS-548: the suite is the GATES' job — this repo's own suite outlasts the output-silence windows the daemon polices, so a worker obeying "budget the full suite" was killed by construction
@@ -3200,6 +3473,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                             journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                             return;
                         }
+                        if (e.phase === "note") {
+                            journal.append(e.name, t.id, e.payload);
+                            return;
+                        }
                         const g = e.result;
                         inParallelOrder(g.gate, () => {
                             // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
@@ -3402,7 +3679,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 continue;
                             return;
                         }
-                        journal.append("consult-verdict", t.id, { action: v.action, notes: v.notes, capAdvisory: true });
+                        journal.append("consult-verdict", t.id, {
+                            action: v.action, notes: v.notes,
+                            adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
+                            capAdvisory: true,
+                        });
                     }
                     // v1.85 T3: a narrow battery over fully carried commits earns a REPAIR (decided above) — the
                     // next dispatch carries the findings verbatim and the diff content instead of re-onboarding a
@@ -3465,6 +3746,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // must still stop the run before it can dispatch more work or write run-end.
                 if (termSignal)
                     throw new Error(`terminated by ${termSignal}`);
+                sweepLiveApprovals();
                 const ready = readyTasks(graph)
                     .filter((t) => !inflight.has(t.id))
                     .slice(0, Math.max(0, concurrency - inflight.size));

package/dist/run/journal.d.ts

@@ -44,6 +44,21 @@ export interface StructuredFinding {
     rationale?: string;
     fingerprint: string;
 }
+declare const CONSULT_ACTIONS: readonly ["retry", "reroute", "decompose", "human"];
+export type ConsultGuidanceAction = (typeof CONSULT_ACTIONS)[number];
+export interface ConsultGuidanceCarry {
+    action: ConsultGuidanceAction;
+    reason?: string;
+    guidance?: string;
+}
+/**
+ * The newest structured consult prescription still open for this task. A consult park is only a
+ * pause: graph-changed revival can dispatch a fresh worker without a live `applyVerdict()` frame, so
+ * prompt-build re-derives the worker-facing bullets from the journal. Notes are deliberately excluded:
+ * they are audit prose, and OBS-37a says workers get only structured reason/guidance rendered by
+ * `renderRetryGuidance()`.
+ */
+export declare function outstandingConsultGuidance(events: JournalEvent[], taskId: string): ConsultGuidanceCarry | undefined;
 export declare const UNIDENTIFIED = "<unidentified>";
 /**
  * Structured findings for a BLOCKING review/judge gate result, parsed from the details the gate
@@ -335,3 +350,4 @@ export declare class Journal {
     readTelemetry(): TelemetryRow[];
     readJudgeTelemetry(): TelemetryRow[];
 }
+export {};