tickmarkr 2.8.6 → 2.8.8

package/dist/run/daemon.js

@@ -1,7 +1,7 @@
 import { HOST_PROBE_SAMPLE_MS, HOST_PROBE_SAMPLES, HostDegradedError, hostDegraded, observeHost } from "./host-health.js";
 import { runWithInterruptionSink, VITEST_CACHE_ENV, worktreeVitestCache } from "../gates/test-manifest.js";
 import { COMMAND_LEASE_TOKEN_ENV, commandLeaseEnvironment, CommandLeases, currentCommandLeaseToken, isRunnerCommand, runWithCommandLease, withCommandLease } from "./lease.js";
-import { execFileSync, spawn } from "node:child_process";
+import { execFile, execFileSync, spawn } 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, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -23,7 +23,7 @@ import { herdrSealShellPrefix, MAX_BUF, SubprocessDriver } from "../drivers/subp
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
 import { reobserveTestFiles, runGates } from "../gates/run-gates.js";
-import { getVerdictStore, isInfraResult, resolveStateDir } from "../gates/cache.js";
+import { environmentFingerprint, getVerdictStore, isInfraResult, resolveStateDir } from "../gates/cache.js";
 import { RUNNER_INFRA_DIAGNOSTIC_RE, timeoutShaped } from "../gates/timeout-shaped.js";
 import { filesGlob } from "../graph/files-glob.js";
 import { addEvidence, attributeBlocked, batteryPriority, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
@@ -34,10 +34,10 @@ 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, 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 { addDetachedWorktree, changeRepresented, cleanupRunWorktrees, declaredBaseContainment, dependencyLinkRefusal, 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, WorktreeAdminRaceError, 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";
+import { classifyRepairDisposition, namedPaths, resolveScopeHints } from "./repair-disposition.js";
 import { applyScopeAmendments, activeRetryBan, interruptedAttempt, RESUME_HARVEST_SOURCE, resumeHarvestAuthor, approvalAction, APPROVAL_REFUSED, bindingToken, effectiveEvents, foldDecisions, physicalLine, staleApprovals, classifyTaskFailure, classifyWorkerResultCause, deferredReviewFindings, engagementComparable, formatPriorFindingEvidence, GATE_FINGERPRINT_CAP, GATE_SATISFIED_RELEASE, identicalGateFailures, isDeferredFinding, journaledFailureBrief, Journal, loadRoutingProfile, newRunId, normalizeGateFailure, outstandingConsultGuidance, readableExcerpt, receiptOrigin, outstandingReviewFindings, pendingApprovalActions, pendingRechecks, pendingRepairFindings, phaseForGate, priorJudgments, readPriorRunEvidence, recordedTaskFailureKind, reraisedReviewChains, RECHECK_RELEASE, renderStructuredReviewFinding, repairReachSinceApproval, repairsSinceApproval, reviewRoundsSinceApproval, runHasEnded, standingRulings, structuredFindings, upheldFeedbackByTask } from "./journal.js";
 import { carriedAuthorVendors, gateReviewerFloor, isDiffCapPark, isGarbageReview, pickReviewer } from "../gates/review.js";
 import { acquireApprovalSerialization, acquireRunLock, isPidLive, releaseRunLock } from "./lock.js";
@@ -855,7 +855,11 @@ export function resetDeadChannelFastKillMsForTests() {
 // monotonic-tracker silence — CONCLUDES the wait. Conclude, never kill: the pane is harvested by
 // the same tail a window expiry uses, and the carried worktree goes straight to gates. Set at the
 // fast-kill's window on purpose (the OBS-264 arithmetic is "a ~36m stall + ~15m redo becomes a
-// ~5m gate pass"); a worker that is merely thinking still burns CPU and is never concluded here.
+// ~5m gate pass"). Queue row 231 (D-2119): a headless worker waiting on its remote provider can be
+// silent with flat CPU. Print mode also requires a fresh reading of no ESTABLISHED TCP connection
+// in its owned process group; connected or unreadable holds the harvest. Interactive workers keep
+// the triad: an idle pane holds connections too. Residual (D-2125): a truly hung headless worker
+// holding a connection rides the stall window instead.
 const HARVEST_SILENT_MS = 5 * 60_000;
 let harvestSilentMs = HARVEST_SILENT_MS;
 /** Test seam — shrink the harvest silence gate without minute-long sleeps. */
@@ -879,6 +883,32 @@ export const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries committ
 export function commandsHash(commands) {
     return createHash("sha256").update(JSON.stringify(Object.entries(commands).sort())).digest("hex").slice(0, 12);
 }
+// Queue row 24 (D-2134): refuse links before npm probes; an unreadable identity stays absent for the battery's infra row.
+function measureTipEnvironment(worktree, capacity) {
+    if (dependencyLinkRefusal(worktree))
+        return undefined;
+    try {
+        return environmentFingerprint({ worktree, scope: "tip", capacity });
+    }
+    catch {
+        return undefined;
+    }
+}
+// Queue row 24 (D-2134): validate the parts too; a matching fingerprint alone cannot rescue a malformed stamp.
+function sameTipEnvironment(recorded, current) {
+    if (!current || !recorded || typeof recorded !== "object" || Array.isArray(recorded))
+        return false;
+    const { fingerprint, parts } = recorded;
+    if (fingerprint !== current.fingerprint || !parts || typeof parts !== "object" || Array.isArray(parts))
+        return false;
+    const p = parts;
+    const verification = p.verification;
+    return p.nodeRuntime === current.parts.nodeRuntime && p.runner === current.parts.runner
+        && p.lockfile === current.parts.lockfile && p.selectedSet === undefined
+        && p.capacity !== undefined && sameCapacity(p.capacity, current.parts.capacity)
+        && !!verification && (verification.source === "explicit" || verification.source === "npm-config")
+        && sameVerification(verification, current.parts.verification);
+}
 /**
  * T4 (OBS-266): the journal's LAST verification cycle — the (tip, cmdHash) pair the most recent run
  * of the verify commands spoke for, the gates it got a pass from, and whether anything failed in it.
@@ -900,7 +930,7 @@ function lastVerifyCycle(events) {
         if (e.event === "tip-verify-start") {
             const { tip, cmdHash } = e.data;
             cur = typeof tip === "string" && typeof cmdHash === "string"
-                ? { tip, cmdHash, gates: new Set(), failed: false, forgiven: false, capacities: [e.data.capacity], evidenceByGate: new Map() }
+                ? { tip, cmdHash, gates: new Set(), failed: false, forgiven: false, capacities: [e.data.capacity], tipEnvironments: [e.data.tipEnvironment], evidenceByGate: new Map() }
                 : undefined;
             afterRunEnd = false;
             continue;
@@ -923,7 +953,7 @@ function lastVerifyCycle(events) {
             continue;
         }
         if (!cur || afterRunEnd || cur.tip !== tip || cur.cmdHash !== cmdHash) {
-            cur = { tip, cmdHash, gates: new Set(), failed: false, forgiven: false, capacities: [], evidenceByGate: new Map() };
+            cur = { tip, cmdHash, gates: new Set(), failed: false, forgiven: false, capacities: [], tipEnvironments: [], evidenceByGate: new Map() };
         }
         afterRunEnd = false;
         // T7: EVERY verdict row's own capacity, not just the start row's. The start row is a statement of
@@ -931,6 +961,7 @@ function lastVerifyCycle(events) {
         // these rows, so a row whose capacity differs from the session's — or which is malformed — has to
         // be able to sink the cycle by itself.
         cur.capacities.push(e.data.capacity);
+        cur.tipEnvironments.push(e.data.tipEnvironment);
         if (e.event === "tip-verify-failed")
             cur.failed = true;
         else {
@@ -1200,13 +1231,13 @@ export function identityDetails(leg, state, branch, runId, expected) {
  */
 export function appendIdentityFailure(journal, f) {
     if (!f.started)
-        journal.append("tip-verify-start", undefined, { tip: f.expected, cmdHash: f.cmdHash, capacity: f.capacity, gates: [], cached: false });
+        journal.append("tip-verify-start", undefined, { tip: f.expected, cmdHash: f.cmdHash, capacity: f.capacity, tipEnvironment: f.tipEnvironment, gates: [], cached: false });
     const found = f.state?.kind === "regular" || f.state?.kind === "symbolic" ? f.state.commit : undefined;
     journal.append("tip-verify-failed", undefined, {
         gate: "integration", cmd: "", exitCode: 1, fingerprints: [], details: f.details, ...(f.infra ? { infra: true } : {}),
         integration: { branch: f.branch, expected: f.expected ?? null, found: found ?? null, leg: f.leg,
             ...(f.state?.kind === "symbolic" ? { target: f.state.target } : {}) },
-        tip: f.expected, cmdHash: f.cmdHash, capacity: f.capacity,
+        tip: f.expected, cmdHash: f.cmdHash, capacity: f.capacity, tipEnvironment: f.tipEnvironment,
     });
 }
 /** O: I(expected) — or, with no expected value, the ref must be regular and its commit becomes the expected. */
@@ -1267,16 +1298,12 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
     opts.signal?.throwIfAborted();
     const cmdHash = commandsHash(commands);
     const { identity } = opts;
-    // T7: the capacity this session's verify children WOULD run under — the third thing a carried
-    // green must match, beside the tip and the command set. A cached verdict is the one place a green
-    // crosses a session boundary with nothing re-run, and a session resumed at a different capacity
-    // divides the machine by a different number: that green was established in another world, so it is
-    // not carried forward and the commands run again. A pre-T7 cycle records no capacity and keeps
-    // exactly the behaviour it has today.
+    // Queue row 24 (D-2134): measure once against the repository whose installed packages the verifier receives.
     const capacity = resolvedCapacity();
+    const tipEnvironment = measureTipEnvironment(identity?.repo ?? intWt, capacity);
     const identityFailure = (f) => {
-        appendIdentityFailure(journal, { ...f, branch: identity.branch, cmdHash, capacity });
-        return { failed: true, identityFailed: true, deferred: [] };
+        appendIdentityFailure(journal, { ...f, branch: identity.branch, cmdHash, capacity, tipEnvironment });
+        return { failed: true, identityFailed: true, deferred: [], tipEnvironment };
     };
     let tip;
     let clean = true; // with `identity` the battery runs in a fresh checkout and K checks tracked content
@@ -1295,25 +1322,30 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
     const gates = Object.keys(commands).filter((g) => g !== "tipTest");
     if (!gates.includes("test") && commands.tipTest)
         gates.push("test");
+    // Queue row 24 (D-2134 R2/Q6/Q7): carry requires tip, commands, every gate and capacity AND the stamped runner
+    // and environment identity with a measured lifecycle on every row. An unstamped cycle re-verifies once.
+    // Package content drift under equal lockfile and links is the declared residual, as in per-gate reuse.
     const cached = last !== undefined && !last.failed && !last.forgiven && last.tip === tip && last.cmdHash === cmdHash
         && gates.every((g) => last.gates.has(g))
-        && last.capacities.every((recorded) => sameCapacity(recorded, capacity));
+        && last.capacities.every((recorded) => sameCapacity(recorded, capacity))
+        && last.tipEnvironments.every((recorded) => sameTipEnvironment(recorded, tipEnvironment))
+        && !dependencyLinkRefusal(identity?.repo ?? intWt);
     // A pair can be verified red and then green without either SHA or command hash changing (for
     // example, an external service or ignored fixture recovers). Delimit attempts explicitly so that
     // the earlier red cannot remain latched into the later complete green cycle.
-    journal.append("tip-verify-start", undefined, { tip, cmdHash, capacity, gates, cached: clean && cached });
+    journal.append("tip-verify-start", undefined, { tip, cmdHash, capacity, tipEnvironment, gates, cached: clean && cached });
     opts.signal?.throwIfAborted();
     if (clean && cached) {
-        journal.append("tip-verify-cached", undefined, { tip, cmdHash, capacity, gates });
+        journal.append("tip-verify-cached", undefined, { tip, cmdHash, capacity, tipEnvironment, gates });
         // The skip must not read as a red. Every surface derives the tip's verdict from this cycle's
         // `tip-verify` events (cockpit derive.ts tipVerificationPassed: a run-end claiming "passed" with
         // ZERO events is fail-closed to FALSE), so a carried-forward green still journals its per-gate
         // pass — `cached: true` keeps it honest about not having re-run the command.
         for (const gate of gates) {
             const cmd = gate === "test" && commands.tipTest ? commands.tipTest : commands[gate];
-            journal.append("tip-verify", undefined, { ...reusedTipEvidence(last.evidenceByGate.get(gate) ?? {}), gate, cmd, pass: true, exitCode: 0, cached: true, tip, cmdHash, capacity });
+            journal.append("tip-verify", undefined, { ...reusedTipEvidence(last.evidenceByGate.get(gate) ?? {}), gate, cmd, pass: true, exitCode: 0, cached: true, tip, cmdHash, capacity, tipEnvironment });
         }
-        return identity ? { failed: false, expected: tip, identityFailed: false, deferred: [] } : false;
+        return identity ? { failed: false, expected: tip, identityFailed: false, deferred: [], tipEnvironment } : false;
     }
     const battery = async (dir) => {
         let tipFailed = false;
@@ -1336,7 +1368,7 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
             };
             if (r.pass) {
                 // Q121s: a forgiven pass journals its fingerprints — honest about what was carried, never a silent green.
-                journal.append("tip-verify", undefined, { ...evidence, gate: r.gate, cmd: r.cmd, pass: true, exitCode: r.exitCode, details: r.details, ...(r.reused ? { cached: true } : {}), ...(r.forgiven ? { forgiven: true, fingerprints: r.fingerprints, ...(r.baselineProvenance ? { baselineProvenance: r.baselineProvenance } : {}) } : {}), tip, cmdHash, capacity: measuredCapacity });
+                journal.append("tip-verify", undefined, { ...evidence, gate: r.gate, cmd: r.cmd, pass: true, exitCode: r.exitCode, details: r.details, ...(r.reused ? { cached: true } : {}), ...(r.forgiven ? { forgiven: true, fingerprints: r.fingerprints, ...(r.baselineProvenance ? { baselineProvenance: r.baselineProvenance } : {}) } : {}), tip, cmdHash, capacity: measuredCapacity, tipEnvironment });
             }
             else {
                 journal.append("tip-verify-failed", undefined, {
@@ -1351,6 +1383,7 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
                     tip,
                     cmdHash,
                     capacity: measuredCapacity,
+                    tipEnvironment,
                 });
                 tipFailed = true;
             }
@@ -1368,7 +1401,7 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
         const changed = await checkoutChange(opened.dir, tip, opened.h0);
         if (changed)
             return identityFailure({ started: true, expected: tip, leg: "checkout", details: `verification checkout changed during the battery: ${changed}` });
-        return { failed: tipFailed, expected: tip, identityFailed: false, deferred };
+        return { failed: tipFailed, expected: tip, identityFailed: false, deferred, tipEnvironment };
     }
     finally {
         if (checkout)
@@ -3235,11 +3268,6 @@ export async function runDaemon(repoRoot, opts = {}) {
                     ];
                     return `${identity} — release with ${commands.map((command) => `\`${command}\``).join(" or ")}`;
                 };
-                // Lexing never starts in the middle of a word. Resolution is separate so missing hints
-                // remain visible evidence without becoming executable approval advice.
-                const namedPaths = (text) => [...text.matchAll(/(?:^|[\s`'"])((?:[A-Za-z0-9_@.()[\]-]+\/)+[A-Za-z0-9_@.[\]-]+|[A-Za-z0-9_@-]+(?:\.[A-Za-z0-9_-]+)+)(?=$|[\s`'"),:;.!?])/g)]
-                    .map((match) => match[1].replace(/^\.\//, "").replace(/\.$/, ""))
-                    .filter((path) => !path.split("/").includes(".."));
                 const diffPaths = async (base, wt) => {
                     const out = await shGit(`git diff --name-only -z ${shq(base)}..HEAD`, wt);
                     return new Set(out.code === 0 ? out.stdout.split("\0").filter(Boolean) : []);
@@ -3381,7 +3409,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const worker = journal.read().reverse().find((e) => e.taskId === t.id && e.event === "worker-result");
                     const disposition = classifyRepairDisposition({
                         // OBS-1072 add.2: hints are lexed from the readable excerpt, never from terminal control bytes.
-                        results: results.map((g) => ({ ...g, details: readableExcerpt(g.details) })), files: t.files, inventory: changed,
+                        results: results.map((g) => ({ ...g, details: readableExcerpt(g.details),
+                            // Queue row 235 (D-2134): oracle output has the same readable boundary as gate details.
+                            ...(Array.isArray(g.meta?.oracles) ? { meta: { ...g.meta, oracles: g.meta.oracles.map((oracle) => oracle && typeof oracle === "object" && typeof oracle.output === "string"
+                                        ? { ...oracle, output: readableExcerpt(oracle.output) } : oracle) } } : {}),
+                        })), files: t.files, inventory: changed,
                         refusalSummary: worker?.data.ok === false && typeof worker.data.summary === "string" ? worker.data.summary : undefined,
                     });
                     for (const diagnostic of disposition.diagnostics) {
@@ -3526,7 +3558,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const ref = await preserveWorktree(priorWt, producer);
                         if (ref)
                             journal.append("worktree-preserved", t.id, { ref, ...producerFields(producer) });
-                        return driver.worktree(repoRoot, taskBranch, taskBase);
+                        // Queue row 223 (D-2118): only this typed add race buys retries, with three adds total.
+                        const addWorktree = () => {
+                            return driver.worktree(repoRoot, taskBranch, taskBase);
+                        };
+                        for (let attempt = 1;; attempt++) {
+                            try {
+                                return await addWorktree();
+                            }
+                            catch (error) {
+                                if (!(error instanceof WorktreeAdminRaceError) || attempt >= 3)
+                                    throw error;
+                                journal.append("worktree-add-retry", t.id, { attempt, nextAttempt: attempt + 1, evidence: error.evidence });
+                            }
+                        }
                     };
                     // A dead worker with a clean checkout still needs a durable recovery handle: there may be no
                     // pane left to identify even the commit it was dispatched from. preserveWorktree deliberately
@@ -3883,8 +3928,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 ...(typeof g.meta.producerAttempt === "number" ? { producerAttempt: g.meta.producerAttempt } : {}),
                             } : {}),
                             ...((cfg.executionPolicy || repairSelection) && !g.pass ? { disposition: failureDisposition(g) } : {}),
-                            ...Object.fromEntries(["runnerInfraRerun", "hostStarvedRerun", "recoveryBlocked", "failingFiles", "selectionDecision", "failureEvidence",
-                                "forgivenFingerprints", "freshFingerprints", "baselineProvenance", "judgment", "adjudication", "judgeDisagreement", "interruptions"]
+                            ...Object.fromEntries(["runnerInfraRerun", "judgeIndependent", "hostStarvedRerun", "recoveryBlocked", "failingFiles", "selectionDecision", "failureEvidence",
+                                "forgivenFingerprints", "freshFingerprints", "baselineProvenance", "oracles", "judgment", "adjudication", "judgeDisagreement", "interruptions"]
                                 .filter((key) => g.meta?.[key] !== undefined).map((key) => [key, g.meta[key]])),
                             // OBS-540: preserve terminal-vs-retryable infra exactly. normalizeGateOutcome deliberately
                             // defaults a legacy infra row to retryable, so dropping an explicit false here reverses the
@@ -5310,17 +5355,19 @@ export async function runDaemon(repoRoot, opts = {}) {
                         let cpuFlat;
                         let cpuAccountant;
                         let cpuGapCount = 0;
-                        let unmeasurableNoted = false;
-                        // One line per attempt, whichever way the CPU leg turns out to be unmeasurable. A triad that
+                        const unmeasurableNoted = new Set();
+                        // Queue row 231 (D-2119): one line per reading per attempt, including the connection leg.
+                        // One CPU line per attempt, whichever way that leg turns out to be unmeasurable. A triad that
                         // can never conclude is this feature silently ABSENT — on a host whose `ps` the probe cannot
                         // read, every stall would ride its whole window out again with nothing saying why. Named once
                         // per attempt, not per slice: the condition is structural, and a per-slice line would bury it.
-                        const noteUnmeasurable = (reason) => {
-                            if (unmeasurableNoted)
+                        const noteUnmeasurable = (reason, reading = "cpu") => {
+                            if (unmeasurableNoted.has(reading))
                                 return;
-                            unmeasurableNoted = true;
+                            unmeasurableNoted.add(reading);
                             journal.append("worker-harvest-unmeasurable", t.id, { slot: slot.name, attempt, reason });
                         };
+                        let harvestHeldNoted = false;
                         // The CPU leg needs a marker in the worker's own argv, and every launch path puts this
                         // attempt's dispatch script there EXCEPT interactiveSeed: runInteractiveSeed launches the
                         // TUI directly, by a command the ADAPTER owns (seed.launch(model)) which tickmarkr cannot
@@ -5382,6 +5429,39 @@ export async function runDaemon(repoRoot, opts = {}) {
                             const carried = await commitsAheadOf(taskBase, wt);
                             if (carried.length === 0)
                                 return false; // nothing landed: not this branch's population
+                            if (!interactive) {
+                                // Queue row 231 (D-2119): query afresh only after the other legs hold. lsof ORs selections
+                                // without -a; -g includes connector children in the owned group, not just the CLI root.
+                                // No environment inspection. One async PATH lookup, bounded from invocation like the
+                                // reap census (15 s); SIGKILL also retires a probe that ignores SIGTERM.
+                                const group = readOwnedProcessGroup(groupFile);
+                                const connection = group === undefined ? "unreadable" : await new Promise((resolve) => {
+                                    try {
+                                        execFile("lsof", ["-nP", "-a", "-g", String(group), "-iTCP", "-sTCP:ESTABLISHED", "-Fp"], { encoding: "utf8", timeout: 15_000, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+                                            if (!error && stdout.trim())
+                                                resolve("connected");
+                                            else if (error && error.code === 1 && !stdout && !stderr)
+                                                resolve("none");
+                                            else
+                                                resolve("unreadable");
+                                        });
+                                    }
+                                    catch {
+                                        resolve("unreadable");
+                                    }
+                                });
+                                if (connection === "unreadable") {
+                                    noteUnmeasurable("the worker ESTABLISHED TCP connection reading could not be read", "connection");
+                                    return false;
+                                }
+                                if (connection === "connected") {
+                                    if (!harvestHeldNoted) {
+                                        harvestHeldNoted = true;
+                                        journal.append("worker-harvest-held", t.id, { slot: slot.name, attempt, reason: "established-tcp-connection", processGroup: group });
+                                    }
+                                    return false;
+                                }
+                            }
                             journal.append("worker-harvest", t.id, {
                                 slot: slot.name, attempt, commits: carried.length,
                                 silentMs, cpuMs: leg.cpu.ms, cpuResolutionMs: leg.cpu.resolutionMs,
@@ -5860,13 +5940,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             lastStatus = st;
                                             journal.append("worker-status", t.id, { slot: slot.name, status: st, attempt });
                                         }
-                                        if (st === "blocked" || st === "idle") {
+                                        // Queue row 215 (D-2118 add.1): an unhooked CLI can report unknown at its startup modal.
+                                        // Bound that status to worker-launch's startup window, including time spent reading.
+                                        const withinTrustStartup = () => workerLaunchedAt !== undefined
+                                            && Date.now() - workerLaunchedAt <= workerStartupWindowMs;
+                                        if (st === "blocked" || st === "idle" || (st === "unknown" && withinTrustStartup())) {
                                             // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
                                             // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
                                             if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
                                                 try {
-                                                    const paneText = await workerTransport.read(slot, 80);
-                                                    if (matchesTrustDialog(paneText, adapter.trustDialog)) {
+                                                    const paneText = await (slot.readScreen ? slot.readScreen() : workerTransport.read(slot, 80));
+                                                    if ((st !== "unknown" || withinTrustStartup()) && matchesTrustDialog(paneText, adapter.trustDialog)) {
                                                         trustAnswered = true;
                                                         trustAnsweredSlots.add(slot.id);
                                                         // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
@@ -6092,9 +6176,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         }
                                         // OBS-548: the FOURTH leg, and the one the daemon already measured. The three legs above
                                         // are all channel-side: they say a pane stopped talking. The tree's CPU says whether
-                                        // anything is still WORKING, and the harvest triad forty lines up refuses exactly this
-                                        // conclusion without it — "a worker that is merely thinking still burns CPU and is never
-                                        // concluded here". A live CPU delta is a live worker, by construction; an UNMEASURABLE
+                                        // anything is still WORKING, and the harvest triad forty lines up refuses this
+                                        // conclusion without it. Queue row 231 (D-2119): print-mode harvest additionally checks
+                                        // connections because a remote model turn can have flat CPU. An UNMEASURABLE
                                         // reading keeps the fail-open contract the probe already states (undefined is never
                                         // evidence a worker stopped), so on a host whose `ps` cannot be read the fast-kill stands
                                         // down and the fixed attempt ceiling bounds the hold.
@@ -6281,13 +6365,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 }
                                 await noteLaunched();
                                 // OBS-54: headless workers have the same output-inactivity budget as visible panes.
-                                // v1.76: same monotonic-progress measure as the interactive site; harvest stays raw.
+                                // Queue row 233 (D-2130): print progress is the driver's received-byte count, never a row
+                                // high-water over the bounded tail; a driver reporting no count keeps the row measure.
                                 const stallWindowMs = taskTimeoutMinutes * 60_000;
+                                const hardDeadline = attemptStart + (attemptHardTimeoutMs ?? stallWindowMs * 4);
                                 const initialPane = await workerTransport.read(slot, 500);
                                 startupFailure = startupFailureInWindow(initialPane, workerLaunchedAt);
                                 let everHadOutput = initialPane.length > 0;
                                 const stallProgress = new StallProgressTracker();
-                                stallProgress.observe({ paneText: initialPane, seedSubmitted: true, contextTokens });
+                                stallProgress.observe({ paneText: initialPane, receivedBytes: (await workerTransport.transportState?.(slot))?.bytes, seedSubmitted: true, contextTokens });
                                 let lastProgressAt = Date.now();
                                 finished = false;
                                 // T2 review (material): the exit marker proves the PROCESS EXITED, never that the worker
@@ -6297,10 +6383,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // worker-result-harvested row. The interactive site has always kept them apart (`finished`
                                 // there is the trailer regex; the exit marker only sets exitCode), and the cause taxonomy
                                 // already names this shape "clean-exit-no-trailer" — unreachable in print mode until now.
-                                while (!startupFailure && Date.now() - lastProgressAt < stallWindowMs) {
+                                while (!startupFailure && Date.now() - lastProgressAt < stallWindowMs && Date.now() < hardDeadline) {
                                     fatalStop.signal.throwIfAborted();
                                     executionSignal()?.throwIfAborted();
-                                    const remaining = stallWindowMs - (Date.now() - lastProgressAt);
+                                    const remaining = Math.min(stallWindowMs - (Date.now() - lastProgressAt), hardDeadline - Date.now());
                                     let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                                     const startupLeft = workerLaunchedAt === undefined
                                         ? 0
@@ -6331,11 +6417,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         break;
                                     }
                                     await sampleContext();
-                                    if (stallProgress.observe({ paneText, contextTokens }))
+                                    if (stallProgress.observe({ paneText, receivedBytes: (await workerTransport.transportState?.(slot))?.bytes, contextTokens }))
                                         lastProgressAt = Date.now();
-                                    // T2 (OBS-264): the same liveness triad the interactive loop runs. A headless worker that
-                                    // committed and went quiet is finished work too, and before this it rode the entire
-                                    // window out before anything looked at its commits.
+                                    // Queue row 231 (D-2119): print mode adds a fresh owned-group connection reading to the
+                                    // silence/commits/CPU triad; a quiet remote model turn can hold a connection with flat CPU.
                                     // No nudge hold here, deliberately: print mode has no nudge surface at all (no pane to
                                     // steer, driver.nudge is never consulted on this path), so there is no pending daemon
                                     // action for the triad to preempt — the asymmetry with the interactive call site above is
@@ -6350,7 +6435,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // without one is finished:false with a non-null exitCode — the harvest synthesis then owns
                                 // it when the worktree carries work, and classifyWorkerResultCause names it otherwise.
                                 finished = new RegExp(trailerPattern(nonce)).test(output);
-                                timedOut = !processExited && !finished && Date.now() - lastProgressAt >= stallWindowMs;
+                                timedOut = !processExited && !finished && (Date.now() - lastProgressAt >= stallWindowMs || Date.now() >= hardDeadline);
                             }
                         }
                         finally {
@@ -7101,7 +7186,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // Budget spent means the FRESH LADDER owns this failure — including a review-only one, whose
                         // same-channel fix retry is exactly the round the budget just declared too expensive to repeat.
                         const repairExhausted = repairable && !repair;
-                        if (repair && !capStep) {
+                        const fundedRepair = repair && !capStep;
+                        if (fundedRepair) {
                             journal.append("repair-attempt", t.id, {
                                 repair: repairHistory.length + 1, charge: repairsDrawn + 1, of: MAX_REPAIRS,
                                 gates: failing.map((g) => g.gate),
@@ -7126,8 +7212,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                             });
                             await driver.notify(`tickmarkr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
                         }
+                        // Queue row 224(b) (D-2118): pinned tasks park on the first unfunded owned deterministic red
+                        // at or after the second, so this climb fires at most once. Unpinned tasks climb on exactly
+                        // the second owned deterministic red, even when it funds a repair.
                         const climbCause = repairExhausted ? "repair-exhausted"
-                            : deterministic && ownedGateFailures === 2 ? "gate-fail" : undefined;
+                            : deterministic && (t.routingHints?.pin
+                                ? ownedGateFailures >= 2 && !fundedRepair
+                                : ownedGateFailures === 2) ? "gate-fail" : undefined;
                         if (climbCause) {
                             const climbed = await climb(climbCause, deterministic ?? failing[0], attempt + 1);
                             if (climbed === "parked")
@@ -7240,6 +7331,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 if (fatalStop.signal.aborted)
                                     return;
                                 const cleanupEvidence = cleanupErrors.length ? { cleanupErrors } : {};
+                                if (err instanceof WorktreeAdminRaceError) {
+                                    await park(t, err.message, "infra", null, 0, Date.now(), 0, 0, undefined, 0, "fresh", { evidence: err.evidence, ...cleanupEvidence });
+                                    return;
+                                }
                                 if (err instanceof HostDegradedError) {
                                     await park(t, err.message, "infra", null, 0, Date.now(), 0, 0, undefined, 0, "fresh", { disposition: "host-degraded", ...cleanupEvidence });
                                     return;
@@ -7416,8 +7511,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                             summary.tipProof = { kind: "incomplete" };
                         }
                         else {
-                            appendIdentityFailure(journal, { started: false, branch, ...opened, cmdHash: commandsHash(commands), capacity: resolvedCapacity() });
-                            tipClose = { failed: true, identityFailed: true, deferred: [] };
+                            const capacity = resolvedCapacity();
+                            const tipEnvironment = measureTipEnvironment(repoRoot, capacity);
+                            appendIdentityFailure(journal, { started: false, branch, ...opened, cmdHash: commandsHash(commands), capacity, tipEnvironment });
+                            tipClose = { failed: true, identityFailed: true, deferred: [], tipEnvironment };
                             summary.tipVerify = "failed";
                             summary.tipProof = runEndTipProof(journal.read());
                         }
@@ -7452,8 +7549,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                     if (!tipClose.identityFailed && tipClose.expected !== undefined) {
                         const closing = await checkIntegrationIdentity(repoRoot, branch, tipClose.expected);
                         if (!closing.ok) {
+                            const capacity = resolvedCapacity();
+                            const tipEnvironment = tipStarted ? tipClose.tipEnvironment : measureTipEnvironment(repoRoot, capacity);
                             appendIdentityFailure(journal, { started: tipStarted, branch, expected: tipClose.expected, leg: closing.leg, state: closing.state,
-                                details: identityDetails(closing.leg, closing.state, branch, runId, tipClose.expected), cmdHash: commandsHash(commands), capacity: resolvedCapacity() });
+                                details: identityDetails(closing.leg, closing.state, branch, runId, tipClose.expected), cmdHash: commandsHash(commands), capacity, tipEnvironment });
                             summary.tipVerify = "failed";
                             summary.tipProof = runEndTipProof(journal.read());
                         }

package/dist/run/git.d.ts

@@ -199,6 +199,11 @@ export declare function shGitOk(cmd: string, cwd: string, own?: OwnGitOptions):
 export declare function gitSync(dir: string, args: readonly string[], { env }?: {
     env?: NodeJS.ProcessEnv;
 }): SpawnSyncReturns<string>;
+/** Queue row 223 (D-2118): git could not read a sibling's partially written admin file during add. */
+export declare class WorktreeAdminRaceError extends Error {
+    readonly evidence: string;
+    constructor(evidence: 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

@@ -621,6 +621,41 @@ export function gitSync(dir, args, { env = process.env } = {}) {
         pin?.release();
     }
 }
+// Queue row 223 (D-2118): one process-wide administration queue; recreation and rollback retain
+// their caller's hold, including trust rechecks and branch restoration, without queuing behind it.
+let worktreeAdminTail = Promise.resolve();
+const worktreeAdminHold = new AsyncLocalStorage();
+async function withWorktreeAdmin(operation) {
+    if (worktreeAdminHold.getStore())
+        return operation();
+    const prior = worktreeAdminTail;
+    let release;
+    worktreeAdminTail = new Promise((done) => { release = done; });
+    await prior;
+    try {
+        return await worktreeAdminHold.run(true, operation);
+    }
+    finally {
+        release();
+    }
+}
+/** Queue row 223 (D-2118): git could not read a sibling's partially written admin file during add. */
+export class WorktreeAdminRaceError extends Error {
+    evidence;
+    constructor(evidence) {
+        super(`worktree add encountered a sibling admin read race (queue row 223, D-2118): ${evidence}`);
+        this.evidence = evidence;
+        this.name = "WorktreeAdminRaceError";
+    }
+}
+const siblingAdminReadFailed = (stderr) => {
+    for (const line of stderr.split("\n")) {
+        const read = /^(?:fatal: |error: )?failed to read (?:'([^'\r\n]+)'|"([^"\r\n]+)"|([^:\r\n]+))(?::|$)/.exec(line);
+        if (read && /(?:^|\/)worktrees\/[^/\r\n]+\/(?:commondir|gitdir|HEAD)$/.test(read[1] ?? read[2] ?? read[3]))
+            return true;
+    }
+    return false;
+};
 /**
  * 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`
@@ -633,6 +668,9 @@ export function gitSync(dir, args, { env = process.env } = {}) {
  * back through the trusted common directory derived here once (dropWorktree), even while that commondir stays hostile.
  */
 export async function addDetachedWorktree(cwd, dir, commitish, timeoutMs = DEFAULT_SHELL_TIMEOUT_MS, { logHead = false } = {}) {
+    return withWorktreeAdmin(() => addDetachedWorktreeHeld(cwd, dir, commitish, timeoutMs, logHead));
+}
+async function addDetachedWorktreeHeld(cwd, dir, commitish, timeoutMs, logHead) {
     // 2.8.1 T1 (ANL-023 §7.1): `logHead` writes the new checkout's HEAD reflog whatever the repository's
     // core.logAllRefUpdates says, so a later HEAD move by any command is appended to an established witness.
     const git = logHead ? "git -c core.logAllRefUpdates=always" : "git";
@@ -682,6 +720,9 @@ function rollbackFailed(error, failure) {
  * step bounded by `timeoutMs`; every step is tried, and any that failed is thrown, never swallowed.
  */
 async function dropWorktree(store, { dir, branch }, timeoutMs = DEFAULT_SHELL_TIMEOUT_MS) {
+    return withWorktreeAdmin(() => dropWorktreeHeld(store, { dir, branch }, timeoutMs));
+}
+async function dropWorktreeHeld(store, { dir, branch }, timeoutMs) {
     const failed = await withoutExecutionBudget(async () => {
         const run = async (cmd) => {
             try {
@@ -859,6 +900,9 @@ export function checkoutIncarnation(worktree) {
     }
 }
 export async function createWorktree(repo, branch, baseRef) {
+    return withWorktreeAdmin(() => createWorktreeHeld(repo, branch, baseRef));
+}
+async function createWorktreeHeld(repo, branch, baseRef) {
     branch = await resolveTaskBranch(repo, branch);
     const dir = join(tickmarkrDir(repo), WORKTREES_DIR, sanitize(branch));
     if (existsSync(dir))
@@ -866,7 +910,13 @@ export async function createWorktree(repo, branch, baseRef) {
     // the worktree capability: a branch add, whose symbolic HEAD keeps the ref-store pin (see OwnGitCapability); a raced
     // add is rolled back, its branch restored to the value read here or deleted when it is new
     const prior = (await shGit(`git rev-parse --verify -q ${shq(`refs/heads/${branch}`)}`, repo)).stdout.trim() || undefined;
-    await shGitOk(`git worktree add -B ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo, { createsWorktree: "branch", rollback: { dir, branch: { name: branch, prior } } });
+    const cmd = `git worktree add -B ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`;
+    const added = await shGit(cmd, repo, DEFAULT_SHELL_TIMEOUT_MS, { createsWorktree: "branch", rollback: { dir, branch: { name: branch, prior } } });
+    if (added.code !== 0) {
+        if (siblingAdminReadFailed(added.stderr))
+            throw new WorktreeAdminRaceError(added.stderr.trim());
+        throw new Error(`command failed (${added.code}): ${cmd}\n${added.stderr || added.stdout}`);
+    }
     linkNodeModules(repo, dir);
     return dir;
 }

package/dist/run/journal.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { z } from "zod";
 import { channelKey, shq, TokenUsageSchema } from "../adapters/types.js";
 import { graphDefinitionHash, stateDirName, taskContentDigest, taskDefinitionFingerprint, tickmarkrDir } from "../graph/graph.js";
@@ -2744,7 +2744,16 @@ function dischargeProblem(row, o, events, cwd, memo) {
         return "discharge range does not bind the obligation";
     let artifact;
     try {
-        const bytes = readFileSync(String(d.artifactPath));
+        let artifactPath = String(d.artifactPath);
+        if (!isAbsolute(artifactPath)) {
+            // Queue row 31 / D-2134: resolve within the obligation's own run, with common-root fallback
+            // only when that run is absent locally; legacy absolute paths keep their original meaning.
+            const id = parseRunId(o.runId);
+            const localRun = join(runsDir(cwd), id);
+            const runDir = existsSync(localRun) ? localRun : join(runsDir(dirname(trustedCommonDir(cwd))), id);
+            artifactPath = join(runDir, artifactPath);
+        }
+        const bytes = readFileSync(artifactPath);
         if (createHash("sha256").update(bytes).digest("hex") !== d.artifactSha256)
             return "artifact hash mismatch";
         artifact = JSON.parse(bytes.toString("utf8")) ?? {};