@miraland-labs/conduit-bridge 0.16.142 → 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,7 +2,7 @@
  * 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 { basename, join, resolve } from "node:path";
 import { execFile } from "node:child_process";
@@ -136,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;
@@ -916,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)
@@ -1996,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",
@@ -2071,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 ?? ""),

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, DeliveryReportDefectError, 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"})`;
@@ -2888,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)
@@ -2921,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

@@ -399,6 +399,23 @@ 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;
@@ -421,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) {
@@ -535,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

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.142",
+  "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": {