@miraland-labs/conduit-bridge 0.16.29 → 0.16.32

package/dist/attempt-worktree.js

@@ -7,6 +7,7 @@ import { constants } from "node:fs";
 import { join, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { headCommitOrNull } from "./git.js";
 const execFileAsync = promisify(execFile);
 export function attemptWorktreePath(sourceWorkspace, attemptId) {
     return join(sourceWorkspace, ".conduit", "attempts", attemptId);
@@ -82,14 +83,18 @@ export async function ensureWorktreeGitIdentity(worktree, sourceWorkspace) {
         await git("config", key, inherited || fallback);
     }
 }
+/** Removes the worktree; answers whether one was there to remove. */
 export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
-    // Settled repair releases are returned on every assignment poll until the local tree is gone.
-    // Make that at-least-once signal cheap and idempotent instead of invoking Git on a missing path.
+    // The control plane names every settled repair on every assignment poll, because it holds no
+    // record of what this computer still has on disk. That is a statement of fact to reconcile
+    // against, not a queue to drain, so the caller asks whether anything actually went -- a release
+    // nobody performed is not an event, and logging one made the same eleven paths scroll past every
+    // fifteen seconds. It also keeps Git off a path that is already gone.
     try {
         await access(worktreePath, constants.F_OK);
     }
     catch {
-        return;
+        return false;
     }
     try {
         await execFileAsync("git", ["-C", sourceWorkspace, "worktree", "remove", "--force", worktreePath], { timeout: 60_000, maxBuffer: 2_000_000 });
@@ -101,6 +106,7 @@ export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
             maxBuffer: 1_000_000,
         }).catch(() => undefined);
     }
+    return true;
 }
 /**
  * F-07 safe resume: prove the interrupted attempt still owns this worktree path.
@@ -114,11 +120,7 @@ export async function proveResumeWorktree(sourceWorkspace, attemptId, worktreePa
         return false;
     try {
         await access(worktreePath, constants.F_OK);
-        const { stdout } = await execFileAsync("git", ["-C", worktreePath, "rev-parse", "HEAD"], {
-            timeout: 15_000,
-            maxBuffer: 1_000_000,
-        });
-        return /^[0-9a-f]{40,64}$/i.test(stdout.trim());
+        return (await headCommitOrNull(worktreePath)) !== null;
     }
     catch {
         return false;

package/dist/brief.js

@@ -1,8 +1,9 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isBoundedVerificationCommand } from "./execution-class.js";
+import { gitOriginUrl, headCommitOrNull } from "./git.js";
 const execFileAsync = promisify(execFile);
 const MANIFESTS = [
     "package.json", "wrangler.jsonc", "wrangler.toml", "tsconfig.json",
@@ -20,14 +21,22 @@ export async function buildWorkspaceBrief(workspace) {
         .map((entry) => entry.name).sort().slice(0, 30);
     const files = new Set(entries.filter((entry) => entry.isFile()).map((entry) => entry.name));
     const manifests = MANIFESTS.filter((name) => files.has(name));
+    const declared = await readDeclaredVerification(workspace);
     return {
-        repository: await gitRemoteUrl(workspace),
-        base_commit: await gitHeadCommit(workspace),
+        repository: await gitOriginUrl(workspace),
+        base_commit: await headCommitOrNull(workspace),
         modules,
         manifests,
         verification: await discoverVerificationCommands(workspace, files),
+        declared_verification: declared,
     };
 }
+/**
+ * Mirror of `src/conductor/repository.ts`. The server fingerprints the initiative URL and the Bridge
+ * fingerprints the workspace remote; dispatch requires the two to be equal, so a divergence stops
+ * matching silently. The Bridge is a published package and cannot import server code, so
+ * `test/matcher.test.ts` ("repository fingerprint agreement") holds the two spellings together.
+ */
 export function normalizeRepositoryUrl(url) {
     let value = url.trim().replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
     const ssh = value.match(/^git@([^:]+):(.+)$/);
@@ -143,61 +152,6 @@ export async function resolveAttemptStartCommit(workspace, requestedBase, claime
         return base;
     return null;
 }
-async function gitRemoteUrl(workspace) {
-    try {
-        const { common } = await gitDirectories(workspace);
-        const config = await readFile(join(common, "config"), "utf8");
-        const remote = config.match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/);
-        return remote?.[1] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-async function gitHeadCommit(workspace) {
-    try {
-        const { worktree, common } = await gitDirectories(workspace);
-        let head = String(await readFile(join(worktree, "HEAD"), "utf8")).trim();
-        // Follow one level of symbolic refs (HEAD → refs/heads/main, or a nested ref file).
-        for (let hop = 0; hop < 3; hop++) {
-            if (/^[0-9a-f]{40,64}$/i.test(head))
-                return head.toLowerCase();
-            const ref = head.match(/^ref:\s*(\S+)$/)?.[1];
-            if (!ref)
-                return null;
-            try {
-                head = String(await readFile(join(common, ref), "utf8")).trim();
-            }
-            catch {
-                const packed = String(await readFile(join(common, "packed-refs"), "utf8"));
-                const line = packed.split("\n").find((entry) => {
-                    const trimmed = entry.trim();
-                    return trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("^") && trimmed.endsWith(` ${ref}`);
-                });
-                const sha = line?.split(/\s+/)[0]?.trim() ?? null;
-                return sha && /^[0-9a-f]{40,64}$/i.test(sha) ? sha.toLowerCase() : null;
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-async function gitDirectories(workspace) {
-    const dotGit = join(workspace, ".git");
-    const info = await stat(dotGit);
-    const pointer = info.isDirectory() ? null : (await readFile(dotGit, "utf8")).trim().match(/^gitdir:\s*(.+)$/)?.[1];
-    if (!info.isDirectory() && !pointer)
-        throw new Error("Invalid Git worktree metadata");
-    const worktree = info.isDirectory() ? dotGit : resolve(workspace, pointer);
-    try {
-        return { worktree, common: resolve(worktree, (await readFile(join(worktree, "commondir"), "utf8")).trim()) };
-    }
-    catch {
-        return { worktree, common: worktree };
-    }
-}
 /** Exported for tests — discovers bounded verification commands from workspace manifests. */
 /**
  * Commands a project declares for itself, in `.conduit/verification` — one per line, `#` comments
@@ -227,12 +181,17 @@ export function parseDeclaredVerification(text) {
     }
     return declared;
 }
-export async function discoverVerificationCommands(workspace, files) {
-    const commands = [];
+export async function readDeclaredVerification(workspace) {
     try {
-        commands.push(...parseDeclaredVerification(await readFile(join(workspace, ".conduit", "verification"), "utf8")));
+        return parseDeclaredVerification(await readFile(join(workspace, ".conduit", "verification"), "utf8"));
     }
-    catch { /* no declaration, or unreadable: discovery below still applies */ }
+    catch {
+        return []; // no declaration, or unreadable: discovery still applies
+    }
+}
+export async function discoverVerificationCommands(workspace, files) {
+    // Declared first: the order is a preference order for every reader that takes one command.
+    const commands = await readDeclaredVerification(workspace);
     if (files.has("package.json")) {
         try {
             const manifest = JSON.parse(await readFile(join(workspace, "package.json"), "utf8"));

package/dist/checkout.js

@@ -11,6 +11,7 @@ import { dirname } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { gitOriginUrl } from "./git.js";
 const execFileAsync = promisify(execFile);
 async function pathExists(path, accessFn) {
     try {
@@ -21,19 +22,6 @@ async function pathExists(path, accessFn) {
         return false;
     }
 }
-async function gitOriginUrl(workspace, exec) {
-    try {
-        const { stdout } = await exec("git", ["-C", workspace, "config", "--get", "remote.origin.url"], {
-            timeout: 15_000,
-            maxBuffer: 1_000_000,
-        });
-        const value = stdout.trim();
-        return value.length > 0 ? value : null;
-    }
-    catch {
-        return null;
-    }
-}
 /** A control-plane repository fingerprint needs a transport before Git can clone it. */
 function cloneRepositoryUrls(repositoryUrl) {
     const value = repositoryUrl.trim();

package/dist/cli.js

@@ -440,7 +440,10 @@ async function driversCommand() {
         for (const lane of laneStatuses(config)) {
             const when = lane.observed_at ? ` observed=${lane.observed_at}` : "";
             const reset = lane.resets_at ? ` resets=${lane.resets_at}` : lane.allowance === "unavailable" ? " resets=unknown" : "";
-            console.log(`  ${lane.id.padEnd(14)} ${lane.state.padEnd(8)} fuel=${lane.fuel}  allowance=${lane.allowance}${when}${reset}  (${lane.label})`);
+            // A degraded provider never refuses, so allowance stays "unknown" while every turn times out.
+            // Printing the count is the only way an operator sees why dispatch keeps avoiding this lane.
+            const slow = lane.timeouts ? `  timeouts=${lane.timeouts} (demoted)` : "";
+            console.log(`  ${lane.id.padEnd(14)} ${lane.state.padEnd(8)} fuel=${lane.fuel}  allowance=${lane.allowance}${when}${reset}${slow}  (${lane.label})`);
         }
         const blocked = laneDispatchBlock(laneStatuses(config));
         console.log(blocked
@@ -609,19 +612,22 @@ async function runner() {
                 progressed = await executeNextInvestigation(client, config, workspace, brief, timeoutMs) || progressed;
             }
             if (workspace && onlineDriverIds(config).length) {
+                // Read the workspace again, then publish it. The last brief stands if the read fails.
+                const publishWorkspaceState = async (options = {}) => {
+                    const currentBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
+                    const preflight = await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined }, options);
+                    const hb = await heartbeat(client, config, workspace, currentBrief, preflight, undefined, bootstrapResult);
+                    return { preflight, hb };
+                };
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: async () => {
-                        const currentBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
-                        const preflight = await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined });
-                        await heartbeat(client, config, workspace, currentBrief, preflight, undefined, bootstrapResult);
+                        await publishWorkspaceState();
                     },
                     beforeClaim: async (driverId) => {
                         // Never let the five-minute heartbeat cache span a CLI upgrade into a certified claim.
                         // Publish the fresh probe first; the Control Plane then remains the authority for the
                         // exact version frozen onto the claim response and event.
-                        const currentBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
-                        const preflight = await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined }, { force: true });
-                        const hb = await heartbeat(client, config, workspace, currentBrief, preflight, undefined, bootstrapResult);
+                        const { preflight, hb } = await publishWorkspaceState({ force: true });
                         if (hb.staleBridge)
                             return false;
                         const lane = preflight.drivers.find((candidate) => candidate.id === driverId);

package/dist/config.js

@@ -262,6 +262,23 @@ export async function saveConfigPrefs(config) {
  * nothing without one.
  */
 export async function saveDriverQuota(driverId, quota) {
+    await updateDriverLane(driverId, (lane) => {
+        if (quota)
+            lane.quota = quota;
+        else
+            delete lane.quota;
+    });
+}
+/** Persist one lane's execution outcome without overwriting operator preferences or quota state. */
+export async function saveDriverOutcome(driverId, outcome) {
+    await updateDriverLane(driverId, (lane) => {
+        if (outcome)
+            lane.outcome = outcome;
+        else
+            delete lane.outcome;
+    });
+}
+async function updateDriverLane(driverId, update) {
     const run = async () => {
         await withConfigLock(async () => {
             let prefs;
@@ -269,15 +286,12 @@ export async function saveDriverQuota(driverId, quota) {
                 prefs = JSON.parse(await readFile(path, "utf8"));
             }
             catch {
-                return; // No prefs on disk yet: nothing to attach a quota to.
+                return; // No prefs on disk yet: nothing to attach lane state to.
             }
             const lane = prefs.drivers?.[driverId];
             if (!lane || typeof lane !== "object")
                 return;
-            if (quota)
-                lane.quota = quota;
-            else
-                delete lane.quota;
+            update(lane);
             await writeJsonAtomic(path, { ...prefs, activeAttempts: {}, sessions: undefined });
         });
     };

package/dist/drivers.js

@@ -55,10 +55,23 @@ export function normalizeDrivers(raw) {
         const state = lane.state === "online" ? "online" : "offline";
         const fuel = lane.fuel === "local" || lane.fuel === "conduit" ? lane.fuel : undefined;
         const quota = normalizeQuota(lane.quota);
-        out[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}) };
+        const outcome = normalizeOutcome(lane.outcome);
+        out[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}), ...(outcome ? { outcome } : {}) };
     }
     return out;
 }
+/** Same rule as quota: a malformed outcome is dropped, never allowed to hold a lane back. */
+function normalizeOutcome(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const value = raw;
+    if (!Number.isFinite(value.consecutive_timeouts) || typeof value.last_timeout_at !== "string")
+        return undefined;
+    if (!Number.isFinite(Date.parse(value.last_timeout_at)))
+        return undefined;
+    const count = Math.max(0, Math.floor(value.consecutive_timeouts));
+    return { consecutive_timeouts: count, last_timeout_at: value.last_timeout_at };
+}
 /** Drop a malformed quota rather than fail the whole config: a bad record must not dark a lane. */
 function normalizeQuota(raw) {
     if (!raw || typeof raw !== "object")
@@ -159,11 +172,14 @@ export function laneStatuses(config, now = Date.now()) {
         const allowance = !local || !quota
             ? "unknown"
             : quota.exhausted ? "unavailable" : "available";
+        const outcome = normalizeDrivers(config.drivers)[lane.id]?.outcome;
         return {
             ...lane,
             allowance,
             observed_at: quota?.observed_at,
             resets_at: quota?.resets_at ?? undefined,
+            ...(laneTimedOutRecently(config, lane.id, now) ? { timeouts: outcome?.consecutive_timeouts } : {}),
+            // Timeouts demote but never make a lane ineligible: see pickDriverForClaim.
             eligible: lane.state === "online" && allowance !== "unavailable",
         };
     });
@@ -178,6 +194,53 @@ export function laneDispatchBlock(statuses) {
         return "every lane is offline";
     return "every online lane has an allowance the provider refused";
 }
+/** Timeouts in a row before a lane stops being preferred. One is noise; two is a pattern. */
+export const TIMEOUT_SUPPRESSION_THRESHOLD = 2;
+/** How long a timeout pattern is believed. Short, because the cause is often the budget, not the lane. */
+export const TIMEOUT_SUPPRESSION_MS = 60 * 60_000;
+/** Record a turn that ended at the execution ceiling. Never touches the quota record. */
+export function recordDriverTimeout(config, driverId, now = Date.now()) {
+    if (!isSupportedDriverId(driverId))
+        return config;
+    const drivers = normalizeDrivers(config.drivers);
+    const lane = drivers[driverId] ?? { state: "offline" };
+    const previous = lane.outcome?.consecutive_timeouts ?? 0;
+    drivers[driverId] = {
+        ...lane,
+        outcome: { consecutive_timeouts: previous + 1, last_timeout_at: new Date(now).toISOString() },
+    };
+    return { ...config, drivers };
+}
+/**
+ * Clear what the last runs said about this lane.
+ *
+ * A run that finished is the strongest evidence there is, and it is worth more than any older claim
+ * — a lane that just worked is not spent and is not slow.
+ */
+export function clearDriverOutcome(config, driverId) {
+    if (!isSupportedDriverId(driverId))
+        return config;
+    const drivers = normalizeDrivers(config.drivers);
+    const lane = drivers[driverId];
+    if (!lane?.outcome)
+        return config;
+    const { outcome: _cleared, ...rest } = lane;
+    drivers[driverId] = rest;
+    return { ...config, drivers };
+}
+/**
+ * Whether this lane's recent timeouts should push it behind others.
+ *
+ * Expires on its own, because a timeout usually means the budget was too small for the work rather
+ * than that the lane is bad, and the next package may be smaller.
+ */
+export function laneTimedOutRecently(config, driverId, now = Date.now()) {
+    const outcome = normalizeDrivers(config.drivers)[driverId]?.outcome;
+    if (!outcome || outcome.consecutive_timeouts < TIMEOUT_SUPPRESSION_THRESHOLD)
+        return false;
+    const seen = Date.parse(outcome.last_timeout_at);
+    return now >= seen && now - seen <= TIMEOUT_SUPPRESSION_MS;
+}
 export function onlineDriverIds(config) {
     const drivers = normalizeDrivers(config.drivers);
     return SUPPORTED_AGENTS.map((agent) => agent.id).filter((id) => drivers[id]?.state === "online");
@@ -290,14 +353,17 @@ export function pickDriverForClaim(config, processOnlineIds, eligible = () => tr
             load.set(active.driverId, (load.get(active.driverId) ?? 0) + 1);
         }
     }
+    // Demote, never exclude. A lane held out of selection can never run the work that would prove it
+    // well again, and suppressing the last candidate would idle the machine over a claim about the
+    // past. Ordering is enough: a healthy lane wins while one exists, and a suppressed lane is still
+    // picked when it is all there is.
+    const rank = (id) => (laneTimedOutRecently(config, id) ? 1 : 0);
     let best = online[0];
-    let bestLoad = load.get(best) ?? 0;
     for (const id of online.slice(1)) {
-        const n = load.get(id) ?? 0;
-        if (n < bestLoad) {
+        const better = rank(id) < rank(best)
+            || (rank(id) === rank(best) && (load.get(id) ?? 0) < (load.get(best) ?? 0));
+        if (better)
             best = id;
-            bestLoad = n;
-        }
     }
     return best;
 }

package/dist/ensure-land-commit.js

@@ -4,18 +4,9 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { commitsAheadOfBase } from "./ensure-pull-request.js";
+import { readHeadCommit } from "./git.js";
 import { AgentNoLandCommitError, filterPathsInScope, requiresLandCommit, } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
-async function workspaceHeadCommit(workspace) {
-    const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
-        timeout: 30_000,
-        maxBuffer: 1_000_000,
-    });
-    const head = stdout.trim();
-    if (!head)
-        throw new Error("Could not read workspace HEAD");
-    return head;
-}
 async function uncommittedPaths(workspace) {
     const { stdout } = await execFileAsync("git", ["-C", workspace, "status", "--porcelain"], {
         timeout: 30_000,
@@ -64,7 +55,7 @@ export async function ensureLandCommit(input) {
     if (!base)
         return { kind: "skipped" };
     const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
-    const readHead = input.readHeadCommit ?? workspaceHeadCommit;
+    const readHead = input.readHeadCommit ?? readHeadCommit;
     const listPending = input.listUncommittedPaths ?? uncommittedPaths;
     const commitPaths = input.commitPaths ?? commitScopedPaths;
     const ahead = await countAhead(input.workspace, base);

package/dist/ensure-pull-request.js

@@ -6,10 +6,10 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { readHeadCommit } from "./git.js";
+import { forgeTransportFailure } from "./transport-fault.js";
 import { agentNoLandCommitMessage } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
-/** Mirror execution.ts FORGE_TRANSPORT_PATTERN — keep local to avoid import cycles. */
-const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
 /**
  * Commits the attempt branch has and the base does not.
  * Returns null when this checkout does not know the base. An unverifiable precondition must not
@@ -103,16 +103,6 @@ export function adoptPullRequestUrlFromEvidence(report, repositoryFingerprint) {
     }
     return report;
 }
-async function workspaceHeadCommit(workspace) {
-    const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
-        timeout: 30_000,
-        maxBuffer: 1_000_000,
-    });
-    const head = stdout.trim().toLowerCase();
-    if (!/^[0-9a-f]{7,64}$/.test(head))
-        throw new Error("Could not determine workspace HEAD commit");
-    return head;
-}
 function execErrorMessage(error) {
     if (!(error instanceof Error))
         return String(error);
@@ -157,7 +147,7 @@ export async function pushOriginHead(workspace, options = {}) {
             catch {
                 // fall through to retry / throw
             }
-            if (attempt < attempts && FORGE_TRANSPORT_PATTERN.test(lastMessage)) {
+            if (attempt < attempts && forgeTransportFailure(lastMessage)) {
                 await sleep(750 * attempt);
                 continue;
             }
@@ -179,7 +169,7 @@ export async function pushOriginHead(workspace, options = {}) {
  * Agent-supplied PR URLs skip creation but still require HEAD identity.
  */
 export async function ensureDeliveryPullRequest(input) {
-    const readHead = input.readHeadCommit ?? workspaceHeadCommit;
+    const readHead = input.readHeadCommit ?? readHeadCommit;
     const push = input.pushOriginHead ?? pushOriginHead;
     const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
     let report = adoptPullRequestUrlFromEvidence(input.report, input.repositoryFingerprint);

package/dist/ensure-test-evidence.js

@@ -5,7 +5,7 @@
  */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { isBoundedVerificationCommand } from "./execution-class.js";
+import { isBoundedVerificationCommand, isRunnableVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const TEST_EVIDENCE_DETAILS_MIN = 32;
 /** Cold `cargo test` in an attempt worktree routinely exceeds two minutes of compile. */
@@ -23,22 +23,53 @@ export function needsTestEvidence(_report, spec, grants) {
  * is not satisfied by a silent `npm run typecheck`.
  */
 export function isPreferentialTestCommand(command) {
-    return /^(npm run test|pnpm test|yarn test|cargo test|go test(?: \.\/\.\.\.)?|make test|python -m pytest|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command.trim());
+    return /^(npm run test|pnpm test|yarn test|cargo test|go test(?: \.\/\.\.\.)?|make test|python3? -m (?:pytest|unittest)(?: [\w./=:-]+)*|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command.trim());
 }
 export function pickVerificationCommand(commands) {
     const bounded = commands
         .map((command) => command.trim())
-        .filter((command) => command && isBoundedVerificationCommand(command));
+        .filter((command) => command && isRunnableVerificationCommand(command));
     return bounded.find(isPreferentialTestCommand) ?? bounded[0] ?? null;
 }
 /** Prefer one project-defined aggregate; otherwise witness every distinct bounded command. */
 export function verificationEvidenceCommands(commands) {
     const bounded = [...new Set(commands
             .map((command) => command.trim())
-            .filter((command) => command && isBoundedVerificationCommand(command)))];
+            .filter((command) => command && isRunnableVerificationCommand(command)))];
     const aggregate = bounded.find((command) => /^(?:npm run|pnpm|yarn) verify$|^make check$/.test(command));
     return aggregate ? [aggregate] : bounded;
 }
+/**
+ * Bounded verification commands named inside free text. Mirror of the control plane's
+ * `verificationCommandsMentioned` in src/conductor/verification-capability.ts — Bridge cannot import
+ * server code, and test/planner-capability.test.ts pins the two together.
+ */
+export function verificationCommandsMentioned(text) {
+    const pattern = /(?:^|[\s("'`])((?:npm run [A-Za-z0-9][A-Za-z0-9._:-]*|pnpm [A-Za-z0-9][A-Za-z0-9._:-]*|yarn [A-Za-z0-9][A-Za-z0-9._:-]*|cargo (?:test|check)|go test(?: \.\/\.\.\.)?|make [A-Za-z0-9][A-Za-z0-9._-]*|python3? -m [A-Za-z0-9_][\w.]*(?: [\w./=:-]*[./=-][\w./=:-]*)*|pytest(?: [\w./=-]+)?|python3? [\w./-]+\.py(?: [\w./=:-]*[./=-][\w./=:-]*)*|\.\/gradlew test))(?=$|[\s"'`),.;:])/g;
+    return [...new Set([...text.slice(0, 20_000).matchAll(pattern)].map((match) => match[1]).filter(isBoundedVerificationCommand))];
+}
+/**
+ * Does a discovered or declared command authorize this one? The agent receives `Bash(<command>:*)`,
+ * so a command authorizes itself with arguments. Mirror of the control plane's
+ * `verificationCommandIsAuthorized`.
+ */
+export function verificationCommandIsAuthorized(command, discovered) {
+    return discovered.some((offered) => command === offered || command.startsWith(`${offered} `));
+}
+/**
+ * The commands the acceptance criteria name, when the workspace authorizes them.
+ *
+ * A criterion that says `python3 tools/mutate.py --mutants …/mutants.json reports every mutant killed`
+ * names its own witness. Witnessing only the aggregate gate left that command agent-attested, the
+ * reviewer could not treat the criterion as supported, and a delivery whose code was correct still
+ * landed in Needs you instead of Ready. A named command runs only when a discovered or declared
+ * command is its prefix: the criterion cannot widen the shell the grant already bounds.
+ */
+export function acceptanceVerificationCommands(acceptance, discovered) {
+    const authorized = discovered.map((command) => command.trim()).filter(Boolean);
+    return verificationCommandsMentioned(acceptance.join("\n"))
+        .filter((command) => isRunnableVerificationCommand(command) && verificationCommandIsAuthorized(command, authorized));
+}
 function argvForBoundedCommand(command) {
     return command.trim().split(/\s+/);
 }
@@ -62,13 +93,21 @@ function argvForBoundedCommand(command) {
 export function diagnosisVerificationCommands(commands) {
     const bounded = commands
         .map((command) => command.trim())
-        .filter((command) => command && isBoundedVerificationCommand(command));
+        .filter((command) => command && isRunnableVerificationCommand(command));
     const nonTest = bounded.filter((command) => !isPreferentialTestCommand(command));
     const tests = bounded.filter((command) => isPreferentialTestCommand(command));
     return [...nonTest, ...tests];
 }
 export async function captureVerificationFailure(input) {
-    const commands = diagnosisVerificationCommands(input.verificationCommands);
+    // A declared prefix such as `python3 tools/mutate.py` is authority, not a gate: run bare it only
+    // prints usage and exits non-zero, which would be reported as the failure. When a criterion names
+    // the full command, that command is the gate and the bare prefix is not run.
+    const named = acceptanceVerificationCommands(input.acceptance ?? [], input.verificationCommands);
+    const commands = [...new Set([
+            ...diagnosisVerificationCommands(input.verificationCommands)
+                .filter((command) => !named.some((full) => full !== command && full.startsWith(`${command} `))),
+            ...named,
+        ])];
     if (commands.length === 0)
         return null;
     const run = input.runCommand ?? defaultRunCommand;
@@ -236,7 +275,7 @@ function verificationCommandNames(command) {
         names.add(script);
     return names;
 }
-export function criteriaForTestEvidence(report, command) {
+export function criteriaForTestEvidence(report, command, acceptance = []) {
     const testEvidence = report.evidence.filter((item) => item.kind === "test");
     const commandNames = command ? verificationCommandNames(command) : null;
     const sources = commandNames
@@ -252,6 +291,20 @@ export function criteriaForTestEvidence(report, command) {
                 mapped.add(criterion);
         }
     }
+    // A criterion that names the command verbatim is proved by that command's witness, whether or
+    // not the agent remembered to map it. Exact command text, followed by nothing that could extend
+    // it: `make check` must not claim a criterion about `make checkout`.
+    if (command) {
+        const exact = command.trim();
+        for (const criterion of acceptance) {
+            const at = criterion.indexOf(exact);
+            if (at < 0)
+                continue;
+            const next = criterion.charAt(at + exact.length);
+            if (next === "" || !/[\w./=:-]/.test(next))
+                mapped.add(criterion);
+        }
+    }
     return [...mapped];
 }
 /**
@@ -261,7 +314,13 @@ export function criteriaForTestEvidence(report, command) {
 export async function ensureTestEvidence(input) {
     if (!needsTestEvidence(input.report, input.spec, input.grants))
         return input.report;
-    const commands = verificationEvidenceCommands(input.verificationCommands);
+    const acceptance = input.spec.acceptance ?? [];
+    // The project's gate first, then every bounded command the criteria name that the workspace
+    // authorizes. Each is witnessed on its own, so the reviewer sees the criterion's own proof.
+    const commands = [...new Set([
+            ...verificationEvidenceCommands(input.verificationCommands),
+            ...acceptanceVerificationCommands(acceptance, input.verificationCommands),
+        ])];
     if (commands.length === 0) {
         throw new Error("Agent report is missing required evidence: test (no bounded verification command available for Bridge to run)");
     }
@@ -307,7 +366,7 @@ export async function ensureTestEvidence(input) {
             kind: "test",
             name: command,
             details,
-            acceptance_criteria: criteriaForTestEvidence(input.report, command),
+            acceptance_criteria: criteriaForTestEvidence(input.report, command, acceptance),
             witness: "bridge",
         });
     }

package/dist/execution-class.js

@@ -10,7 +10,7 @@ export function isBoundedVerificationCommand(command) {
     // project from naming its own gate, which is what forced four attempts to die on a command they
     // could not run. The boundary that matters is the SHAPE: one tool, one identifier, no shell
     // metacharacters, so nothing can be smuggled in through the name.
-    return /^(npm run [A-Za-z0-9][A-Za-z0-9._:-]*|pnpm [A-Za-z0-9][A-Za-z0-9._:-]*|yarn [A-Za-z0-9][A-Za-z0-9._:-]*|cargo (test|check)|go test(?: \.\/\.\.\.)?|make [A-Za-z0-9][A-Za-z0-9._-]*|python -m pytest|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command);
+    return /^(npm run [A-Za-z0-9][A-Za-z0-9._:-]*|pnpm [A-Za-z0-9][A-Za-z0-9._:-]*|yarn [A-Za-z0-9][A-Za-z0-9._:-]*|cargo (test|check)|go test(?: \.\/\.\.\.)?|make [A-Za-z0-9][A-Za-z0-9._-]*|python3? -m [A-Za-z0-9_][\w.]*(?: [\w./=:-]+)*|pytest(?: [\w./=-]+)?|python3? [\w./-]+\.py(?: [\w./=:-]+)*|\.\/gradlew test)$/.test(command);
 }
 /** Shell commands each grant authorizes — mapped per driver so they cannot drift. */
 export const branchCreateCommands = [
@@ -25,6 +25,31 @@ export const deniedCommands = [
 ];
 /** Land commands denied for publish_artifact / observe* (delivery gate still enforces). */
 export const landCommands = ["git commit", "git push", "gh pr create"];
+/** Script and target names that publish, whatever tool runs them. */
+const DENIED_ACTION_PATTERN = /^(?:npm run|pnpm|yarn|make)\s+[\w.:-]*\b(?:deploy|publish|release|promote)\b/i;
+/**
+ * A denied action, read the way permission is granted.
+ *
+ * `Bash(git push:*)` authorizes `git push` and its arguments, so a denial must cover the arguments
+ * too. Equality covered only the exact spelling: `pnpm deploy:prod` and `make deploy` were never on
+ * the list, and a project names its own gates now, so the spelling reaching a driver is the
+ * project's. The check therefore reads the action.
+ */
+export function isDeniedCommand(command) {
+    const text = command.trim();
+    return deniedCommands.some((denied) => text === denied || text.startsWith(`${denied} `))
+        || DENIED_ACTION_PATTERN.test(text);
+}
+/**
+ * A command a `test_run` grant may run: bounded in shape, and not a denied action.
+ *
+ * Every driver projection asks this one question. Only the prompt used to remove denied commands, so
+ * `Bash(npm run deploy:*)` reached the agent while the prompt beside it said that command was
+ * forbidden.
+ */
+export function isRunnableVerificationCommand(command) {
+    return isBoundedVerificationCommand(command) && !isDeniedCommand(command);
+}
 export const EXECUTION_CLASSES = [
     "observe",
     "observe_network",
@@ -82,7 +107,7 @@ export function executionClassPromptRules(input) {
     const rules = [];
     const grantShell = [
         ...(grants.includes("test_run")
-            ? verificationCommands.filter((command) => isBoundedVerificationCommand(command) && !deniedCommands.includes(command))
+            ? verificationCommands.filter(isRunnableVerificationCommand)
             : []),
         ...(grants.includes("branch_create") ? branchCreateCommands : []),
         ...(grants.includes("pr_create") ? prCreateCommands : []),
@@ -146,7 +171,7 @@ export function projectCursor(executionClass, input) {
         allow.push("WebFetch(*)");
     if (executionClass === "mutate_repo" || executionClass === "verify") {
         if (grants.includes("test_run")) {
-            allow.push(...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Shell(${command})`));
+            allow.push(...verificationCommands.filter(isRunnableVerificationCommand).map((command) => `Shell(${command})`));
         }
         if (executionClass === "mutate_repo" && !input.diagnosis) {
             if (grants.includes("branch_create"))
@@ -182,7 +207,7 @@ export function projectClaude(executionClass, input) {
         return {
             allowedTools: [
                 "Read", "Glob", "Grep",
-                ...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Bash(${command}:*)`),
+                ...verificationCommands.filter(isRunnableVerificationCommand).map((command) => `Bash(${command}:*)`),
                 ...fetchTools,
             ],
             disallowedTools,
@@ -200,7 +225,7 @@ export function projectClaude(executionClass, input) {
         return {
             allowedTools: [
                 "Read",
-                ...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Bash(${command}:*)`),
+                ...verificationCommands.filter(isRunnableVerificationCommand).map((command) => `Bash(${command}:*)`),
                 ...fetchTools,
             ],
             disallowedTools,
@@ -214,7 +239,7 @@ export function projectClaude(executionClass, input) {
     if (grants.includes("repo_write"))
         tools.push("Edit", "Write");
     if (grants.includes("test_run")) {
-        tools.push(...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Bash(${command}:*)`));
+        tools.push(...verificationCommands.filter(isRunnableVerificationCommand).map((command) => `Bash(${command}:*)`));
     }
     if (grants.includes("branch_create"))
         tools.push(...branchCreateCommands.map((command) => `Bash(${command}:*)`));
@@ -272,12 +297,12 @@ export function projectGrok(executionClass, input) {
         return { sandbox: "read-only", allow, deny, disableWebSearch: !fetch, disallowedTools };
     }
     if (input.diagnosis) {
-        allow.push("Read(*)", "Grep(*)", ...verificationCommands.filter(isBoundedVerificationCommand).map(grokBash));
+        allow.push("Read(*)", "Grep(*)", ...verificationCommands.filter(isRunnableVerificationCommand).map(grokBash));
         deny.push("Edit(*)", "Write(*)");
         return { sandbox: "read-only", allow, deny, disableWebSearch: !fetch, disallowedTools };
     }
     if (executionClass === "verify") {
-        allow.push("Read(*)", "Grep(*)", ...verificationCommands.filter(isBoundedVerificationCommand).map(grokBash));
+        allow.push("Read(*)", "Grep(*)", ...verificationCommands.filter(isRunnableVerificationCommand).map(grokBash));
         deny.push("Edit(*)", "Write(*)");
         return { sandbox: "workspace", allow, deny, disableWebSearch: !fetch, disallowedTools };
     }
@@ -290,7 +315,7 @@ export function projectGrok(executionClass, input) {
     if (grants.includes("repo_write"))
         allow.push("Edit(*)", "Write(*)");
     if (grants.includes("test_run")) {
-        allow.push(...verificationCommands.filter(isBoundedVerificationCommand).map(grokBash));
+        allow.push(...verificationCommands.filter(isRunnableVerificationCommand).map(grokBash));
     }
     if (grants.includes("branch_create"))
         allow.push(...branchCreateCommands.map(grokBash));

package/dist/execution-facts.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { commitOrNull } from "./git.js";
 const execFileAsync = promisify(execFile);
 export const EXECUTION_CLASSES = ["observe", "observe_network", "publish_artifact", "verify", "mutate_repo"];
 export const BOOTSTRAP_RESULTS = ["not_applicable", "not_run", "installed", "failed"];
@@ -91,22 +92,6 @@ export async function workspaceIsClean(workspace) {
         return false;
     }
 }
-/** Read only the bounded HEAD identity retained when an attempt terminates. */
-export async function finalCommitForWorkspace(workspace) {
-    try {
-        const result = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
-            timeout: 15_000,
-            windowsHide: true,
-        });
-        return commitOrNull(result.stdout.trim());
-    }
-    catch {
-        return null;
-    }
-}
-function commitOrNull(value) {
-    return value && /^[0-9a-f]{40,64}$/i.test(value) ? value.toLowerCase() : null;
-}
 /** Build one self-contained heartbeat/attempt snapshot from existing Bridge observations. */
 export async function buildSovereignExecutionFacts(input) {
     const repository = input.brief?.repository?.trim();

package/dist/execution.js

@@ -3,15 +3,17 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { resolveAgentTimeout } from "./execution-budget.js";
 import { ConduitRequestError } from "./client.js";
-import { redactSecrets, saveDriverQuota } from "./config.js";
+import { redactSecrets, saveDriverOutcome, saveDriverQuota } from "./config.js";
 import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, requireStampedExecutionClass, tierForRisk } from "./driver.js";
 import { assertClassFloor } from "./execution-class.js";
-import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis } from "./drivers.js";
+import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis, clearDriverOutcome, recordDriverTimeout } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
-import { buildSovereignExecutionFacts, bootstrapResultForWorkspace, finalCommitForWorkspace, workspaceIsClean } from "./execution-facts.js";
+import { buildSovereignExecutionFacts, bootstrapResultForWorkspace, workspaceIsClean } from "./execution-facts.js";
+import { forgeTransportFailure } from "./transport-fault.js";
+import { headCommitOrNull } from "./git.js";
 import { BRIDGE_PROTOCOL_VERSION } from "./preflight.js";
 import { bridgeVersion } from "./version.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
@@ -63,15 +65,6 @@ function changesRequestedFeedback(summary) {
         return null;
     }
 }
-/**
- * A network fault reaching the code host. Mirrors FORGE_TRANSPORT_PATTERN in the control plane's
- * failures.ts — Bridge cannot import from there, so test/failure-classification.test.ts pins the two
- * together rather than trusting them to stay in step.
- */
-export const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
-export function forgeTransportFailure(message) {
-    return FORGE_TRANSPORT_PATTERN.test(message);
-}
 /**
  * A vendor refusing a local-fuel run because the operator's subscription window is spent.
  *
@@ -231,14 +224,36 @@ export function classifyFinalizeFailure(message) {
  * leave the lane eligible.
  */
 export async function learnDriverFuel(config, driverId, fuelSource, result) {
-    const drivers = observeDriverFuel(config, driverId, fuelSource, result).drivers;
+    // Fuel is what the vendor said; outcome is what the run did. Both are learned here so every path
+    // that already reports a result learns both, and no new call site can forget one of them.
+    let next = observeDriverFuel(config, driverId, fuelSource, result);
+    next = observeDriverOutcome(next, driverId, result);
+    const drivers = next.drivers;
     if (JSON.stringify(drivers ?? {}) === JSON.stringify(config.drivers ?? {}))
         return;
     config.drivers = drivers;
     // Only this lane's quota reaches disk. Writing the whole snapshot would carry the rest of a config
     // that may be minutes stale back over the operator's newer choices — see saveDriverQuota.
     // A fuel record is worth less than the run it came from: never let a disk fault fail the attempt.
-    await saveDriverQuota(driverId, drivers?.[driverId]?.quota).catch(() => undefined);
+    await Promise.all([
+        saveDriverQuota(driverId, drivers?.[driverId]?.quota),
+        saveDriverOutcome(driverId, drivers?.[driverId]?.outcome),
+    ]).catch(() => undefined);
+}
+/**
+ * Learn from what the run did, not from what a vendor said about it.
+ *
+ * A provider that degrades instead of refusing — a spent Cursor subscription still answering from a
+ * slow free tier — produces no refusal to learn from, so the quota record stays empty and the lane
+ * looks healthy while every turn runs to the ceiling. The timeout itself is the evidence.
+ *
+ * Recorded separately from quota on purpose. A timeout means the budget was too small or the lane is
+ * degraded; a refusal means the allowance is spent. They call for different operator actions.
+ */
+export function observeDriverOutcome(config, driverId, result) {
+    if (result.status !== "failed")
+        return clearDriverOutcome(config, driverId);
+    return agentTurnTimedOut(result.error ?? "") ? recordDriverTimeout(config, driverId) : config;
 }
 export function observeDriverFuel(config, driverId, fuelSource, result, now = Date.now()) {
     if (fuelSource !== "local")
@@ -680,7 +695,8 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
     for (const attemptId of releasedWorktrees) {
         const worktree = attemptWorktreePath(workspace, attemptId);
         await removeAttemptWorktree(workspace, worktree)
-            .then(() => console.log(`Released settled diagnostic worktree ${worktree}`))
+            .then((released) => { if (released)
+            console.log(`Released settled diagnostic worktree ${worktree}`); })
             .catch((error) => console.error(`Diagnostic worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
     }
     const assignments = z.array(assignmentSchema).parse(data.assignments ?? []);
@@ -1219,6 +1235,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 ? await captureVerificationFailure({
                     workspace: attemptWorkspace,
                     verificationCommands: attemptBrief?.verification ?? [],
+                    acceptance: spec.acceptance ?? [],
                 })
                 : null;
             const message = verificationDetail
@@ -1395,7 +1412,9 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                     }
                     catch (repairError) {
                         const message = repairError instanceof Error ? repairError.message : "Delivery report repair failed";
-                        await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair failed: ${message}`, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                        const detail = `Delivery report repair failed: ${message}`;
+                        const retryable = retryableAgentFailure(message);
+                        await queueTerminal(client, taskId, { action: "fail", body: { error: detail, retryable, failure: retryable ? undefined : deliveryReportRepairFailure(detail), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
                         console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
                         return;
                     }
@@ -1407,7 +1426,8 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                     }
                     if (repaired.status === "failed") {
                         const message = repaired.error ?? "Delivery report repair failed";
-                        await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                        const retryable = retryableAgentFailure(message);
+                        await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable, failure: retryable ? undefined : deliveryReportRepairFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
                         console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
                         return;
                     }
@@ -1429,15 +1449,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                                 body: {
                                     error: detail,
                                     retryable: false,
-                                    failure: {
-                                        code: "delivery_report_invalid",
-                                        class: "contract",
-                                        disposition: "rework",
-                                        responsible_party: "conduit",
-                                        message: "Conduit could not prepare a valid delivery report from the completed agent run.",
-                                        next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
-                                        diagnostic_detail: detail,
-                                    },
+                                    failure: deliveryReportRepairFailure(detail),
                                     idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}`,
                                 },
                             });
@@ -2071,11 +2083,29 @@ function retainDiagnosticWorktree(response) {
     // receive that decision, so fail safe by retaining the only copy of the failed code.
     return response.retain_worktree === true || response.status === "invalid_lease";
 }
+/**
+ * The envelope for a delivery report the Bridge could not repair.
+ *
+ * The implementation finished; only the response envelope is unusable. The control plane must be
+ * able to tell that from the code alone -- it used to read the failure text, and prose is not an
+ * authority. A retryable fault is not this: it gets another attempt rather than repair guidance.
+ */
+function deliveryReportRepairFailure(detail) {
+    return {
+        code: "delivery_report_invalid",
+        class: "contract",
+        disposition: "rework",
+        responsible_party: "conduit",
+        message: "Conduit could not prepare a valid delivery report from the completed agent run.",
+        next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
+        diagnostic_detail: detail,
+    };
+}
 async function queueTerminal(client, taskId, terminal) {
     const active = client.attempt(taskId);
     let executionFacts = active.executionFacts;
     if (executionFacts && executionFacts.final_commit === null && active.worktreePath) {
-        const finalCommit = await finalCommitForWorkspace(active.worktreePath);
+        const finalCommit = await headCommitOrNull(active.worktreePath);
         if (finalCommit) {
             executionFacts = { ...executionFacts, final_commit: finalCommit };
             await client.updateAttempt(taskId, { executionFacts });

package/dist/git.js

@@ -0,0 +1,48 @@
+/**
+ * Every read of Git identity in a workspace — HEAD and the origin URL.
+ * One shape of commit identity, so the control plane never receives two spellings
+ * of the same object name from two callers.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** A full object name, lowercased, or null when the text is not one. */
+export function commitOrNull(value) {
+    const text = value?.trim() ?? "";
+    return /^[0-9a-f]{40,64}$/i.test(text) ? text.toLowerCase() : null;
+}
+/** The workspace HEAD, or null when the directory is not a readable repository. */
+export async function headCommitOrNull(workspace) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
+            timeout: 30_000,
+            maxBuffer: 1_000_000,
+            windowsHide: true,
+        });
+        return commitOrNull(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** The workspace HEAD, where a missing HEAD must end the step instead of being reported as absent. */
+export async function readHeadCommit(workspace) {
+    const head = await headCommitOrNull(workspace);
+    if (!head)
+        throw new Error("Could not determine workspace HEAD commit");
+    return head;
+}
+/** The configured origin, or null when the workspace has no origin remote. */
+export async function gitOriginUrl(workspace, exec = execFileAsync) {
+    try {
+        const { stdout } = await exec("git", ["-C", workspace, "config", "--get", "remote.origin.url"], {
+            timeout: 15_000,
+            maxBuffer: 1_000_000,
+        });
+        const value = stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/investigation.js

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { boundedTail } from "./ensure-test-evidence.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
+import { headCommitOrNull } from "./git.js";
 import { redactSecrets } from "./config.js";
 import { learnDriverFuel } from "./execution.js";
 import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
@@ -93,9 +94,11 @@ export function parseInvestigationBrief(text) {
  */
 async function workspaceFingerprint(workspace) {
     try {
-        const head = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], { timeout: 30_000 });
+        const head = await headCommitOrNull(workspace);
+        if (!head)
+            return null;
         const dirty = await execFileAsync("git", ["-C", workspace, "status", "--porcelain"], { timeout: 30_000, maxBuffer: 8_000_000 });
-        return `${head.stdout.trim()}\n${dirty.stdout.trim()}`;
+        return `${head}\n${dirty.stdout.trim()}`;
     }
     catch {
         return null;

package/dist/normative-refs.js

@@ -11,6 +11,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { z } from "zod";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { headCommitOrNull } from "./git.js";
 const execFileAsync = promisify(execFile);
 export const normativeRefSchema = z.object({
     label: z.string().trim().min(1).max(120),
@@ -68,18 +69,6 @@ async function pathExists(path) {
         return false;
     }
 }
-async function readPinnedRevision(repoDir) {
-    try {
-        const { stdout } = await execFileAsync("git", ["-C", repoDir, "rev-parse", "HEAD"], {
-            timeout: 30_000,
-            maxBuffer: 256_000,
-        });
-        return stdout.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
 async function gitNoPrompt(args, timeout, maxBuffer) {
     await execFileAsync("git", args, { timeout, maxBuffer, env: GIT_NO_PROMPT });
 }
@@ -127,7 +116,7 @@ async function ensureRepoCache(sourceWorkspace, ref) {
             // Keep the last successful cache when origin is unreachable (offline tests, private host already rejected).
         }
     }
-    const revision = (await readPinnedRevision(dir)) ?? wantedRevision;
+    const revision = (await headCommitOrNull(dir)) ?? wantedRevision;
     await writeFile(marker, `${revision}\n`, "utf8");
     return { dir, revision };
 }

package/dist/transport-fault.js

@@ -0,0 +1,12 @@
+/**
+ * A network fault reaching the code host. Mirrors FORGE_TRANSPORT_PATTERN in the control plane's
+ * failures.ts — Bridge cannot import from there, so test/failure-classification.test.ts pins the two
+ * together rather than trusting them to stay in step.
+ *
+ * It lives in its own module because both execution.ts and ensure-pull-request.ts read it, and
+ * execution.ts imports ensure-pull-request.ts.
+ */
+export const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
+export function forgeTransportFailure(message) {
+    return FORGE_TRANSPORT_PATTERN.test(message);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.29",
+  "version": "0.16.32",
   "description": "Conduit Bridge CLI \u2014 join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity / Grok Build agents for a Conduit organization",
   "type": "module",
   "bin": {