@miraland-labs/conduit-bridge 0.11.2 → 0.11.4

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.11.0` — **ExecutionClass inversion:** the control plane stamps `execution_class` on the assignment; Bridge launches from that stamp (fail closed if missing), asserts the full class floor after ceilings, and projects permissions locally (“Bridge wins” on tools). Ordinary grants are derived server-side as classMax ∩ project ceiling; landing is package `lands`, not a class axiom. Workspace briefs discover verification commands for Node, Make, Cargo, Go, pytest, and Gradle. Control-plane `instruction` is **additive** evidence/class prose; Bridge always appends local RULES (shell allow-list, verbatim paste, criterion mapping, hard-denied). Prompt is data; permissions stay local — residual risk if the control plane is compromised (sharpest for `observe_network`). Artifact digests still normalize bare 64-hex to `sha256:<hex>`. Experimental Pi lane remains; `observe_network` is refused on Pi. Heartbeat protocol 2, worktrees, ops helpers, multi-driver lanes, and slots **1–4** unchanged. Protocol 1 heartbeats remain compatible for presence but cannot receive work.
+**Package version:** `0.11.4` — finalize transport flakes stay **retryable**; stamped **ExecutionClass** is required (fail closed if missing). Heartbeat requires **protocol 2 + preflight** (protocol 1 rejected). Bring lanes online with `drivers online`, then `runner --workspace` or `install-service` (no `--agent` process override). Prefs commands (`fuel`, `drivers online|offline`) do not heartbeat a fake not-ready preflight over a live runner. In-flight claims prefer `runtime.json`; a one-time migrate still adopts legacy `config.json` claims when runtime is absent. Ordinary grants derive server-side as classMax ∩ project ceiling; landing is package `lands`.
 
 ## Prerequisites
 

package/dist/cli.js

@@ -18,7 +18,7 @@ import { ensureCheckout } from "./checkout.js";
 import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
 import { OPS_VERBS, runOps } from "./ops.js";
-import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight } from "./preflight.js";
+import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, unavailableWorkspacePreflight } from "./preflight.js";
 const [command] = process.argv.slice(2);
 /** Read our own package version so every runner start logs exactly which build is live. */
 function bridgeVersion() {
@@ -35,7 +35,7 @@ const BRIDGE_NPX = "npx @miraland-labs/conduit-bridge";
 function bridgeUsage(...args) {
     return `${BRIDGE_NPX} ${args.join(" ")}`;
 }
-/** Single source for the --agent placeholder so CLI help never drifts from DRIVERS. */
+/** Single source for the driver-id placeholder so CLI help never drifts from DRIVERS. */
 const AGENT_PLACEHOLDER = `<${Object.keys(DRIVERS).join("|")}>`;
 function parseFuelSource(value) {
     if (value === undefined)
@@ -231,7 +231,7 @@ async function finishConnection(baseUrl, data, fuelSource) {
     const client = new ConduitClient(config);
     let heartbeatOk = true;
     try {
-        await heartbeat(client, config, null);
+        await heartbeat(client, config, null, unavailableWorkspacePreflight({ config }));
     }
     catch {
         heartbeatOk = false;
@@ -254,7 +254,7 @@ async function finishConnection(baseUrl, data, fuelSource) {
     console.log("Heartbeats report capabilities for diagnostics only; matching uses the Connect confirmation. Detected clients never receive grants automatically.");
     console.log(`MCP setup: {"mcpServers":{"conduit":{"command":"npx","args":["-y","@miraland-labs/conduit-bridge","mcp"]}}}`);
     console.log(`Bring a lane online: ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}`);
-    console.log(`Execute work: ${bridgeUsage("runner", "--workspace", "<repo>")} (or ${bridgeUsage("runner", "--agent", AGENT_PLACEHOLDER, "--workspace", "<repo>")})`);
+    console.log(`Execute work: ${bridgeUsage("runner", "--workspace", "<repo>")}`);
     console.log(`Keep on shift (macOS/Linux): ${bridgeUsage("install-service", "--workspace", "<repo>")}`);
     console.log(`Flip machine fuel later: ${bridgeUsage("fuel", "local|conduit")} (per-lane override: ${bridgeUsage("drivers", "fuel", "<id>", "local|conduit")})`);
     console.log("Windows: keep the runner terminal open — install-service is macOS/Linux only.");
@@ -281,24 +281,15 @@ function openUrl(url) {
 async function installService() {
     let config = await loadConfig();
     const { values } = parseArgs({ args: process.argv.slice(3), options: {
-            agent: { type: "string" }, workspace: { type: "string" }, interval: { type: "string" }, "agent-timeout-minutes": { type: "string" },
+            workspace: { type: "string" }, interval: { type: "string" }, "agent-timeout-minutes": { type: "string" },
             "ensure-checkout": { type: "string" },
         } });
     if (!values.workspace) {
-        throw new Error(`Usage: ${bridgeUsage("install-service", "--workspace", "<repository-path>", `[--agent ${AGENT_PLACEHOLDER}]`, "[--ensure-checkout <repository-url>]")} (workspace required; uses online driver lanes)`);
+        throw new Error(`Usage: ${bridgeUsage("install-service", "--workspace", "<repository-path>", "[--ensure-checkout <repository-url>]")} (workspace required; uses online driver lanes)`);
     }
     config = (await seedDriversFromDetection(config)).config;
-    if (values.agent) {
-        if (!DRIVERS[values.agent]) {
-            throw new Error(`Unknown agent driver: ${values.agent}. Available: ${Object.keys(DRIVERS).join(", ")}`);
-        }
-        config = seedDriverLanes(config, [values.agent]).config;
-        config = setDriversOnline(config, [values.agent], true);
-        await saveConfigPrefs(config);
-        console.log(`Brought ${values.agent} online for this computer (shared capacity ${config.leaseCapacity}).`);
-    }
-    else if (!onlineDriverIds(config).length) {
-        throw new Error(`No online driver lanes. Run \`${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}\` first, or pass --agent to bring one online.`);
+    if (!onlineDriverIds(config).length) {
+        throw new Error(`No online driver lanes. Run \`${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}\` first.`);
     }
     const workspace = resolve(values.workspace);
     if (values["ensure-checkout"]) {
@@ -307,7 +298,6 @@ async function installService() {
             ? `Cloned ${values["ensure-checkout"]} into ${workspace}`
             : `Workspace already matches ${values["ensure-checkout"]}`);
     }
-    // Supervisor service: no baked --agent; honors config drivers online set.
     const result = await installRunnerService({
         workspace,
         interval: values.interval,
@@ -380,9 +370,8 @@ async function fuelCommand() {
     const config = await loadConfig();
     config.fuelSource = mode;
     await saveConfigPrefs(config);
-    const client = new ConduitClient(config);
-    await heartbeat(client, config, null);
-    console.log(`Machine fuel source set to ${mode === "local" ? "local subscription" : "Conduit pump"} and reported on heartbeat.`);
+    // Do not heartbeat here: a workspace-less preflight would overwrite a live runner's ready report.
+    console.log(`Machine fuel source set to ${mode === "local" ? "local subscription" : "Conduit pump"}. The runner reports it on the next heartbeat.`);
 }
 async function driversCommand() {
     const sub = process.argv[3];
@@ -416,8 +405,7 @@ async function driversCommand() {
         config = seedDriverLanes(config, ids).config;
         config = setDriversOnline(config, ids, sub === "online");
         await saveConfigPrefs(config);
-        const client = new ConduitClient(config);
-        await heartbeat(client, config, null).catch(() => undefined);
+        // Prefs only — a not-ready preflight here would clear a live runner's dispatch readiness.
         console.log(`${sub === "online" ? "Online" : "Offline"}: ${ids.join(", ")}`);
         console.log(`Now online: ${onlineDriverIds(config).join(", ") || "(none)"}`);
         return;
@@ -438,7 +426,7 @@ async function driversCommand() {
 }
 async function runner() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: {
-            agent: { type: "string" }, workspace: { type: "string" }, interval: { type: "string" }, once: { type: "boolean" },
+            workspace: { type: "string" }, interval: { type: "string" }, once: { type: "boolean" },
             "agent-timeout-minutes": { type: "string" }, fuel: { type: "string" }, "ensure-checkout": { type: "string" },
         } });
     let config = await loadConfig();
@@ -450,16 +438,6 @@ async function runner() {
     config = (await seedDriversFromDetection(config)).config;
     await saveConfigPrefs(config);
     const client = new ConduitClient(config);
-    let processDriver = null;
-    let processOnlineIds = null;
-    if (values.agent) {
-        processDriver = DRIVERS[values.agent] ?? null;
-        if (!processDriver)
-            throw new Error(`Unknown agent driver: ${values.agent}. Available: ${Object.keys(DRIVERS).join(", ")}`);
-        if (!values.workspace)
-            throw new Error("--workspace <repository-path> is required with --agent");
-        processOnlineIds = [values.agent];
-    }
     if (values["ensure-checkout"] && !values.workspace) {
         throw new Error("--ensure-checkout requires --workspace <repository-path>");
     }
@@ -473,14 +451,14 @@ async function runner() {
     const brief = workspace ? await buildWorkspaceBrief(workspace) : null;
     const intervalMs = values.interval ? Math.max(5_000, Number(values.interval)) : 15_000;
     const timeoutMs = values["agent-timeout-minutes"] ? Number(values["agent-timeout-minutes"]) * 60_000 : undefined;
-    const canExecute = Boolean(workspace) && (Boolean(processDriver) || onlineDriverIds(config).length > 0);
+    const canExecute = Boolean(workspace) && onlineDriverIds(config).length > 0;
     if (!workspace) {
         console.warn(`WARNING: heartbeat only — pass --workspace <repo>. Lanes: ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}`);
     }
     else if (!canExecute) {
-        console.warn(`WARNING: no online driver lanes — ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)} (or pass --agent)`);
+        console.warn(`WARNING: no online driver lanes — ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}`);
     }
-    const onlineLabel = (processOnlineIds?.join(", ") || onlineDriverIds(config).join(", ")) || "(none)";
+    const onlineLabel = onlineDriverIds(config).join(", ") || "(none)";
     console.log(`Conduit runner (bridge v${bridgeVersion()}) connected to ${config.baseUrl}${workspace ? ` — workspace ${workspace}` : " — heartbeat only"} (lanes: ${onlineLabel}; machine fuel: ${config.fuelSource === "local" ? "local" : "conduit"}; slots: ${config.leaseCapacity})`);
     const running = new Map();
     for (;;) {
@@ -492,18 +470,20 @@ async function runner() {
             config.fuelSource = latest.fuelSource;
             config.leaseCapacity = latest.leaseCapacity;
             const currentBrief = workspace ? await buildWorkspaceBrief(workspace).catch(() => brief) : null;
-            const preflight = workspace ? await cachedBridgePreflight({ config, workspace, processOnlineIds, brief: currentBrief ?? undefined }) : undefined;
-            await heartbeat(client, config, currentBrief, processOnlineIds, preflight);
+            const preflight = workspace
+                ? await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined })
+                : unavailableWorkspacePreflight({ config });
+            await heartbeat(client, config, currentBrief, preflight);
             await renewLeases(client, config);
-            if (workspace && (processDriver || onlineDriverIds(config).length)) {
+            if (workspace && onlineDriverIds(config).length) {
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: async () => {
                         const currentBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
-                        const preflight = await cachedBridgePreflight({ config, workspace, processOnlineIds, brief: currentBrief ?? undefined });
-                        await heartbeat(client, config, currentBrief, processOnlineIds, preflight);
+                        const preflight = await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined });
+                        await heartbeat(client, config, currentBrief, preflight);
                     },
                     heartbeatIntervalMs: intervalMs,
-                }, running, { driver: processDriver, processOnlineIds });
+                }, running, {});
             }
         }
         catch (error) {
@@ -517,9 +497,8 @@ async function runner() {
         await new Promise((resolveSleep) => setTimeout(resolveSleep, intervalMs));
     }
 }
-async function heartbeat(client, config, brief, processOnlineIds, preflight) {
-    // Process-level `--agent` override must count as online even when saved lanes are offline.
-    const online = processOnlineIds?.length ? processOnlineIds : onlineDriverIds(config);
+async function heartbeat(client, config, brief, preflight) {
+    const online = onlineDriverIds(config);
     const status = heartbeatStatusForDrivers(online);
     await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
             status,
@@ -528,8 +507,8 @@ async function heartbeat(client, config, brief, processOnlineIds, preflight) {
             fuel_source: config.fuelSource === "local" ? "local" : "conduit",
             bridge_version: bridgeVersion(),
             bridge_protocol: BRIDGE_PROTOCOL_VERSION,
-            drivers: driversHeartbeatReport(config, config.activeAttempts, processOnlineIds),
-            ...(preflight ? { preflight } : {}),
+            drivers: driversHeartbeatReport(config, config.activeAttempts),
+            preflight,
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
 }

package/dist/config.js

@@ -23,6 +23,22 @@ const runtimePath = join(directory, "runtime.json");
 const lockPath = join(directory, "config.lock");
 const pendingPath = join(directory, "pending-connect.json");
 const installationPath = join(directory, "installation.json");
+/**
+ * Prefer runtime.json; when absent, adopt legacy activeAttempts/sessions still on config.json
+ * so one Bridge upgrade does not strand in-flight claims.
+ */
+export function adoptLegacyRuntimeClaims(input) {
+    if (input.runtime) {
+        return {
+            activeAttempts: input.runtime.activeAttempts ?? {},
+            sessions: input.runtime.sessions,
+        };
+    }
+    return {
+        activeAttempts: input.legacyAttempts,
+        sessions: input.legacySessions,
+    };
+}
 export async function loadConfig() {
     const config = await loadConfigIfPresent();
     if (!config)
@@ -49,9 +65,13 @@ export async function loadConfigIfPresent() {
         }
     }
     const runtime = await loadRuntime();
-    // Prefer dedicated runtime file; fall back to legacy fields still present in config.json.
-    config.activeAttempts = runtime?.activeAttempts ?? config.activeAttempts ?? {};
-    config.sessions = runtime?.sessions ?? config.sessions;
+    const adopted = adoptLegacyRuntimeClaims({
+        runtime,
+        legacyAttempts: config.activeAttempts && typeof config.activeAttempts === "object" ? config.activeAttempts : {},
+        legacySessions: config.sessions && typeof config.sessions === "object" ? config.sessions : undefined,
+    });
+    config.activeAttempts = adopted.activeAttempts;
+    config.sessions = adopted.sessions;
     for (const active of Object.values(config.activeAttempts))
         active.phase ??= "agent_running";
     if (config.fuelSource !== "local" && config.fuelSource !== "conduit")
@@ -165,10 +185,12 @@ export async function saveConfig(config, options = {}) {
                 let legacySessions;
                 try {
                     const legacy = JSON.parse(await readFile(path, "utf8"));
-                    if (legacy.activeAttempts && typeof legacy.activeAttempts === "object")
+                    if (legacy.activeAttempts && typeof legacy.activeAttempts === "object") {
                         legacyAttempts = legacy.activeAttempts;
-                    if (legacy.sessions && typeof legacy.sessions === "object")
+                    }
+                    if (legacy.sessions && typeof legacy.sessions === "object") {
                         legacySessions = legacy.sessions;
+                    }
                 }
                 catch { /* no prior config */ }
                 if (Object.keys(legacyAttempts).length || legacySessions) {

package/dist/driver.js

@@ -3,8 +3,8 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
-import { deniedCommands, executionClassPromptRules, parsePiJsonl, projectClaude, projectCoarseMode, projectCodex, projectCursor, projectKiroTools, projectPi, requireStampedExecutionClass, resolveExecutionClass, } from "./execution-class.js";
-export { branchCreateCommands, deniedCommands, isBoundedVerificationCommand, prCreateCommands, requireStampedExecutionClass, resolveExecutionClass, } from "./execution-class.js";
+import { deniedCommands, executionClassPromptRules, parsePiJsonl, projectClaude, projectCoarseMode, projectCodex, projectCursor, projectKiroTools, projectPi, requireStampedExecutionClass, } from "./execution-class.js";
+export { branchCreateCommands, deniedCommands, isBoundedVerificationCommand, prCreateCommands, requireStampedExecutionClass, } from "./execution-class.js";
 function deliveryLanguageRule(language) {
     if (language === "zh") {
         return "- Write every human-facing delivery packet string (outcome, changes, verification, assumptions, risks, limitations, criterion text) in Chinese (Simplified). Keep JSON keys and enum token values in English.";
@@ -424,10 +424,8 @@ export const codexDriver = {
  * publish shell under open class policy. Research-only networked assignments
  * deny Shell(*) and Write(**).
  */
-export function cursorPermissionsForGrants(grants, verificationCommands = [], capabilities = [], deliverable = "repository", workRole, executionClass) {
-    const cls = executionClass
-        ?? resolveExecutionClass({ grants, capabilities, deliverable, workRole });
-    const { allow, deny } = projectCursor(cls, { grants, verificationCommands, capabilities });
+export function cursorPermissionsForGrants(grants, verificationCommands, capabilities, executionClass) {
+    const { allow, deny } = projectCursor(executionClass, { grants, verificationCommands, capabilities });
     return { allow, deny };
 }
 /**

package/dist/drivers.js

@@ -146,7 +146,7 @@ export function driversHeartbeatReport(config, activeAttempts, processOnlineIds)
 }
 /**
  * Pick an online driver for a new claim: least loaded among online (shared machine pool).
- * `processOnlineIds` overrides config when runner was started with --agent.
+ * `processOnlineIds` overrides config online lanes (tests / harness).
  */
 export function pickDriverForClaim(config, processOnlineIds) {
     const online = (processOnlineIds?.length ? processOnlineIds : onlineDriverIds(config))

package/dist/execution-class.js

@@ -27,31 +27,6 @@ export const EXECUTION_CLASSES = [
     "verify",
     "mutate_repo",
 ];
-/**
- * Migrator / test helper only. Launch must use the control-plane stamped class
- * via `requireStampedExecutionClass` — do not re-derive as source of truth.
- */
-export function resolveExecutionClass(input) {
-    const grants = input.grants;
-    const capabilities = input.capabilities ?? [];
-    const deliverable = input.deliverable ?? "repository";
-    const workRole = input.workRole ?? null;
-    const hasWrite = grants.includes("repo_write");
-    const hasLand = grants.includes("branch_create") || grants.includes("pr_create");
-    const hasTest = grants.includes("test_run");
-    const hasRead = grants.includes("repo_read");
-    const external = capabilities.includes("external_network");
-    if (deliverable === "artifact" && workRole !== "research" && hasWrite)
-        return "publish_artifact";
-    if (external && !hasWrite && !hasLand && !hasTest)
-        return "observe_network";
-    // verify before observe: repo_read+test_run is the usual verify shape and must keep shell.
-    if (hasTest && !hasWrite && !hasLand)
-        return "verify";
-    if (!hasWrite && !hasLand && !hasTest && (hasRead || workRole === "research"))
-        return "observe";
-    return "mutate_repo";
-}
 const STAMPED_CLASSES = new Set(EXECUTION_CLASSES);
 /** Fail closed when the assignment has no stamped class (upgrade Bridge / redeploy CP). */
 export function requireStampedExecutionClass(stamped) {
@@ -89,9 +64,7 @@ export function assertClassFloor(executionClass, ordinaryGrants) {
  * with `external_network` was therefore told to fetch by a prompt no driver could honour. One
  * predicate, read by all of them, is what keeps that from recurring for the next class added.
  *
- * `observe_network` implies the capability by construction (`resolveExecutionClass` only returns it
- * when `external_network` is present); it stays in the test so a spec that loses its capability list
- * in transit still fails toward the class it was stamped with.
+ * `observe_network` implies the capability by construction.
  */
 export function allowsExternalFetch(executionClass, capabilities = []) {
     return executionClass === "observe_network" || capabilities.includes("external_network");

package/dist/execution.js

@@ -22,6 +22,34 @@ 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);
+}
+/** Environment faults that must Hold — mirror CP ENVIRONMENT_FAILURES message patterns. */
+const FINALIZE_ENVIRONMENT_PATTERN = /base[_ ]not[_ ]ancestor|required base commit is not available|source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace|workspace[_ ]head[_ ]changed|workspace[_ ]repository|workspace[_ ]unavailable|driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required|no[_ ]online[_ ]driver|bridge[_ ]preflight|stale bridge|bridge version/i;
+/** Delivery-report / grant / evidence contract defects (non-retryable rework). */
+const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_write grant|pull_request_url|Artifact delivery requires|outside the approved scope|head commit|test evidence must include|Met acceptance criteria|Agent report|Agent reported|Delivery report/i;
+/**
+ * Classify throws from ensureDeliveryPullRequest + validateDeliveryReport.
+ * Unknown non-contract faults must not be laundered as execution_contract_failed.
+ */
+export function classifyFinalizeFailure(message) {
+    if (forgeTransportFailure(message))
+        return { retryable: true, error: message };
+    if (FINALIZE_ENVIRONMENT_PATTERN.test(message))
+        return { retryable: false, error: message };
+    if (FINALIZE_CONTRACT_PATTERN.test(message))
+        return { retryable: false, error: message };
+    // Unknown finalize faults fail closed once — retrying burns the attempt budget (Invariant 22).
+    // Distinct from execution_contract_failed so owners see a Bridge fault, not a contract lie.
+    return { retryable: false, error: `Bridge finalize interrupted: ${message}` };
+}
 /** Failures that require an operator/configuration change must never burn the remaining attempts. */
 export function retryableAgentFailure(message) {
     // `cannot enforce` is a driver projection refusing a class it structurally cannot bound (Pi and
@@ -188,7 +216,6 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
         let laneDriver = null;
         let driverId = null;
         if (fallbackDriver) {
-            // Legacy `--agent` / tests: one fixed driver for every new claim.
             laneDriver = fallbackDriver;
             driverId = processOnlineIds?.[0]
                 ?? Object.entries(DRIVERS).find(([, d]) => d === fallbackDriver)?.[0]
@@ -521,10 +548,18 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            // Contract/tooling/credential failures need a human fix. Automatic retry would repeat the same
-            // state immediately and spend another attempt before the operator can change anything.
-            await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: false, idempotency_key: `bridge:invalid-delivery:${active.attemptId}` } });
-            console.error(`Assignment ${taskId} could not produce a valid Delivery: ${redactSecrets(message)}`);
+            // classifyFinalizeFailure: contract/environment → non-retryable; forge transport → retryable;
+            // unknown faults stay retryable as "Bridge finalize interrupted" (not laundered as contract).
+            const classified = classifyFinalizeFailure(message);
+            await queueTerminal(client, taskId, {
+                action: "fail",
+                body: {
+                    error: classified.error,
+                    retryable: classified.retryable,
+                    idempotency_key: `bridge:invalid-delivery:${active.attemptId}`,
+                },
+            });
+            console.error(`Assignment ${taskId} could not produce a valid Delivery: ${redactSecrets(classified.error)}`);
             const replyTail = reportText.slice(-8_000);
             console.error(`Assignment ${taskId} agent reply tail (${reportText.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
             return;

package/dist/preflight.js

@@ -110,6 +110,21 @@ export async function cachedBridgePreflight(input) {
     cached = { key, at: Date.now(), report };
     return report;
 }
+/** Heartbeat-only / missing workspace still reports protocol 2 preflight (not ready). */
+export function unavailableWorkspacePreflight(input) {
+    const online = input.processOnlineIds?.length ? input.processOnlineIds : onlineDriverIds(input.config);
+    const issues = [];
+    if (!online.length)
+        issues.push({ code: "no_online_driver" });
+    issues.push({ code: "workspace_unavailable" });
+    return {
+        ready: false,
+        checked_at: new Date().toISOString(),
+        workspace_clean: false,
+        drivers: online.map((id) => ({ id, version: null, ready: false })),
+        issues,
+    };
+}
 export function describePreflightIssue(issue) {
     const lane = issue.driver ? ` (${issue.driver})` : "";
     if (issue.code === "no_online_driver")

package/dist/service.js

@@ -22,8 +22,6 @@ export function runnerProgramArguments(options = {}) {
     if (!cli)
         throw new Error("Unable to resolve the conduit CLI path");
     const args = [process.execPath, cli, "runner"];
-    if (options.agent)
-        args.push("--agent", options.agent);
     if (options.workspace)
         args.push("--workspace", options.workspace);
     if (options.ensureCheckout)

package/package.json

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