@miraland-labs/conduit-bridge 0.16.141 → 0.16.143

package/README.md

@@ -2,7 +2,7 @@
 
 Local Bridge CLI for [Conduit](https://github.com/miralandlabs/conduit). Connects a computer to one organization, claims work, and drives a local agent.
 
-**Package version:** `0.16.125` — the workspace brief reports `declared_demonstration` so the planner knows whether the repository can show itself (KERNEL.md §51). Earlier (0.16.124) — when a project declares `.conduit/demonstrate`, Bridge runs that bounded command at the delivered head and attaches a stamped `preview` row (KERNEL.md §47). Earlier (0.16.95) — Conduit-fuel lanes bind organization aliases (T144), the Anthropic base URL is the origin (T148), the investigation lane resolves its model (T154); a hosted container image lives under `hosted/` (docs/HOSTED_RUNNER.md). Earlier (0.16.27) — work-package execution budgets reach every agent turn, are bounded by the machine ceiling, and expose their effective source for operations. Local-fuel provider refusals make the affected lane unavailable instead of repeatedly spending attempts; an operator who changes the lane's account or plan can invalidate that observation with `ops quota-clear <driver>`. Bridge discovers bounded repository verification commands, including Make targets `test`, `check`, `verify`, `replay`, `typecheck`, `lint`, and `build`. `ops disconnect` asks before it removes the runner service and clears credentials; pass `--yes` to skip the question. `ops.env` is enrollment/bootstrap defaults only: an explicit workspace does not inherit an old repository, and project switches do not rewrite global project state. `ops enroll` exchanges a single-use token, registers the machine, binds project affinity, provisions fuel keys, brings detected drivers online, and starts the runner in one command. On Linux, `ops install` refuses any effective systemd drop-in. A switch intent remains queued until the target runner heartbeat proves Bound. After every Bridge publish, operators must re-run `ops install` (LaunchAgent pins an absolute `cli.js`).
+**Package version:** `0.16.125` — the workspace brief reports `declared_demonstration` so the planner knows whether the repository can show itself (docs/historical/KERNEL_HISTORY_2026-09.md §51). Earlier (0.16.124) — when a project declares `.conduit/demonstrate`, Bridge runs that bounded command at the delivered head and attaches a stamped `preview` row (docs/historical/KERNEL_HISTORY_2026-09.md §47). Earlier (0.16.95) — Conduit-fuel lanes bind organization aliases (T144), the Anthropic base URL is the origin (T148), the investigation lane resolves its model (T154); a hosted container image lives under `hosted/` (docs/HOSTED_RUNNER.md). Earlier (0.16.27) — work-package execution budgets reach every agent turn, are bounded by the machine ceiling, and expose their effective source for operations. Local-fuel provider refusals make the affected lane unavailable instead of repeatedly spending attempts; an operator who changes the lane's account or plan can invalidate that observation with `ops quota-clear <driver>`. Bridge discovers bounded repository verification commands, including Make targets `test`, `check`, `verify`, `replay`, `typecheck`, `lint`, and `build`. `ops disconnect` asks before it removes the runner service and clears credentials; pass `--yes` to skip the question. `ops.env` is enrollment/bootstrap defaults only: an explicit workspace does not inherit an old repository, and project switches do not rewrite global project state. `ops enroll` exchanges a single-use token, registers the machine, binds project affinity, provisions fuel keys, brings detected drivers online, and starts the runner in one command. On Linux, `ops install` refuses any effective systemd drop-in. A switch intent remains queued until the target runner heartbeat proves Bound. After every Bridge publish, operators must re-run `ops install` (LaunchAgent pins an absolute `cli.js`).
 
 ## Prerequisites
 

package/dist/attempt-worktree.js

@@ -2,9 +2,9 @@
  * F-07 slice 1: one Git worktree per attempt. The install-service source checkout is never the
  * agent cwd; retries must not inherit dirty files from a failed run.
  */
-import { access, appendFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { access, appendFile, mkdir, readFile, rm } from "node:fs/promises";
 import { constants } from "node:fs";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { headCommitOrNull } from "./git.js";
@@ -106,6 +106,16 @@ export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
             maxBuffer: 1_000_000,
         }).catch(() => undefined);
     }
+    // The attempt branch goes with its worktree: left behind, every attempt added one local branch to
+    // the source checkout for ever. Only the branch Bridge created for this path, and only the local
+    // ref: a delivered branch was pushed before the release and lives on in the forge.
+    const attemptId = basename(worktreePath);
+    if (resolve(worktreePath) === resolve(attemptWorktreePath(sourceWorkspace, attemptId))) {
+        await execFileAsync("git", ["-C", sourceWorkspace, "branch", "-D", attemptBranchName(attemptId)], {
+            timeout: 30_000,
+            maxBuffer: 1_000_000,
+        }).catch(() => undefined);
+    }
     return true;
 }
 /**
@@ -126,28 +136,3 @@ export async function proveResumeWorktree(sourceWorkspace, attemptId, worktreePa
         return false;
     }
 }
-/** Hold a crashed attempt tree for local diagnosis; never reused as agent cwd. */
-export async function quarantineAttemptWorktree(sourceWorkspace, worktreePath, attemptId) {
-    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const dest = join(sourceWorkspace, ".conduit", "quarantine", `${attemptId}-${stamp}`);
-    await mkdir(join(sourceWorkspace, ".conduit", "quarantine"), { recursive: true });
-    try {
-        await execFileAsync("git", ["-C", sourceWorkspace, "worktree", "remove", "--force", worktreePath], { timeout: 60_000, maxBuffer: 2_000_000 });
-        return null;
-    }
-    catch {
-        try {
-            await rename(worktreePath, dest);
-            await execFileAsync("git", ["-C", sourceWorkspace, "worktree", "prune"], {
-                timeout: 30_000,
-                maxBuffer: 1_000_000,
-            }).catch(() => undefined);
-            await writeFile(join(dest, ".conduit-quarantine.json"), `${JSON.stringify({ attemptId, at: stamp })}\n`, "utf8");
-            return dest;
-        }
-        catch {
-            await removeAttemptWorktree(sourceWorkspace, worktreePath);
-            return null;
-        }
-    }
-}

package/dist/config.js

@@ -58,8 +58,6 @@ export async function loadConfigIfPresent() {
     // Claims live only in runtime.json; a fresh install has none.
     config.activeAttempts = runtime?.activeAttempts ?? {};
     config.sessions = runtime?.sessions;
-    for (const active of Object.values(config.activeAttempts))
-        active.phase ??= "agent_running";
     if (config.fuelSource !== "local" && config.fuelSource !== "conduit")
         config.fuelSource = "conduit";
     // Clamp to what concurrent slot workers can run (1..BRIDGE_MAX_LEASE_CAPACITY).

package/dist/driver.js

@@ -152,11 +152,6 @@ export function tierForRisk(risk) {
 export function isSafeModelName(value) {
     return /^[A-Za-z0-9][A-Za-z0-9._/-]{0,99}$/.test(value);
 }
-/** Grants → Claude Code tool allow-list (mutate_repo mapping). Privileged grants are never mapped. */
-export function claudeToolsForGrants(grants, verificationCommands = [], capabilities = []) {
-    return projectClaude("mutate_repo", { grants, verificationCommands, capabilities }).allowedTools;
-}
-export const claudeDeniedTools = deniedCommands.map((command) => `Bash(${command}:*)`);
 function resolveRunClass(input) {
     if (input.executionClass)
         return input.executionClass;
@@ -739,7 +734,9 @@ export const claudeCodeDriver = {
             };
         }
         const maxTurns = resolveMaxTurns(input.maxTurns);
-        const args = ["-p", input.prompt, "--output-format", "json", "--max-turns", String(maxTurns)];
+        // The prompt goes on stdin (`claude -p` reads it there when no prompt argument is given): Linux
+        // caps one argument at 128 KiB (MAX_ARG_STRLEN) and an assignment contract exceeds that.
+        const args = ["-p", "--output-format", "json", "--max-turns", String(maxTurns)];
         args.push(...modelArgs(claudeCodeDriver, input.model));
         if (input.resumeSessionId)
             args.push("--resume", input.resumeSessionId);
@@ -747,7 +744,7 @@ export const claudeCodeDriver = {
         args.push("--disallowedTools", projected.disallowedTools.join(","));
         if (projected.acceptEdits)
             args.push("--permission-mode", "acceptEdits");
-        const { code, stdout, stderr } = await execute(driverExecutable(claudeCodeDriver.name, input.executable), args, input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, undefined, input.signal, claudeCodeFuelEnv(fuelSource, input.model));
+        const { code, stdout, stderr } = await execute(driverExecutable(claudeCodeDriver.name, input.executable), args, input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, input.prompt, input.signal, claudeCodeFuelEnv(fuelSource, input.model));
         let message = null;
         try {
             message = JSON.parse(stdout);
@@ -914,21 +911,6 @@ export const codexDriver = {
         return { status: "completed", resultText, sessionId: parsed.sessionId, usage: parsed.usage };
     },
 };
-/**
- * Grants + capabilities → Cursor CLI permissions via ExecutionClass.
- * Current Cursor Agent schema accepts only `permissions.{allow,deny}` (no
- * `version` / `approvalMode`). Outside the allow list is denied without --force.
- *
- * `observe_network` / networked mutate / publish_artifact use `--force` (see
- * cursorRunArgs). Field evidence: allow-listing WebFetch alone still yields
- * "User Rejected" under headless `-p`; `--force` is required for fetch and for
- * publish shell under open class policy. Research-only networked assignments
- * deny Shell(*) and Write(**).
- */
-export function cursorPermissionsForGrants(grants, verificationCommands, capabilities, executionClass) {
-    const { allow, deny } = projectCursor(executionClass, { grants, verificationCommands, capabilities });
-    return { allow, deny };
-}
 /**
  * Cursor CLI arguments. Deliberately no `--mode plan` for read-only assignments: plan mode is not an
  * enforcement boundary (in headless `-p` mode the agent can self-escalate out of it and edit anyway)
@@ -1229,9 +1211,9 @@ export const openCodeDriver = {
         if (!agent) {
             return { status: "failed", resultText: null, sessionId: null, error: "No Bridge-mapped OpenCode agent for active grants; refusing to start agent" };
         }
-        const args = openCodeRunArgs(input, agent);
-        args.push(input.prompt);
-        const { code, stdout, stderr } = await withOpenCodePermissions(input.workspace, () => execute(driverExecutable(openCodeDriver.name, input.executable), args, input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, undefined, input.signal));
+        // The prompt goes on stdin (`opencode run` reads a piped stdin as the message), as it does for
+        // codex: Linux caps one argument at 128 KiB (MAX_ARG_STRLEN).
+        const { code, stdout, stderr } = await withOpenCodePermissions(input.workspace, () => execute(driverExecutable(openCodeDriver.name, input.executable), openCodeRunArgs(input, agent), input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, input.prompt, input.signal));
         const parsed = parseOpenCodeOutput(stdout);
         if (code !== 0 || parsed.isError) {
             return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, signal: agentExitSignal({ exit_code: code, stderr, stdout, model: input.model }), error: boundedTail(stderr || parsed.resultText || `opencode exited with code ${code}`, 20_000) };
@@ -1313,9 +1295,9 @@ export const kiroDriver = {
                 return { status: "failed", resultText: null, sessionId: null, error: "kiro has no login (set KIRO_API_KEY or run `kiro-cli login`)" };
             }
         }
-        const args = kiroChatArgs(input, trusted);
-        args.push(input.prompt);
-        const { code, stdout, stderr } = await execute(executable, args, input.workspace, agentTurnTimeoutMs(input), undefined, "local", undefined, input.signal);
+        // The prompt goes on stdin (`kiro-cli chat` takes a piped stdin as its input), as it does for
+        // codex: Linux caps one argument at 128 KiB (MAX_ARG_STRLEN).
+        const { code, stdout, stderr } = await execute(executable, kiroChatArgs(input, trusted), input.workspace, agentTurnTimeoutMs(input), undefined, "local", input.prompt, input.signal);
         if (code !== 0) {
             return { status: "failed", resultText: stdout || null, sessionId: null, signal: agentExitSignal({ exit_code: code, stderr, stdout, model: input.model }), error: boundedTail(stderr || stdout || `kiro-cli exited with code ${code}`, 20_000) };
         }
@@ -1638,7 +1620,8 @@ export const antigravityDriver = {
 export function piRunArgs(input) {
     const args = ["--mode", "json", "-p", "--no-session", "--tools", input.tools];
     args.push(...modelArgs(piDriver, input.model));
-    args.push(input.prompt);
+    // The prompt goes on stdin (pi reads a piped stdin as its initial message), as it does for codex:
+    // Linux caps one argument at 128 KiB (MAX_ARG_STRLEN).
     return args;
 }
 /**
@@ -1703,7 +1686,7 @@ export const piDriver = {
         if (version.code !== 0 || !(version.stdout || version.stderr).trim()) {
             return { status: "failed", resultText: null, sessionId: null, error: "pi preflight could not verify the installed CLI version" };
         }
-        const { code, stdout, stderr } = await execute(executable, piRunArgs({ prompt: input.prompt, tools: projected.tools, model: input.model }), input.workspace, agentTurnTimeoutMs(input), undefined, "local", undefined, input.signal);
+        const { code, stdout, stderr } = await execute(executable, piRunArgs({ tools: projected.tools, model: input.model }), input.workspace, agentTurnTimeoutMs(input), undefined, "local", input.prompt, input.signal);
         const parsed = parsePiJsonl(stdout);
         if (code !== 0) {
             return {
@@ -1894,12 +1877,14 @@ const MAX_AGENT_OUTPUT = 8 * 1024 * 1024;
 export const STDIO_DRAIN_MS = 2_000;
 /** How long a stopped child may take to die before the run reports what it already has. */
 const CHILD_STOP_GRACE_MS = 20_000;
-export function execute(executable, args, cwd, timeoutMs, fuel, fuelSource = "conduit", stdinText, signal, extraEnv) {
+export function execute(executable, args, cwd, timeoutMs, fuel, fuelSource = "conduit", stdinText, signal, extraEnv, 
+/** The whole environment, for a run that must see less than an agent does (a probe instrument). */
+env) {
     return new Promise((resolve, reject) => {
         const child = spawn(executable, args, {
             cwd,
             stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
-            env: boundedEnvironment(fuel, fuelSource, extraEnv),
+            env: env ?? boundedEnvironment(fuel, fuelSource, extraEnv),
         });
         let stdout = "";
         let stderr = "";
@@ -1991,7 +1976,8 @@ const LOCAL_VENDOR_ENV = [
     "CURSOR_API_KEY", "KIRO_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY",
     "XAI_API_KEY",
 ];
-function boundedEnvironment(fuel, fuelSource = "conduit", extraEnv) {
+/** The stripped process environment an agent CLI runs with, carrying Conduit fuel when given. */
+export function boundedEnvironment(fuel, fuelSource = "conduit", extraEnv) {
     // Proxy and TLS variables stay: fueled agents must reach Conduit's /v1 on
     // machines that only have network access through a proxy.
     const allowed = ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "TERM", "NO_COLOR", "FORCE_COLOR",
@@ -2066,7 +2052,3 @@ export function hasGrokLogin(env = process.env) {
     // `~/.grok` exists after install; auth.json is the `grok login` / cached_token file.
     return Boolean(home && existsSync(join(home, ".grok", "auth.json")));
 }
-/** Exported for tests — builds the stripped process env with optional Conduit fuel. */
-export function agentProcessEnv(fuel, fuelSource = "conduit", extraEnv) {
-    return boundedEnvironment(fuel, fuelSource, extraEnv);
-}

package/dist/drivers.js

@@ -400,15 +400,6 @@ export function setDriverFuel(config, driverId, fuel) {
 export function heartbeatStatusForDrivers(onlineIds) {
     return onlineIds.length > 0 ? "online" : "standby";
 }
-/**
- * Effective capacity advertised on heartbeat: full approved pool when any lane is online;
- * 0 (via standby + no claims) when none are. Caller still sends lease_capacity = approved when online.
- */
-export function advertiseLeaseCapacity(approved, onlineIds) {
-    if (onlineIds.length === 0)
-        return 1; // schema/heartbeat min; status standby prevents matching
-    return approved;
-}
 export function driversHeartbeatReport(config, activeAttempts, processOnlineIds, env = process.env) {
     const processOnline = new Set(processOnlineIds ?? []);
     const busyByDriver = new Map();

package/dist/ensure-demonstration-evidence.js

@@ -1,6 +1,6 @@
 /**
  * When the project declares how it shows itself, Bridge runs that command at the delivered head and
- * attaches what it printed. The agent never authors this entry (KERNEL.md §47, "See it").
+ * attaches what it printed. The agent never authors this entry (docs/historical/KERNEL_HISTORY_2026-09.md §47, "See it").
  *
  * `.conduit/demonstrate` is one bounded command, `#` comments allowed, absent by default. It runs
  * with the same shape check, runner and bound as a verification command, and it is never a gate:

package/dist/ensure-test-evidence.js

@@ -319,8 +319,11 @@ export function boundedFailureDetail(command, stdoutLines, stderrLines, code, ma
 /**
  * The bounded runner every Bridge-run verification uses: the declared command, in the given
  * workspace, with the verification timeout and buffer. A non-zero exit is a result, not a throw.
+ *
+ * A gate the timeout stopped did not exit: `timedOut` says so, and stderr ends with the limit it
+ * reached. Read as exit 1, a gate that hung on the untouched base was a red base on the author.
  */
-export async function runBoundedVerificationCommand(command, workspace) {
+export async function runBoundedVerificationCommand(command, workspace, timeoutMs = VERIFICATION_TIMEOUT_MS) {
     const argv = argvForBoundedCommand(command);
     const bin = argv[0];
     if (!bin)
@@ -328,7 +331,7 @@ export async function runBoundedVerificationCommand(command, workspace) {
     try {
         const { stdout, stderr } = await execFileAsync(bin, argv.slice(1), {
             cwd: workspace,
-            timeout: VERIFICATION_TIMEOUT_MS,
+            timeout: timeoutMs,
             maxBuffer: VERIFICATION_MAX_BUFFER_BYTES,
             env: process.env,
         });
@@ -343,6 +346,14 @@ export async function runBoundedVerificationCommand(command, workspace) {
         // message reaches the `enoent` rule that Holds it on the computer operator.
         if (typeof err.code === "string")
             throw error;
+        if (err.killed === true) {
+            return {
+                stdout: String(err.stdout ?? ""),
+                stderr: `${String(err.stderr ?? "")}\nBridge stopped the gate: it did not exit within ${Math.round(timeoutMs / 1_000)} seconds.`.trimStart(),
+                code: 1,
+                timedOut: true,
+            };
+        }
         const stderr = String(err.stderr || err.message || "verification failed");
         return {
             stdout: String(err.stdout ?? ""),
@@ -456,6 +467,18 @@ export function detectGateRanNothing(command, stdout, stderr, code) {
     }
     return null;
 }
+/**
+ * A delivery report that falls short of the delivery contract while the work itself may be
+ * complete: a required evidence kind is missing, a met criterion cites no evidence, test evidence is
+ * a summary, or the pull request or published artifact is missing. The type, not the sentence, is
+ * what tells the control plane this is a report defect for repair.
+ */
+export class DeliveryReportDefectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DeliveryReportDefectError";
+    }
+}
 /**
  * A declared gate that ran and failed. Carries the command as a field so the verification signal
  * can name the gate without reading it back out of this error's text.
@@ -501,7 +524,7 @@ export async function ensureTestEvidence(input) {
             ...named.commands,
         ])];
     if (commands.length === 0) {
-        throw new Error("Agent report is missing required evidence: test (no bounded verification command available for Bridge to run)");
+        throw new DeliveryReportDefectError("Agent report is missing required evidence: test (no bounded verification command available for Bridge to run)");
     }
     const run = input.runCommand ?? runBoundedVerificationCommand;
     const witnessed = [];

package/dist/execution.js

@@ -11,12 +11,12 @@ import { saveDriverOutcome, saveDriverQuota, tierCandidates } from "./config.js"
 import { DRIVERS, acceptanceCriteriaLines, acceptanceReportSkeleton, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, isSafeModelName, driverExecutable, requireStampedExecutionClass, tierForRisk } from "./driver.js";
 import { assertClassFloor } from "./execution-class.js";
 import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis, clearDriverOutcome, recordDriverTimeout } from "./drivers.js";
-import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
+import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, fetchOrigin, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { buildSovereignExecutionFacts, bootstrapResultForWorkspace, changedExecutionFact, resumeExecutionFacts, workspaceIsClean } from "./execution-facts.js";
-import { agentOutputCause, boundedDetail, bridgeCause, contractScopeConflictFailure, executionFactChangedSignal, verificationRedBaseSignal, verificationScopeConflictSignal } from "./failure-signal.js";
+import { agentOutputCause, boundedDetail, bridgeCause, contractScopeConflictFailure, executionFactChangedSignal, verificationGateTimeoutSignal, verificationRedBaseSignal, verificationScopeConflictSignal } from "./failure-signal.js";
 import { forgeTransportFailure } from "./transport-fault.js";
 import { managedWorkspacePath, switchManagedWorkspace } from "./on-shift-apply.js";
 import { formatResetMinute, parseQuotaResetAt } from "./quota-reset.js";
@@ -28,7 +28,7 @@ import { ensureLandCommit } from "./ensure-land-commit.js";
 import { AGENT_NO_LAND_COMMIT_PREFIX, AgentNoLandCommitError, agentNoLandCommitMessage, requiresLandCommit } from "./land-contract.js";
 import { agentClaimsRepositoryWork, claimsVsGitMismatch, isLandTreeEmpty, reportClaimsRepositoryWork, } from "./land-git-reality.js";
 const execFileAsync = promisify(execFile);
-import { boundedTail, captureVerificationFailure, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationFailedError, VerificationGateRanNothingError } from "./ensure-test-evidence.js";
+import { boundedTail, captureVerificationFailure, DeliveryReportDefectError, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationFailedError, VerificationGateRanNothingError, VERIFICATION_TIMEOUT_MS } from "./ensure-test-evidence.js";
 import { ensureChangeEvidence } from "./ensure-change-evidence.js";
 import { ensureDemonstrationEvidence } from "./ensure-demonstration-evidence.js";
 import { ensureNormativeEvidence } from "./ensure-normative-evidence.js";
@@ -534,7 +534,17 @@ export function buildDiagnosticPrompt(input) {
  * control plane has ended.
  */
 const slotAborts = new Map();
-export async function renewLeases(client, config) {
+/**
+ * The renewal pass in flight. Each running slot and the runner loop all ask for a pass; one pass
+ * covers every attempt, so a caller that arrives while one runs waits for it instead of renewing
+ * the same leases and dropping the same attempts a second time.
+ */
+let renewalPass = null;
+export function renewLeases(client, config) {
+    renewalPass ??= renewEachLease(client, config).finally(() => { renewalPass = null; });
+    return renewalPass;
+}
+async function renewEachLease(client, config) {
     for (const active of Object.values(config.activeAttempts)) {
         if (Date.parse(active.leaseExpiresAt) - Date.now() < 120_000) {
             try {
@@ -633,14 +643,8 @@ function checkpointInstructionPrompt(instructions) {
         agentReportTemplate,
     ].join("\n");
 }
-function resolveAttemptDriver(config, active, fallback) {
-    if (active.driverId && DRIVERS[active.driverId])
-        return DRIVERS[active.driverId];
-    if (fallback)
-        return fallback;
-    // Crash between claim and driverId persist: pick any free online lane so recovery is not stranded.
-    const picked = pickDriverForClaim(config);
-    return picked ? DRIVERS[picked] ?? null : null;
+function resolveAttemptDriver(active, fallback) {
+    return (active.driverId ? DRIVERS[active.driverId] : undefined) ?? fallback ?? null;
 }
 export async function recoverActiveAttempt(client, config, driver, sourceWorkspace, brief, timeoutMs, supervision, taskId) {
     const active = taskId ? config.activeAttempts[taskId] : Object.values(config.activeAttempts)[0];
@@ -660,25 +664,15 @@ export async function recoverActiveAttempt(client, config, driver, sourceWorkspa
             await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
         }
         else if (!diagnosis && response.retain_worktree !== true && worktree) {
-            if (active.terminal?.action === "fail") {
-                await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
-            }
-            else {
-                await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
-            }
+            await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
         }
         return true;
     }
-    const laneDriver = resolveAttemptDriver(config, active, driver);
+    const laneDriver = resolveAttemptDriver(active, driver);
     if (!laneDriver) {
         console.error(`No driver for attempt ${active.attemptId} (driverId=${active.driverId ?? "unset"})`);
         return false;
     }
-    if (!active.driverId) {
-        const assigned = Object.entries(DRIVERS).find(([, d]) => d === laneDriver)?.[0];
-        if (assigned)
-            await client.updateAttempt(active.taskId, { driverId: assigned });
-    }
     if (active.phase === "agent_running") {
         const diagnosis = active.executionKind === "diagnosis";
         const worktreeOwner = diagnosis ? active.sourceAttemptId : active.attemptId;
@@ -706,9 +700,9 @@ export async function recoverActiveAttempt(client, config, driver, sourceWorkspa
             await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
         }
         else if (!diagnosis && response.retain_worktree !== true && worktree) {
-            // Do not quarantine before the terminal response: Conduit may need this exact tree for a
+            // Do not remove before the terminal response: Conduit may need this exact tree for a
             // pinned diagnosis even when Bridge restarted before it could preserve the agent session.
-            await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
+            await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
         }
         return true;
     }
@@ -752,7 +746,7 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
         const active = config.activeAttempts[id];
         const laneDriver = active.phase === "terminal_pending"
             ? fallbackDriver
-            : resolveAttemptDriver(config, active, fallbackDriver);
+            : resolveAttemptDriver(active, fallbackDriver);
         if (!laneDriver && active.phase !== "terminal_pending") {
             console.error(`Slot recovery skipped for ${id}: no driver lane`);
             continue;
@@ -799,7 +793,7 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
             break;
         const taskId = claimed.taskId;
         driverId = claimed.driverId ?? driverId;
-        laneDriver = driverId ? DRIVERS[driverId] ?? laneDriver : laneDriver;
+        laneDriver = fallbackDriver ?? DRIVERS[driverId] ?? laneDriver;
         progressed = true;
         console.log(`Executing ${taskId} via ${laneDriver.name}`);
         // T86: the claim answers with the checkout it proved, which is this assignment's repository.
@@ -945,27 +939,6 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
     });
     return { taskId: assignment.id, driverId: selectedDriverId, workspace: claimWorkspace };
 }
-export function claimedAssignmentDriver(fallback, driverId) {
-    if (!driverId)
-        return fallback;
-    const selected = DRIVERS[driverId];
-    if (!selected)
-        throw new Error(`Claimed assignment selected unavailable driver ${driverId}`);
-    return selected;
-}
-export async function executeNextAssignment(client, config, driver, workspace, brief, timeoutMs, supervision) {
-    if (Object.keys(config.activeAttempts).length)
-        return recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision);
-    const preferredDriverId = Object.entries(DRIVERS).find(([, candidate]) => candidate === driver)?.[0] ?? null;
-    const claimed = await claimNextAssignment(client, config, workspace, brief, preferredDriverId, null, {
-        beforeClaim: supervision?.beforeClaim,
-    });
-    if (!claimed)
-        return false;
-    const selectedDriver = claimedAssignmentDriver(driver, claimed.driverId);
-    await runClaimedAssignment(client, config, selectedDriver, claimed.workspace, brief, claimed.taskId, timeoutMs, supervision);
-    return true;
-}
 /**
  * T90: attempts whose stall report already ended them, by attempt id.
  *
@@ -1342,9 +1315,9 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
         return;
     }
     // T22/T24/T28: the gates run once here, before the first model call. A gate that started but
-    // tested nothing is the earliest fact and refuses first; then a gate already red on the untouched
-    // base; only a green base still runs the scope check, which refuses when a gate wrote outside the
-    // approved change scope.
+    // tested nothing is the earliest fact and refuses first; then a gate that never exited; then a gate
+    // already red on the untouched base; only a green base still runs the scope check, which refuses
+    // when a gate wrote outside the approved change scope.
     if (dryRunsVerification({
         executionKind,
         executionClass,
@@ -1388,6 +1361,25 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             console.error(`Assignment ${taskId} refused before the agent started: ${redactSecrets(detail)}`);
             return;
         }
+        if (dryRun.timedOut) {
+            const { command, stderrTail, stdoutTail } = dryRun.timedOut;
+            const detail = `Verification gate did not finish on the base commit ${worktreeStart}: ${command} (stopped after ${Math.round(VERIFICATION_TIMEOUT_MS / 60_000)} minutes)`;
+            const response = await queueTerminal(client, taskId, {
+                action: "fail",
+                body: {
+                    error: detail,
+                    retryable: false,
+                    signal: verificationGateTimeoutSignal({ command, baseCommit: worktreeStart, stderr: stderrTail, stdout: stdoutTail }),
+                    idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
+                },
+            });
+            // No agent ran and the tree stands at the base commit, so it holds no diagnostic value.
+            if (response.retain_worktree !== true) {
+                await removeAttemptWorktree(workspace, attemptWorkspace).catch(() => undefined);
+            }
+            console.error(`Assignment ${taskId} refused before the agent started: ${redactSecrets(detail)}`);
+            return;
+        }
         if (dryRun.redBase) {
             const { command, exitCode, stderrTail, stdoutTail } = dryRun.redBase;
             const detail = `Verification fails on the base commit ${worktreeStart}: ${command} (exit ${exitCode ?? "unknown"})`;
@@ -2264,11 +2256,16 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                     .then((stat) => stat?.slice(0, 8_000) ?? null)
                     .catch(() => null)
                 : null;
+            // A report that fell short of the delivery contract is named by its type and travels as the
+            // delivery_report signal, so repair routing never reads this message (K3, debt 18 item 3c).
+            const reportDefect = error instanceof DeliveryReportDefectError;
             const classified = verificationFailed
                 ? { retryable: true, error: `Verification failed after the agent run.\n${message}${diffStat ? `\n\nChanged files:\n${diffStat}` : ""}` }
-                // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail
-                // closed (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
-                : classifyFinalizeFailure(message);
+                : reportDefect
+                    ? { retryable: false, error: message }
+                    // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail
+                    // closed (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
+                    : classifyFinalizeFailure(message);
             if (verificationFailed)
                 retainAttemptWorktree = true;
             const response = await queueTerminal(client, taskId, {
@@ -2284,6 +2281,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                             command: error.command,
                             ...(diffStat ? { diff_stat: diffStat } : {}),
                         } } : {}),
+                    ...(reportDefect ? { signal: { phase: "delivery_report", witness: "bridge", kind: "contract" } } : {}),
                     // A rework's own PR may already be open (ensureDeliveryPullRequest ran before this
                     // gate). Carry the URL so the control plane can close it instead of littering.
                     ...(report.pull_request_url ? { pull_request_url: report.pull_request_url } : {}),
@@ -2759,7 +2757,7 @@ export function validateDeliveryReport(report, spec, grants = [], actualPaths, b
             }
         });
         if (!published) {
-            throw new Error("Artifact delivery requires a published HTTP(S) URL and sha256 digest");
+            throw new DeliveryReportDefectError("Artifact delivery requires a published HTTP(S) URL and sha256 digest");
         }
     }
     // Invariant 9: grants bound what an attempt may do. Cursor/plan-mode are soft hints the headless
@@ -2773,7 +2771,7 @@ export function validateDeliveryReport(report, spec, grants = [], actualPaths, b
     if (grants.includes("pr_create")
         && report.head_commit
         && !report.pull_request_url) {
-        throw new Error("Repository changes require a pull_request_url when pr_create is granted");
+        throw new DeliveryReportDefectError("Repository changes require a pull_request_url when pr_create is granted");
     }
     const requiredEvidence = spec.required_evidence ?? [];
     const supplied = new Set(report.evidence.map((item) => item.kind));
@@ -2782,20 +2780,20 @@ export function validateDeliveryReport(report, spec, grants = [], actualPaths, b
         // Name the base Bridge diffed against: an empty path list is a fact about that base, not proof
         // that the agent did no work. Without the base the repair brief can only guess the symptom.
         const since = missing.includes("change") && baseCommit ? ` (no paths changed since ${baseCommit})` : "";
-        throw new Error(`Agent report is missing required evidence: ${missing.join(", ")}${since}`);
+        throw new DeliveryReportDefectError(`Agent report is missing required evidence: ${missing.join(", ")}${since}`);
     }
     const unsupported = report.acceptance_results
         .filter((result) => result.status === "met" && !report.evidence.some((item) => item.acceptance_criteria.includes(result.criterion)))
         .map((result) => result.criterion);
     if (unsupported.length)
-        throw new Error(`Met acceptance criteria require mapped evidence: ${unsupported.join("; ")}`);
+        throw new DeliveryReportDefectError(`Met acceptance criteria require mapped evidence: ${unsupported.join("; ")}`);
     // Plan-time normalizeRequiredEvidence puts "test" on verify packages; reject summary-only details.
     if (requiredEvidence.includes("test")) {
         const thin = report.evidence
             .filter((item) => item.kind === "test")
             .filter((item) => item.details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN);
         if (thin.length) {
-            throw new Error("test evidence must include verbatim command output in details (not a summary)");
+            throw new DeliveryReportDefectError("test evidence must include verbatim command output in details (not a summary)");
         }
     }
 }
@@ -2882,15 +2880,28 @@ export function verificationScopeConflictDetail(paths, changeScope) {
 export async function verificationScopeDryRun(input) {
     const commands = verificationEvidenceCommands(input.verificationCommands, input.declaredVerificationCommands ?? [], input.acceptance ?? null);
     if (!commands.length)
-        return { ranNothing: null, redBase: null, outsideScope: [] };
+        return { ranNothing: null, timedOut: null, redBase: null, outsideScope: [] };
     const run = input.runCommand ?? runBoundedVerificationCommand;
     let ranNothing = null;
+    let timedOut = null;
     let redBase = null;
     for (const command of commands) {
         // A gate that cannot start says nothing about the scope; the next one still can.
         const result = await run(command, input.workspace).catch(() => null);
         if (!result)
             continue;
+        // A gate that never exited says nothing about the base commit: it is not a red base, and it
+        // does not go to the initiative author.
+        if (result.timedOut) {
+            if (!timedOut) {
+                timedOut = {
+                    command,
+                    ...(result.stderr.trim() ? { stderrTail: result.stderr } : {}),
+                    ...(result.stdout.trim() ? { stdoutTail: result.stdout } : {}),
+                };
+            }
+            continue;
+        }
         // Ahead of the exit code: a gate that discovered no test exits 5, and a no-op recipe exits 0
         // with no output. Neither is a red base, so neither goes to the initiative author.
         const reason = detectGateRanNothing(command, result.stdout, result.stderr, result.code)
@@ -2915,7 +2926,7 @@ export async function verificationScopeDryRun(input) {
     const outsideScope = written === null
         ? []
         : written.filter((path) => !input.changeScope.some((scope) => pathMatchesScope(path, scope)));
-    return { ranNothing, redBase, outsideScope };
+    return { ranNothing, timedOut, redBase, outsideScope };
 }
 /** Prompt and failure lines keep a short tail; the investigation brief caps each failure at 1,000. */
 const DELIVERY_VERIFICATION_GATE_TAIL_CHARS = 800;

package/dist/failure-signal.js

@@ -228,9 +228,10 @@ export function contractScopeConflictFailure(detail) {
 function resetClock(resetsAt) {
     return `${resetsAt.slice(0, 16).replace("T", " ")} UTC`;
 }
-/** Signal tails are bounded: one runaway log cannot fill the wire or the card. */
+/** Signal tails are bounded: one runaway log cannot fill the wire or the card. A tail keeps the
+ *  end of the output, because the decisive error is printed last. */
 function bounded2k(text) {
-    return text.length > 2_000 ? `${text.slice(0, 1_999)}…` : text;
+    return text.length > 2_000 ? `…${text.slice(-1_999)}` : text;
 }
 /**
  * Vendor text that names the model as the reason the CLI refused the run. The model name is the one
@@ -398,14 +399,33 @@ export function verificationRedBaseSignal(input) {
         ...(input.stdout?.trim() ? { stdout_tail: bounded2k(input.stdout) } : {}),
     };
 }
+/**
+ * The signal Bridge emits when the verification timeout stops a gate on the base commit, before the
+ * agent starts. The gate never exited, so it says nothing about the base: read as exit 1, a gate
+ * that hung (waiting for input or the network, or on a slow computer) was a red base on the author.
+ */
+export function verificationGateTimeoutSignal(input) {
+    return {
+        phase: "verification",
+        witness: "bridge",
+        kind: "timeout",
+        command: input.command,
+        base_commit: input.baseCommit,
+        exit_code: null,
+        ...(input.stderr?.trim() ? { stderr_tail: bounded2k(input.stderr) } : {}),
+        ...(input.stdout?.trim() ? { stdout_tail: bounded2k(input.stdout) } : {}),
+    };
+}
 /** A fact value as a person reads it on the card; an absent value says so in words. */
 function factValue(value) {
     return value === null ? "none" : value;
 }
-/** The vendor's own reason, kept inside the 2,000-char message bound. */
+/** The vendor's own reason, kept inside the 2,000-char message bound; a stderr tail keeps its end. */
 function quotedVendorText(signal) {
-    const text = signal.vendor_message ?? signal.stderr_tail ?? "";
-    return text.length > 400 ? `${text.slice(0, 399)}…` : text;
+    if (signal.vendor_message)
+        return signal.vendor_message.length > 400 ? `${signal.vendor_message.slice(0, 399)}…` : signal.vendor_message;
+    const tail = signal.stderr_tail ?? "";
+    return tail.length > 400 ? `…${tail.slice(-399)}` : tail;
 }
 /**
  * Classify one typed signal. Null when the signal carries no typed verdict (`kind: "unknown"`):
@@ -418,17 +438,19 @@ function quotedVendorText(signal) {
  * 2. model_unbound → the tier has no other model to retry into: Hold, naming the tier and driver.
  * 3. denied_tool / usage_error → the driver and vendor cannot run this assignment: Hold.
  * 4. a changed pinned execution fact → the computer moved under the run: Hold, then Retry re-pins.
- * 5. a gate that already fails on the untouched base commit → no agent ran and none can repair a
+ * 5. a gate the verification timeout stopped on the base commit → it never exited, so it says
+ *    nothing about the base: Hold, on the computer operator, naming the gate.
+ * 6. a gate that already fails on the untouched base commit → no agent ran and none can repair a
  *    gate broken before it started: Hold, on the initiative author, naming the gate and the base.
- * 6. verification whose gates wrote outside the approved change scope → the work package is the
+ * 7. verification whose gates wrote outside the approved change scope → the work package is the
  *    defect: Hold, on the initiative author, who opens a revision.
- * 7. verification run by Bridge whose gate ran nothing → the gate is misconfigured, not failed:
+ * 8. verification run by Bridge whose gate ran nothing → the gate is misconfigured, not failed:
  *    Hold, on the computer operator, naming the command and the file that declares it. Never a
  *    repair attempt: the delivery pack may be entirely correct.
- * 8. verification run by Bridge, any other cause → the verify class: diagnose and brief a repair.
- * 9. contract, or a delivery_report phase → the delivery contract codes: rework.
- * 10. timeout → the turn reached its execution limit: stop.
- * 11. turn_cap → the run reached the computer's per-attempt turn cap: Hold, on the operator, who
+ * 9. verification run by Bridge, any other cause → the verify class: diagnose and brief a repair.
+ * 10. contract, or a delivery_report phase → the delivery contract codes: rework.
+ * 11. timeout → the turn reached its execution limit: stop.
+ * 12. turn_cap → the run reached the computer's per-attempt turn cap: Hold, on the operator, who
  *     decides whether the work was looping or the cap is too tight. Never a silent retry.
  */
 export function classifyFailureSignal(signal) {
@@ -532,6 +554,21 @@ export function classifyFailureSignal(signal) {
             diagnostic_detail: `${fact.name}: pinned ${factValue(fact.pinned)}, found ${factValue(fact.observed)}`,
         };
     }
+    // Ahead of the red-base and generic verification rules: the gate never exited, so neither the
+    // base commit nor a change is known to be at fault. The generic rule read it as a failed test.
+    if (signal.phase === "verification" && signal.kind === "timeout") {
+        const command = signal.command ?? "the declared gate";
+        const base = signal.base_commit ?? "the base commit";
+        return {
+            code: "verification_gate_timeout",
+            class: "environment",
+            disposition: "hold",
+            responsible_party: "computer_operator",
+            message: `The verification gate \`${command}\` did not finish on the base commit ${base} within Bridge's 10-minute limit, so Bridge stopped it before any change was made.`,
+            next_action: `Run \`${command}\` on this computer and find where it hangs — a test that waits for input or the network, or a computer too slow for the gate — then fix it and Recheck. Conduit does not retry or repair a gate that does not finish.`,
+            diagnostic_detail: [`$ ${command}`, "stopped after 10 minutes", signal.stderr_tail, signal.stdout_tail].filter(Boolean).join("\n"),
+        };
+    }
     // Ahead of the scope and generic verification rules: the base commit itself does not pass the
     // gates, so no agent ran and no agent can repair a gate that was already broken before it
     // started. This is the earlier fact — checked in the dry run before the scope conflict — so it
@@ -614,7 +651,7 @@ export function classifyFailureSignal(signal) {
                 disposition: "rework",
                 responsible_party: "conduit",
                 message: "The delivery report did not satisfy the delivery contract.",
-                next_action: "Bridge's report-only repair turns ran; review the report defect and rework it.",
+                next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
                 diagnostic_detail: signal.vendor_message ?? signal.stderr_tail,
             }
             : {

package/dist/investigation.js

@@ -12,11 +12,11 @@ import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { headCommitOrNull } from "./git.js";
 import { learnDriverFuel, resolveAssignmentModel, changedPathsSince, runDeliveryVerificationGates, discardWorktreeWrites } from "./execution.js";
-import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
+import { DRIVERS, execute, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { diffStatSince } from "./git-witness.js";
 import { switchManagedWorkspace } from "./on-shift-apply.js";
-import { execFile, spawn } from "node:child_process";
+import { execFile } from "node:child_process";
 import { rm, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { join } from "node:path";
@@ -634,34 +634,17 @@ function toStepWitness(witness) {
         instrument: witness.instrument === "delivered" ? "delivered" : "running",
     };
 }
+/**
+ * The delivered instrument runs through the agent runs' own process helper (T90): bounded output,
+ * an answer on the child's exit even when a process it left behind holds the pipes, and a stop
+ * that escalates to SIGKILL. Its environment stays the probe's own, PATH and HOME only.
+ */
 async function execDeliveredProbeRun(argv, stdin, workspace, timeoutMs) {
     const [file, ...args] = argv;
     if (!file)
         throw new Error("delivered probe command is empty");
-    return await new Promise((resolve, reject) => {
-        const child = spawn(file, args, {
-            cwd: workspace,
-            env: probeEnv(),
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        const timer = setTimeout(() => {
-            child.kill("SIGKILL");
-        }, timeoutMs);
-        child.stdout?.on("data", (chunk) => { stdout += String(chunk); });
-        child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
-        child.on("error", (error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? -1, stdout, stderr });
-        });
-        child.stdin?.on("error", () => undefined);
-        child.stdin?.end(stdin);
-    });
+    const result = await execute(file, args, workspace, timeoutMs, undefined, "conduit", stdin, undefined, undefined, probeEnv());
+    return { code: result.code ?? -1, stdout: result.stdout, stderr: result.stderr };
 }
 export async function runDeliveredProbeInstrument(input) {
     const entry = join(input.workspace, PROBE_RUN_ENTRY);
@@ -724,10 +707,6 @@ export const INVESTIGATION_RENEW_INTERVAL_MS = 2 * 60_000;
 export function investigationRunId(investigationId) {
     return `${investigationId}-${crypto.randomUUID().slice(0, 8)}`;
 }
-async function deleteRunBranch(workspace, runId) {
-    await execFileAsync("git", ["-C", workspace, "branch", "-D", `conduit/attempt/${runId}`], { timeout: 30_000, maxBuffer: 1_000_000 })
-        .catch(() => undefined);
-}
 export async function executeNextInvestigation(client, config, workspace, brief, timeoutMs, options = {}) {
     const data = await client.request("/runner/v1/investigations");
     const assignments = z.array(investigationAssignmentSchema).parse(data.investigations ?? []);
@@ -959,7 +938,6 @@ export async function executeNextInvestigation(client, config, workspace, brief,
         if (attemptWorkspace) {
             await removeAttemptWorktree(workspace, attemptWorkspace)
                 .catch((error) => console.error(`Investigation worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
-            await deleteRunBranch(workspace, runId);
         }
     }
     return true;

package/dist/ops.js

@@ -191,14 +191,6 @@ export function resolveInstallDrivers(env, argv, detect = detectInstalledClients
         return [preferred];
     });
 }
-/** Quote args for a copy-pasteable shell/cmd line (paths with spaces). */
-export function shellQuoteArgs(args) {
-    return args.map((arg) => {
-        if (!/[^\w@%+=:,./\\-]/i.test(arg))
-            return arg;
-        return `"${arg.replaceAll('"', '\\"')}"`;
-    }).join(" ");
-}
 /** Ask the operator to approve a step that cannot be undone. Non-interactive shells must pass --yes. */
 async function confirmOps(question) {
     if (!input.isTTY || !output.isTTY) {

package/dist/service.js

@@ -262,7 +262,6 @@ export function runnerServiceWorkspaceWarnings(declaredWorkspace, home = homedir
     }
     return warnings;
 }
-export const WINDOWS_TASK_NAME = "ConduitBridgeRunner";
 /** Quote one argv token for a Windows Task Scheduler /TR command line. */
 export function quoteWindowsTaskArg(value) {
     if (!/[\s&<>|^()"]/.test(value))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.141",
+  "version": "0.16.143",
   "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": {