tickmarkr 2.1.8 → 2.2.0

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";
@@ -15,13 +16,14 @@ 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 { 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 +78,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 +693,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 +1177,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 +1189,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
@@ -1093,8 +1296,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 +1372,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 +1439,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;
@@ -1801,7 +2044,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 +2102,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 +2138,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 +2207,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 +2242,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 +2342,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
@@ -3465,6 +3717,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 {};

package/dist/run/journal.js

@@ -148,6 +148,40 @@ export function upheldFeedbackByTask(events) {
     }
     return upheld;
 }
+const CONSULT_ACTIONS = ["retry", "reroute", "decompose", "human"];
+const consultAction = (action) => typeof action === "string" && CONSULT_ACTIONS.includes(action)
+    ? action
+    : undefined;
+/**
+ * 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 function outstandingConsultGuidance(events, taskId) {
+    let carry;
+    for (const e of events) {
+        if (e.taskId !== taskId)
+            continue;
+        if (e.event === "consult-verdict") {
+            const action = consultAction(e.data.action);
+            const reason = typeof e.data.reason === "string" && e.data.reason.trim() ? e.data.reason : undefined;
+            const guidance = typeof e.data.guidance === "string" && e.data.guidance.trim() ? e.data.guidance : undefined;
+            carry = action && (reason || guidance)
+                ? {
+                    action,
+                    ...(reason ? { reason } : {}),
+                    ...(guidance ? { guidance } : {}),
+                }
+                : undefined;
+        }
+        else if (e.event === "task-done" || e.event === "merge") {
+            carry = undefined;
+        }
+    }
+    return carry;
+}
 // Reserved for a finding whose OWN evidence names no path. Reporting a blank path a reader would take
 // for a resolved one is the silent-lie shape the gates exist to refuse, so the field says so outright.
 export const UNIDENTIFIED = "<unidentified>";
@@ -1360,16 +1394,27 @@ export class Journal {
         }
         return m;
     }
-    // OBS-130: gate satisfaction is authority, not an inferred daemon state. Only an explicit
-    // task-approved event with the typed release marker and a known gate enters this fold. A daemon-made
-    // gate-satisfied event, a prior pass/fail result, malformed data, or another task's approval is inert.
+    // OBS-130/OBS-571: gate satisfaction is authority, not an inferred daemon state. Only an explicit
+    // task-approved event with the typed release marker and a known gate enters this fold. Authority is
+    // scoped to that approval: any later approval supersedes it, and the worktree-recreation row written
+    // before the approved gate suffix runs consumes it at enactment. A daemon-made gate-satisfied event,
+    // a prior pass/fail result, malformed data, or another task's approval is inert.
     replaySatisfiedGates() {
         const satisfied = new Map();
         for (const e of this.read()) {
-            if (e.event !== "task-approved" || !e.taskId || e.data.release !== GATE_SATISFIED_RELEASE)
+            if (!e.taskId)
                 continue;
-            if (typeof e.data.gate === "string" && GATE_NAMES.includes(e.data.gate)) {
-                satisfied.set(e.taskId, e.data.gate);
+            if (e.event === "worktree-recreation") {
+                satisfied.delete(e.taskId);
+                continue;
+            }
+            if (e.event === "task-approved") {
+                satisfied.delete(e.taskId);
+                if (e.data.release === GATE_SATISFIED_RELEASE
+                    && typeof e.data.gate === "string"
+                    && GATE_NAMES.includes(e.data.gate)) {
+                    satisfied.set(e.taskId, e.data.gate);
+                }
             }
         }
         return satisfied;

package/dist/tui/cockpit/setup-cockpit.d.ts

@@ -1,4 +1,5 @@
 import { type ReactElement } from "react";
+import { type ApprovalDisposition, type ApprovalRunOwner } from "../../cli/commands/approve.js";
 import { Journal } from "../../run/journal.js";
 import { type TickmarkrConfig } from "../../config/config.js";
 import { type ComponentState, type JournalRow } from "./components.js";
@@ -73,15 +74,8 @@ export type ParkedDecision = {
 };
 /** The parks a verb can release — the rows the surface draws live verbs on. */
 export declare function actionableDecisions(decisions: readonly ParkedDecision[]): readonly ParkedDecision[];
-/**
- * The decisions section's rows: one per task the journal's own status replay
- * leaves parked on a human, in the order the journal first named them. The
- * replay is the production one (`Journal.replayStatuses`) so this surface and
- * `tickmarkr status` can never disagree about what is parked.
- */
 export declare function deriveParkedDecisions(journal: Journal): readonly ParkedDecision[];
-/** The two decisions a parked task offers — the production command's two verbs. */
-export type SetupDecisionVerb = "approve" | "uphold";
+export type SetupDecisionVerb = "approve" | "waive" | "uphold" | "recheck";
 /** A decision the operator has named but not yet confirmed. */
 export type SetupDecisionCommand = {
     readonly verb: SetupDecisionVerb;
@@ -93,6 +87,7 @@ export type SetupDecisionWrite = {
     readonly verb: SetupDecisionVerb;
     /** The release marker read back from the recorded task-approved event. */
     readonly release: string | undefined;
+    readonly disposition: ApprovalDisposition;
     readonly by: string;
 };
 /**
@@ -120,6 +115,7 @@ export type SetupDecisionsKeyResult = {
  * inert and the keybar does not advertise it — the surface never promises a
  * decision the command must refuse.
  */
+export declare function setupDecisionVerbs(decision: ParkedDecision): readonly SetupDecisionVerb[];
 export declare function upholdAvailable(decision: ParkedDecision): boolean;
 /**
  * The decisions surface's whole key grammar: ↑↓ move, a approve, u uphold,
@@ -160,7 +156,7 @@ export declare function recordSetupDecisionOutcome(session: SetupDecisionsSessio
  * The confirm inset's lines: the task, the actor, the effect and the file,
  * stated before the single key that can write.
  */
-export declare function setupDecisionConfirmLines(command: SetupDecisionCommand, decision: ParkedDecision | undefined, actor: string, journalFile: string): readonly string[];
+export declare function setupDecisionConfirmLines(command: SetupDecisionCommand, decision: ParkedDecision | undefined, actor: string, journalFile: string, run: ApprovalRunOwner): readonly string[];
 /**
  * The decisions surface. Every row it draws — decisions, the confirm inset,
  * the pending writes region — is measured and clipped through the width
@@ -168,12 +164,14 @@ export declare function setupDecisionConfirmLines(command: SetupDecisionCommand,
  * neither overflow its row nor be cut mid-cluster. The one unclipped element
  * is `notice`: the production command's own words, verbatim.
  */
-export declare function SetupDecisionsSurface({ decisions, session, columns, actor, journalFile, }: {
+export declare function SetupDecisionsSurface({ decisions, session, columns, actor, journalFile, run, }: {
     decisions: readonly ParkedDecision[];
     session: SetupDecisionsSession;
     columns: number;
     actor: string;
     journalFile: string;
+    /** Who enacts a confirmed write — read from the run lock, never assumed. */
+    run: ApprovalRunOwner;
 }): ReactElement;
 /**
  * The setup decisions surface on a live engagement. This is the only cockpit