tickmarkr 2.8.4 → 2.8.6

package/dist/gates/cache.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { execSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { checkoutIncarnation, describeCapacity, inventoryDependencyLinks, resolvedCapacity, shGit, verificationProtocol } from "../run/git.js";
 import { shq } from "../adapters/types.js";
+import { trustedCommonDir } from "../run/git-trust.js";
 import { titleEnvironment } from "../run/title-environment.js";
 export const DEFAULT_VERDICT_CACHE_BOUND = 128;
 let testCacheBound;
@@ -269,9 +269,7 @@ export function resolveStateDir(worktree, artifactDir) {
         return join(worktree, ".tickmarkr");
     }
     try {
-        const commonDir = execSync("git rev-parse --git-common-dir", { cwd: worktree, encoding: "utf8" }).trim();
-        const resolved = resolve(worktree, commonDir);
-        const commonRoot = realpathSync(dirname(resolved));
+        const commonRoot = realpathSync(dirname(trustedCommonDir(worktree)));
         if (existsSync(join(commonRoot, ".tickmarkr"))) {
             return join(commonRoot, ".tickmarkr");
         }

package/dist/graph/schema.js

@@ -118,7 +118,9 @@ export const RunGraphSchema = z
         source: z.enum(SPEC_SOURCES),
         paths: z.array(z.string()),
         hash: z.string(),
-        // Q11 compile half: an author-declared ref only. Runtime Git resolution/enforcement is later.
+        // Q11 / queue row 220: an author-declared ref, proven at run and resume start against the run's
+        // starting commit (HEAD for a run, the recorded run-start base for a resume) by ancestry or patch-id;
+        // drifted or unresolvable, the run or resume is refused before it writes anything. Never rebased onto.
         base: z.string().min(1).optional(),
     }),
     tasks: z.array(TaskSchema).min(1),

package/dist/run/daemon.js

@@ -34,7 +34,7 @@ import { executionSignal, remainingExecutionMs, withExecutionBudget, withoutExec
 import { repairSelectionDecision, repairSelectionEnabled } from "./repair-selection.js";
 import { failureDisposition, reserveInfrastructureRetry } from "./recovery.js";
 import { runEnvironment } from "./environment.js";
-import { addDetachedWorktree, changeRepresented, cleanupRunWorktrees, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER, preserveWorktree, producerFields, reflogWitness, removeWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sameVerification, sh, shell, shGit, SUITE_PARENT_ENV, verificationProtocol, WORKTREE_LAYOUT_CONTRACT, WORKTREES_DIR, worktreePath } from "./git.js";
+import { addDetachedWorktree, changeRepresented, cleanupRunWorktrees, declaredBaseContainment, deriveForkCap, FORK_CAP_ENV, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER, preserveWorktree, producerFields, reflogWitness, removeWorktree, resolvedCapacity, runWithForkBudget, runWithVerificationBudget, sameCapacity, sameVerification, sh, shell, shGit, SUITE_PARENT_ENV, verificationProtocol, WORKTREE_LAYOUT_CONTRACT, WORKTREES_DIR, worktreePath } from "./git.js";
 import { MASK } from "./redact.js";
 import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyRepairDisposition, resolveScopeHints } from "./repair-disposition.js";
@@ -1145,6 +1145,48 @@ export function integrationAnchor(events) {
         return { unreadable: `the newest merge row's from is ${show(merge.data.from)}, not an object id` };
     return { anchor: merge.data.commit };
 }
+/**
+ * Queue row 220 (D-2111): prove the spec's declared base against the commit this run starts from — the
+ * checkout HEAD for a fresh run (recorded as its run-start baseRef), the recorded run-start baseRef for a
+ * resume, never the checkout's current HEAD: a resume never re-bases, and no run rebases onto the declared
+ * ref. Drift and an unresolvable answer throw; runDaemon calls this before it writes anything.
+ */
+async function proveDeclaredBase(repoRoot, runId, ref, resume) {
+    const action = resume ? `resume ${runId}` : "run";
+    const remedy = `Remedy: check out a branch that contains ${ref}, or correct base: in the spec and recompile.`;
+    const unresolvable = (against, why) => new Error(`refusing to ${action}: declared base ${ref} is unresolvable against ${against} — ${why}. ${remedy}`);
+    let start;
+    let against;
+    if (resume) {
+        const recorded = Journal.open(repoRoot, runId).read().find((e) => e.event === "run-start")?.data.baseRef;
+        if (typeof recorded !== "string" || !recorded)
+            throw unresolvable("the recorded run-start base", "the journal's run-start records no baseRef");
+        start = recorded;
+        against = `the recorded run-start base ${short(start)}`;
+    }
+    else {
+        const head = await shGit("git rev-parse --verify HEAD^{commit}", repoRoot);
+        if (head.code !== 0)
+            throw unresolvable("HEAD", `git said for HEAD: ${(head.stderr || head.stdout).trim()}`);
+        start = head.stdout.trim();
+        against = `HEAD ${short(start)}`;
+    }
+    const probe = await declaredBaseContainment(repoRoot, ref, start);
+    if (probe.result === "contained")
+        return { ref, via: probe.via, start };
+    if (probe.result === "unresolvable")
+        throw unresolvable(against, `git said for ${probe.ref}: ${probe.evidence}`);
+    const lines = await Promise.all(probe.missing.map(async (m) => {
+        const subject = await shGit(`git log -1 --format=%s ${shq(m.commit)}`, repoRoot);
+        // a drift refusal must name the subject: an unreadable one refuses as unresolvable, quoting git
+        if (subject.code !== 0)
+            throw unresolvable(against, `git said for missing commit ${short(m.commit)}: ${(subject.stderr || subject.stdout).trim()}`);
+        return `  ${short(m.commit)} ${subject.stdout.trim()}${m.merge ? " (merge)" : ""}`
+            + ` — ${m.paths.length > 0 ? m.paths.join(", ") : "no paths"}`;
+    }));
+    throw new Error(`refusing to ${action}: declared base ${ref} has drifted from ${against} — `
+        + `${probe.missing.length} declared commit(s) missing:\n${lines.join("\n")}\n${remedy}`);
+}
 /** The ref legs' details: the leg, both commits, the symbolic target and the repair text. */
 export function identityDetails(leg, state, branch, runId, expected) {
     const found = state.kind === "regular" || state.kind === "symbolic" ? state.commit : undefined;
@@ -2105,6 +2147,12 @@ export async function runDaemon(repoRoot, opts = {}) {
     let baselineFailed = false;
     try {
         graph = loadGraph(repoRoot);
+        // Queue row 220 (D-2111): a declared base is proven HERE — before any journal row (lock-reclaimed and
+        // exit-cause included), the resume anchor checks, a worktree, the integration ref or baseline capture —
+        // so a refusal leaves nothing; the finally releases the lock and repository claim. No base: unchanged.
+        const declaredBase = graph.spec.base === undefined ? undefined
+            : await proveDeclaredBase(repoRoot, runId, graph.spec.base, opts.resume === true);
+        const declaredBaseRow = declaredBase ? { declaredBase: { ref: declaredBase.ref, via: declaredBase.via } } : {};
         // One bounded snapshot supplies every dispatch. On resume the current journal still participates
         // in the fold so its task-done/ordinary-approval events can retire older evidence, but findings it
         // produced are suppressed: same-run feedback already replays those bytes and must not deliver them
@@ -2943,6 +2991,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
                         ...(opts.retryFailed ? { retryFailed: true } : {}),
                         ...(opts.graphChanged ? { graphChanged: true } : {}), // OBS-1073: the release is the engagement's
+                        ...declaredBaseRow,
                     });
                     runStarted = true;
                     await placeBoard();
@@ -2993,7 +3042,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     }
                 }
                 else {
-                    baseRef = await gitHead(repoRoot);
+                    baseRef = declaredBase?.start ?? await gitHead(repoRoot); // row 220: the proven commit is the run's base
                     journal.append("baseline-start", undefined, { baseRef, commands, capacity: resolvedCapacity() });
                     await placeBoard();
                     baselinePending = true;
@@ -3034,6 +3083,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         branch, graphDefinitionHash: graphDefinitionHash(graph),
                         integrationAnchor: "journal", // 2.8.1 T2: this run creates its branch at baseRef and journals every publication with `from`
                         ...(prior ? { supersedes: prior.runId } : {}),
+                        ...declaredBaseRow,
                     }); // 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
@@ -5186,7 +5236,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const icmd = retryMode === "resume"
                             ? adapter.resumeCommand(sessionId, promptFile, assignment.model, assignment.effort)
                             : cfg.visibility.worker === "interactive" && driver.interactive
-                                ? adapter.interactiveCommand(promptFile, assignment.model, assignment.effort)
+                                ? adapter.interactiveCommand(promptFile, assignment.model, assignment.effort, { cwd: wt, branch: taskBranch, repoRoot })
                                 : null;
                         // v1.69 T6: adapters that declare interactiveSeed launch the real TUI and inject the prompt as a
                         // user turn; they do NOT need the argv-seeding surface that interactiveCommand represents.
@@ -5203,7 +5253,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // timing can never interleave a `$(…)` with what follows it (the codex corruption class).
                         const workerCmd = interactive
                             ? (hasSeed ? ":" : icmd)
-                            : adapter.invoke(t, wt, assignment, { promptFile }).command;
+                            : adapter.invoke(t, wt, assignment, { promptFile, branch: taskBranch, repoRoot }).command;
                         const dispatchScript = promptFile.replace(/\.md$/, ".sh");
                         // Approval can reset the attempt counter while the old pane remains retained.
                         // Its ownership claim must survive a new engagement reusing the script path.

package/dist/run/git-trust.d.ts

@@ -4,11 +4,21 @@ export declare class GitTrustRefusal extends Error {
     readonly detail: string;
     constructor(path: string, detail: string, options?: ErrorOptions);
 }
+interface Authority {
+    gitdir: string;
+    common: string;
+    linked: boolean;
+}
 /**
  * The canonical, independently expected common git directory for the checkout enclosing `cwd` — never what
  * a mutable commondir says. Throws GitTrustRefusal naming the authority path when it cannot be established.
  */
 export declare function trustedCommonDir(cwd: string): string;
+/** The checked authority for `cwd` (see assertGitTrust), with the canonical worktree root the gitfile sits in. */
+export declare function checkedAuthority(cwd: string): (Authority & {
+    worktree: string;
+    stamp?: string;
+}) | undefined;
 /**
  * The uncached pre-spawn check for a covered git invocation at `cwd`. Outside any checkout it is a no-op
  * (unrelated shell commands stay compatible). Inside one it refuses, naming the file, when the commondir git
@@ -119,3 +129,4 @@ export declare const INERT_HOOKS_PATH = "/dev/null";
  * children (shGit/shGitOk) receive it; payload shells (gate commands, suites) keep the operator's git config.
  */
 export declare function protectedGitEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export {};

package/dist/run/git-trust.js

@@ -151,7 +151,7 @@ catch {
     return false;
 } };
 /** The checked authority for `cwd` (see assertGitTrust), with the canonical worktree root the gitfile sits in. */
-function checkedAuthority(cwd) {
+export function checkedAuthority(cwd) {
     const dotGit = dotGitOf(cwd);
     if (!dotGit)
         return undefined;

package/dist/run/git.d.ts

@@ -1,5 +1,5 @@
 import type { CommandReceiptAttribution, ShellReceipt } from "./protocol.js";
-import { spawn } from "node:child_process";
+import { spawn, type SpawnSyncReturns } from "node:child_process";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 import { type OwnGitCapability } from "./git-trust.js";
 export { ROUTING_ENV_SEAMS };
@@ -187,6 +187,18 @@ export declare function sh(cmd: string, cwd: string, timeoutMs?: number, options
 export declare function shGit(cmd: string, cwd: string, timeoutMs?: number, own?: OwnGitOptions, options?: Pick<ShellOptions, "bytes">): Promise<ShResult>;
 export declare function shOk(cmd: string, cwd: string): Promise<string>;
 export declare function shGitOk(cmd: string, cwd: string, own?: OwnGitOptions): Promise<string>;
+/**
+ * Queue row 2 item b (D-1042, D-2112, D-2114): the SYNCHRONOUS own-git entry for operator commands — argv, no shell.
+ * It applies what shGit's own-git entry applies, from the same sources: the uncached trust check and, in a linked
+ * checkout, ownGitPin's pin, post-exit recheck and ref-view release, each derived from `dir` — the directory git
+ * targets (a site's -C directory), never the caller's cwd — and protectedGitEnv's forced core.fsmonitor=false and
+ * inert core.hooksPath appended last. A trust refusal throws GitTrustRefusal naming the path (before the spawn, or
+ * after it for a commondir changed while the child ran); every other outcome is spawnSync's own result, so a caller's
+ * fail-open answer for an ordinary git failure is unchanged.
+ */
+export declare function gitSync(dir: string, args: readonly string[], { env }?: {
+    env?: NodeJS.ProcessEnv;
+}): SpawnSyncReturns<string>;
 /**
  * v2.6.8 T2: the DETACHED worktree capability, declared by calling it (the daemon's baseline recapture and standalone
  * verify's base worktree). Under the ref-store pin git stubs a detached add's new HEAD as `ref: refs/heads/.invalid`

package/dist/run/git.js

@@ -2,14 +2,15 @@ import { observeVerificationReceipt, observeVerificationSpawn, verificationJobEn
 import { executionSignal, withoutExecutionBudget } from "./execution-budget.js";
 import { commandLeaseEnvironment, repositoryLeaseEnvironment, registerRepositoryChild, withCommandLease } from "./lease.js";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFile, execFileSync, spawn } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmdirSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { availableParallelism, homedir, tmpdir } from "node:os";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { shq } from "../adapters/types.js";
 import { tickmarkrDir } from "../graph/graph.js";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
+import { HOST_SESSION_VARS } from "../drivers/host-env.js";
 import { titleEnvironment } from "./title-environment.js";
 import { assertGitTrust, GitTrustRefusal, ownGitPin, protectedGitEnv, trustedCommonDir } from "./git-trust.js";
 export { ROUTING_ENV_SEAMS };
@@ -330,6 +331,9 @@ function executeShell(cmd, cwd, timeoutMs, login, options, observation, ownGit)
     const env = ownGit ? protectedGitEnv(payloadEnv) : payloadEnv;
     for (const k of ROUTING_ENV_SEAMS)
         delete env[k];
+    // Queue row 193 (D-2102 add.1): no gate or agent child inherits the launching agent session's host variables.
+    for (const k of HOST_SESSION_VARS)
+        delete env[k];
     // A run freezes the operator override and cores at startup; admission can lower the round cap.
     env[FORK_CAP_ENV] = verificationBudget.getStore()
         ? String(resolvedCapacity().forkCap)
@@ -596,6 +600,27 @@ export async function shGitOk(cmd, cwd, own = {}) {
         throw new Error(`command failed (${r.code}): ${cmd}\n${r.stderr || r.stdout}`);
     return r.stdout;
 }
+/**
+ * Queue row 2 item b (D-1042, D-2112, D-2114): the SYNCHRONOUS own-git entry for operator commands — argv, no shell.
+ * It applies what shGit's own-git entry applies, from the same sources: the uncached trust check and, in a linked
+ * checkout, ownGitPin's pin, post-exit recheck and ref-view release, each derived from `dir` — the directory git
+ * targets (a site's -C directory), never the caller's cwd — and protectedGitEnv's forced core.fsmonitor=false and
+ * inert core.hooksPath appended last. A trust refusal throws GitTrustRefusal naming the path (before the spawn, or
+ * after it for a commondir changed while the child ran); every other outcome is spawnSync's own result, so a caller's
+ * fail-open answer for an ordinary git failure is unchanged.
+ */
+export function gitSync(dir, args, { env = process.env } = {}) {
+    const forced = protectedGitEnv(env);
+    const pin = ownGitPin(dir, forced);
+    try {
+        const r = spawnSync("git", args, { cwd: dir, env: pin?.env ?? forced, encoding: "utf8", maxBuffer: 1 << 28, stdio: ["ignore", "pipe", "pipe"] });
+        pin?.recheck();
+        return pin && typeof r.stdout === "string" ? { ...r, stdout: pin.unview(r.stdout), stderr: pin.unview(r.stderr) } : r;
+    }
+    finally {
+        pin?.release();
+    }
+}
 /**
  * v2.6.8 T2: the DETACHED worktree capability, declared by calling it (the daemon's baseline recapture and standalone
  * verify's base worktree). Under the ref-store pin git stubs a detached add's new HEAD as `ref: refs/heads/.invalid`
@@ -1089,19 +1114,14 @@ export async function probeRefsWritable(cwd = process.cwd()) {
         const error = (delRes.stderr || delRes.stdout).trim() || `git update-ref -d failed (${delRes.code})`;
         return { ok: false, path: refsDir, refsDir, error };
     }
-    // Clean up empty directories left behind by git
-    try {
-        const preflightDir = join(refsDir, "tickmarkr", "preflight");
-        if (existsSync(preflightDir) && readdirSync(preflightDir).length === 0) {
-            rmSync(preflightDir, { recursive: true, force: true });
-        }
-        const tmDir = join(refsDir, "tickmarkr");
-        if (existsSync(tmDir) && readdirSync(tmDir).length === 0) {
-            rmSync(tmDir, { recursive: true, force: true });
+    // Queue row 194 (D-2102): remove only EMPTY directories git left behind, non-recursively — rmdir(2)
+    // refuses (ENOTEMPTY) a ref another process writes under refs/tickmarkr at this moment, where an
+    // emptiness check followed by a recursive remove deleted it. Best-effort: a refusal leaves the tree.
+    for (const dir of [join(refsDir, "tickmarkr", "preflight"), join(refsDir, "tickmarkr")]) {
+        try {
+            rmdirSync(dir);
         }
-    }
-    catch {
-        // best-effort cleanup of empty dirs
+        catch { /* absent, or no longer empty */ }
     }
     return { ok: true, path: refsDir, refsDir };
 }

package/dist/run/journal.d.ts

@@ -42,7 +42,14 @@ export declare const bindingToken: (binding: DecisionBinding) => string;
 export declare function parseBindingToken(token: string): DecisionBinding | undefined;
 /** The binding a task-approved row recorded under `park` or `failure`, when well formed. */
 export declare function recordedBinding(value: unknown): DecisionBinding | undefined;
-/** The newest failed gate before a park row — the gate a waive of that park would satisfy. */
+/**
+ * The newest failed gate before a park row — the gate a waive of that park would satisfy.
+ * Queue row 225 (D-2111): a gate-fail park with no task-dispatch, gate-result (passing or failing) or
+ * unvoided task-approved row of its task since its previous task-human — a resume's re-park at the same
+ * review round cap — inherits that park's failed gate, the walk continuing past it. A task-approved row
+ * an approval-refused row of the task voids before the newer park (its lines name it, or it names none)
+ * does not end the walk; refusals are read here directly, never through foldDecisions (which calls this).
+ */
 export declare function failedGateBeforePark(events: readonly JournalEvent[], taskId: string, parkIndex: number): GateName | undefined;
 /** The physical journal line of `events[i]` (see SOURCE_LINE). */
 export declare const physicalLine: (events: readonly JournalEvent[], i: number) => number;
@@ -96,6 +103,13 @@ export interface PreservedRef {
 export declare function preservedRefsByTask(events: JournalEvent[]): Map<string, PreservedRef[]>;
 export declare function reviewRoundsSinceApproval(events: JournalEvent[], taskId: string, rounds?: (decided: JournalEvent[]) => JournalEvent[]): number;
 export declare function upheldFeedbackByTask(events: JournalEvent[]): Map<string, string>;
+/**
+ * Queue row 225 (D-2111): a restore names upheld feedback only when it is FUNDED — the task carries an
+ * active uphold brief AND an effective task-approved row newer than its newest task-human. A restore
+ * that only re-parks at the same cap announces nothing, so a spent uphold is never re-announced.
+ * `decided` is already read through the decision fold (effectiveEvents).
+ */
+export declare function restoresUpheldFeedback(decided: JournalEvent[], taskId: string): boolean;
 export interface StructuredFinding {
     class: string;
     path: string;

package/dist/run/journal.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { channelKey, shq, TokenUsageSchema } from "../adapters/types.js";
@@ -11,7 +11,7 @@ import { channelRouteIdentity, modelProvider } from "../route/preference.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { DecisionEventSchema, trackJournalRows, } from "./protocol.js";
 import { PRESERVE_COMMIT_SUBJECT, PRESERVE_PRODUCER_TRAILER } from "./git.js";
-import { assertGitTrust, protectedGitEnv } from "./git-trust.js";
+import { assertGitTrust, protectedGitEnv, trustedCommonDir } from "./git-trust.js";
 import { normalizeGateOutcome } from "./outcome.js";
 import { redactSecrets } from "./redact.js";
 export function phaseForGate(gate) {
@@ -97,17 +97,44 @@ export function recordedBinding(value) {
     const { line, ts } = value;
     return typeof line === "number" && Number.isSafeInteger(line) && line > 0 && typeof ts === "string" ? { line, ts } : undefined;
 }
-/** The newest failed gate before a park row — the gate a waive of that park would satisfy. */
+/**
+ * The newest failed gate before a park row — the gate a waive of that park would satisfy.
+ * Queue row 225 (D-2111): a gate-fail park with no task-dispatch, gate-result (passing or failing) or
+ * unvoided task-approved row of its task since its previous task-human — a resume's re-park at the same
+ * review round cap — inherits that park's failed gate, the walk continuing past it. A task-approved row
+ * an approval-refused row of the task voids before the newer park (its lines name it, or it names none)
+ * does not end the walk; refusals are read here directly, never through foldDecisions (which calls this).
+ */
 export function failedGateBeforePark(events, taskId, parkIndex) {
+    let inherits = events[parkIndex]?.data.kind === "gate-fail";
+    let refused = new Set();
     for (let i = parkIndex - 1; i >= 0; i -= 1) {
         const event = events[i];
         if (event.taskId !== taskId)
             continue;
-        if (event.event === "task-approved" || event.event === "task-human" || event.event === "task-dispatch")
+        if (event.event === "task-human") {
+            // Only a gate-fail predecessor has a failed gate to hand down; any other kind ends the walk as today.
+            if (!inherits || event.data.kind !== "gate-fail")
+                return undefined;
+            // The walk now reads the previous park's own span, under that park's own refusals.
+            refused = new Set();
+        }
+        else if (event.event === APPROVAL_REFUSED) {
+            if (refused !== "all")
+                refused = Array.isArray(event.data.lines) ? new Set([...refused, ...event.data.lines]) : "all";
+        }
+        else if (event.event === "task-approved") {
+            if (!inherits || (refused !== "all" && !refused.has(physicalLine(events, i))))
+                return undefined;
+        }
+        else if (event.event === "task-dispatch") {
             return undefined;
-        if (event.event === "gate-result" && event.data.pass === false
-            && typeof event.data.gate === "string" && GATE_NAMES.includes(event.data.gate)) {
-            return event.data.gate;
+        }
+        else if (event.event === "gate-result") {
+            if (event.data.pass === false && typeof event.data.gate === "string" && GATE_NAMES.includes(event.data.gate)) {
+                return event.data.gate;
+            }
+            inherits = false; // a passing gate-result keeps the park's own span
         }
     }
     return undefined;
@@ -321,6 +348,16 @@ export function upheldFeedbackByTask(events) {
     }
     return upheld;
 }
+/**
+ * Queue row 225 (D-2111): a restore names upheld feedback only when it is FUNDED — the task carries an
+ * active uphold brief AND an effective task-approved row newer than its newest task-human. A restore
+ * that only re-parks at the same cap announces nothing, so a spent uphold is never re-announced.
+ * `decided` is already read through the decision fold (effectiveEvents).
+ */
+export function restoresUpheldFeedback(decided, taskId) {
+    const newest = (event) => decided.reduce((at, e, i) => e.taskId === taskId && e.event === event ? i : at, -1);
+    return newest("task-approved") > newest("task-human") && upheldFeedbackByTask(decided).has(taskId);
+}
 const CONSULT_ACTIONS = ["retry", "reroute", "decompose", "human"];
 const consultAction = (action) => typeof action === "string" && CONSULT_ACTIONS.includes(action)
     ? action
@@ -1651,30 +1688,59 @@ export function engagementComparable(events, loadedHash) {
     return recorded === loadedHash ? { comparable: true, recorded } : { comparable: false, reason: "mismatch", recorded };
 }
 const RUN_SEQUENCE_WIDTH = 16;
+const TICKET = /^\d{16}$/;
+const ticketsIn = (dir) => {
+    try {
+        return readdirSync(dir).filter((name) => TICKET.test(name));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+};
+const highest = (tickets) => tickets.reduce((max, name) => (BigInt(name) > max ? BigInt(name) : max), 0n);
 // The daemon mints before acquiring graph.lock, and each CLI invocation has fresh module state. Claim
-// a repository-state ticket with mkdir's atomic EEXIST boundary instead: a losing process advances and
-// retries, while the winning directory remains as the durable high-water evidence for later invocations.
+// a ticket with mkdir's atomic EEXIST boundary: a losing process advances and retries. Queue row 194
+// (D-2102): the sequence lives at the trusted common git dir, shared by the main checkout and every
+// linked worktree (a trust refusal refuses — never a per-checkout fallback), and its first ticket sits
+// above this checkout's own pre-change sequence. Pruning keeps it bounded, and the durable high-water
+// mark is the highest ticket itself: a prune removes a ticket only after seeing a higher one, so the
+// highest ever claimed survives. A stale reader can recreate a pruned ticket, but then sees that higher
+// one and claims again above it — only a ticket that is the highest after its own mkdir is issued.
 function claimRunSequence(repoRoot = process.cwd()) {
-    const dir = join(tickmarkrDir(repoRoot), "run-id-sequence");
+    const dir = join(trustedCommonDir(repoRoot), "tickmarkr-run-id-sequence");
     mkdirSync(dir, { recursive: true });
-    const allocated = readdirSync(dir).filter((name) => /^\d{16}$/.test(name));
-    let candidate = allocated.reduce((max, name) => {
-        const value = BigInt(name);
-        return value > max ? value : max;
-    }, 0n) + 1n;
+    const own = highest(ticketsIn(join(repoRoot, stateDirName(repoRoot), "run-id-sequence")));
+    const shared = highest(ticketsIn(dir));
+    let candidate = (own > shared ? own : shared) + 1n;
     while (true) {
         const suffix = candidate.toString().padStart(RUN_SEQUENCE_WIDTH, "0");
         if (suffix.length > RUN_SEQUENCE_WIDTH)
             throw new Error("run id sequence exhausted");
         try {
             mkdirSync(join(dir, suffix));
-            return suffix;
         }
         catch (error) {
             if (error.code !== "EEXIST")
                 throw error;
             candidate += 1n;
+            continue;
+        }
+        const tickets = ticketsIn(dir);
+        const top = highest(tickets);
+        if (top > candidate) {
+            candidate = top + 1n;
+            continue;
+        }
+        for (const name of tickets) {
+            if (BigInt(name) < candidate)
+                try {
+                    rmdirSync(join(dir, name));
+                }
+                catch { /* a concurrent prune took it */ }
         }
+        return suffix;
     }
 }
 export function newRunId(now = new Date()) {
@@ -1979,7 +2045,7 @@ export class Journal {
                 const folded = !decisionRow && data.fatal === true ? [...priorEvents, { ts: new Date().toISOString(), event, data }] : priorEvents;
                 return decisionRow ? reduced : { ...reduced, owedChecks: foldOwedChecks(folded, join(this.dir, "..", "..", "..")) };
             })()
-            : event === "resume-restore" && rowTaskId && upheldFeedbackByTask(effectiveEvents(priorEvents)).has(rowTaskId)
+            : event === "resume-restore" && rowTaskId && restoresUpheldFeedback(effectiveEvents(priorEvents), rowTaskId)
                 ? {
                     ...inputData,
                     upheldFeedbackRestoredFor: rowTaskId,

package/dist/run/lock.d.ts

@@ -3,6 +3,8 @@ export declare const STALE_MS = 60000;
 export interface Inspection {
     pid?: number;
     runId?: string;
+    startedAt?: number;
+    checkout?: string;
     garbage: boolean;
     dead: boolean;
     expired: boolean;
@@ -15,6 +17,9 @@ export type RunLineEvent = {
 };
 export declare function shouldRefuse(i: Pick<Inspection, "garbage" | "dead">): boolean;
 export declare function isPidLive(pid: number): boolean;
+/** The repository run claim for the checkout enclosing `repoRoot`; undefined when no checkout encloses it
+ * (graph.lock alone guards there, as before). Any other git trust refusal propagates: fail closed. */
+export declare function repositoryClaimPath(repoRoot: string): string | undefined;
 export declare function acquireRunLock(repoRoot: string, runId: string): {
     reclaimed?: {
         pid: number;