@miraland-labs/conduit-bridge 0.6.1 → 0.8.0

package/README.md

@@ -2,16 +2,18 @@
 
 Local Bridge CLI for [Conduit](https://github.com/miralandlabs/conduit). Connects a computer to one organization, claims work, and drives a local agent.
 
+**Current npm:** `0.8.0` — **multi-driver lanes** on one Connect computer (`drivers online|offline`), shared concurrent slots **1–4** (sum across online IDEs, not per IDE), per-attempt worktrees, optional `--ensure-checkout`, safe resume.
+
 ## Prerequisites
 
 - Node.js 20+
-- One supported agent CLI on PATH:
+- One or more supported agent CLIs on PATH (common: install several on one Mac):
   - **Claude Code** — `claude` (Conduit pump or Anthropic login)
   - **Codex** — `codex` (Conduit pump or ChatGPT/OpenAI login). Since the July 2026 ChatGPT desktop merge, Bridge also finds the CLI bundled inside ChatGPT.app when `codex` is not on PATH (macOS)
   - **OpenCode** — `opencode` (Conduit pump or local provider login)
-  - **Cursor Agent** — `agent` (requires `conduit fuel local` + `CURSOR_API_KEY` / Cursor login)
-  - **Kiro CLI** — `kiro-cli` (requires `conduit fuel local` + `KIRO_API_KEY` / `kiro-cli login`)
-  - **Antigravity** — `agy` (requires `conduit fuel local` + `GEMINI_API_KEY` / `agy login`)
+  - **Cursor Agent** — `agent` (local fuel; set with `drivers fuel cursor local` or machine `fuel local`)
+  - **Kiro CLI** — `kiro-cli` (local fuel)
+  - **Antigravity** — `agy` (local fuel)
 - macOS or Linux for `install-service` (Windows: keep a terminal runner open)
 
 ## Install / run
@@ -20,26 +22,36 @@ Local Bridge CLI for [Conduit](https://github.com/miralandlabs/conduit). Connect
 npx @miraland-labs/conduit-bridge join --url <https://your-conduit> --organization <slug>
 ```
 
-After approval:
+After approval, seed detects installed CLIs as **offline lanes**. Bring one or more online (subscription failover / concurrent lanes):
+
+```bash
+npx @miraland-labs/conduit-bridge drivers              # list lanes
+npx @miraland-labs/conduit-bridge drivers online claude-code
+npx @miraland-labs/conduit-bridge drivers online claude-code codex   # both can run at once
+npx @miraland-labs/conduit-bridge drivers offline claude-code         # finish in-flight; no new claims
+npx @miraland-labs/conduit-bridge runner --workspace /path/to/repo
+```
+
+Legacy single-driver process override (does not change saved online set):
 
 ```bash
 npx @miraland-labs/conduit-bridge runner --agent claude-code --workspace /path/to/repo
-npx @miraland-labs/conduit-bridge runner --agent codex --workspace /path/to/repo
-npx @miraland-labs/conduit-bridge runner --agent opencode --workspace /path/to/repo
-npx @miraland-labs/conduit-bridge fuel local   # required before cursor / kiro / antigravity
-npx @miraland-labs/conduit-bridge runner --agent cursor --workspace /path/to/repo
-npx @miraland-labs/conduit-bridge runner --agent kiro --workspace /path/to/repo
-npx @miraland-labs/conduit-bridge runner --agent antigravity --workspace /path/to/repo
 ```
 
-Persist (macOS/Linux):
+Persist (macOS/Linux) — one LaunchAgent; honors the drivers online set:
 
 ```bash
-npx @miraland-labs/conduit-bridge install-service --agent <claude-code|codex|cursor|opencode|kiro|antigravity> --workspace /path/to/repo
+npx @miraland-labs/conduit-bridge install-service --workspace /path/to/repo
+# optional: bring a lane online at install time
+npx @miraland-labs/conduit-bridge install-service --agent claude-code --workspace /path/to/repo
 ```
 
+Reinstall after upgrading from Bridge versions before 0.8 if the old unit baked a single `--agent`.
+
 For a Start-created GitHub repo that is not checked out yet, point `--workspace` at the intended path and add `--ensure-checkout <https://github.com/…>` so Bridge clones with the machine’s Git credentials before the first heartbeat (never the control-plane PAT).
 
+**Capacity:** Connect-approved `lease_capacity` (1–4) is a **shared pool** for all online lanes on that computer. Claude alone may use all 4 slots; Claude + Codex share those 4 — never 4×N.
+
 ## Grant enforcement
 
 Every driver enforces the assignment's granted actions with its CLI's native mechanism — never just the prompt:

package/dist/attempt-worktree.js

@@ -2,14 +2,23 @@
  * 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 { appendFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { access, appendFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 export function attemptWorktreePath(sourceWorkspace, attemptId) {
     return join(sourceWorkspace, ".conduit", "attempts", attemptId);
 }
+/**
+ * The branch each attempt works on. Named by attempt id, which is globally unique, so concurrent slots
+ * (F-07 multi-slot) never collide in the shared ref namespace and a retry never clashes with a prior
+ * attempt's branch. The agent commits on this branch — "the current branch" in the prompt is now true.
+ */
+export function attemptBranchName(attemptId) {
+    return `conduit/attempt/${attemptId}`;
+}
 export async function ensureConduitExclude(sourceWorkspace) {
     const excludePath = join(sourceWorkspace, ".git", "info", "exclude");
     await mkdir(join(sourceWorkspace, ".git", "info"), { recursive: true });
@@ -39,7 +48,11 @@ export async function createAttemptWorktree(input) {
     await assertSourceWorkspaceClean(input.sourceWorkspace);
     const path = attemptWorktreePath(input.sourceWorkspace, input.attemptId);
     await mkdir(join(input.sourceWorkspace, ".conduit", "attempts"), { recursive: true });
-    await execFileAsync("git", ["-C", input.sourceWorkspace, "worktree", "add", "--detach", path, input.startCommit], { timeout: 60_000, maxBuffer: 2_000_000 });
+    await execFileAsync("git", 
+    // A named attempt branch, not --detach: it collision-proofs concurrent slots and makes the agent's
+    // "commit on the current branch" accurate. -b fails if the branch exists, which is the desired
+    // guard — createAttemptWorktree only ever runs for a fresh attempt id (resume reuses its worktree).
+    ["-C", input.sourceWorkspace, "worktree", "add", "-b", attemptBranchName(input.attemptId), path, input.startCommit], { timeout: 60_000, maxBuffer: 2_000_000 });
     return path;
 }
 export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
@@ -54,6 +67,28 @@ export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
         }).catch(() => undefined);
     }
 }
+/**
+ * F-07 safe resume: prove the interrupted attempt still owns this worktree path.
+ * Does not check session identity — caller requires config.sessions[taskId] separately.
+ */
+export async function proveResumeWorktree(sourceWorkspace, attemptId, worktreePath) {
+    if (!worktreePath?.trim())
+        return false;
+    const expected = attemptWorktreePath(sourceWorkspace, attemptId);
+    if (resolve(worktreePath) !== resolve(expected))
+        return false;
+    try {
+        await access(worktreePath, constants.F_OK);
+        const { stdout } = await execFileAsync("git", ["-C", worktreePath, "rev-parse", "HEAD"], {
+            timeout: 15_000,
+            maxBuffer: 1_000_000,
+        });
+        return /^[0-9a-f]{40,64}$/i.test(stdout.trim());
+    }
+    catch {
+        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, "-");

package/dist/cli.js

@@ -6,13 +6,14 @@ import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { ConduitClient } from "./client.js";
-import { BRIDGE_LEASE_CAPACITY, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, savePendingConnection, suggestMachineName, } from "./config.js";
+import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, savePendingConnection, suggestMachineName, } from "./config.js";
 import { runMcp } from "./mcp.js";
 import { detectInstalledClients, localFuelOnlyClients, suggestFuelSource } from "./detect.js";
 import { DRIVERS } from "./driver.js";
+import { driversHeartbeatReport, driverLabel, heartbeatStatusForDrivers, isSupportedDriverId, listDriverLanes, onlineDriverIds, seedDriversFromDetection, seedDriverLanes, setDriverFuel, setDriversOnline, } from "./drivers.js";
 import { buildWorkspaceBrief } from "./brief.js";
 import { ensureCheckout } from "./checkout.js";
-import { executeNextAssignment, renewLeases } from "./execution.js";
+import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
 const [command] = process.argv.slice(2);
 /** Read our own package version so every runner start logs exactly which build is live. */
@@ -91,10 +92,11 @@ async function join() {
         const operatorName = values.operator?.trim() || userInfo().username;
         const machineName = values.machine?.trim() || suggestMachineName(hostname(), installationId);
         const capabilities = values.capability?.map((item) => item.trim()).filter(Boolean) ?? ["implement"];
-        if (values.capacity && Number(values.capacity) !== BRIDGE_LEASE_CAPACITY) {
-            throw new Error("Conduit Bridge currently runs one assignment at a time; --capacity must be 1");
+        const requestedCapacity = values.capacity ? Number(values.capacity) : BRIDGE_LEASE_CAPACITY;
+        if (!Number.isInteger(requestedCapacity) || requestedCapacity < 1 || requestedCapacity > BRIDGE_MAX_LEASE_CAPACITY) {
+            throw new Error(`--capacity must be an integer from 1 to ${BRIDGE_MAX_LEASE_CAPACITY} (concurrent attempt slots)`);
         }
-        const leaseCapacity = BRIDGE_LEASE_CAPACITY;
+        const leaseCapacity = clampLeaseCapacity(requestedCapacity);
         console.log("\nRequesting a Conduit connection:");
         console.log(`Operator: ${operatorName}`);
         console.log(`Computer: ${machineName}`);
@@ -186,18 +188,19 @@ async function finishConnection(baseUrl, data, fuelSource) {
     const detected = await detectInstalledClients();
     const resolvedFuel = fuelSource ?? suggestFuelSource(detected);
     const fuelAutoLocal = fuelSource === undefined && resolvedFuel === "local";
-    const config = {
+    let config = {
         baseUrl,
         organizationId: String(data.organization_id),
         machineId: String(data.machine_id),
         runnerKey: String(data.runner_secret),
         capabilities: data.capabilities,
         grants: data.grants,
-        leaseCapacity: Number(data.lease_capacity),
+        leaseCapacity: clampLeaseCapacity(data.lease_capacity),
         activeAttempts: {},
         fuelSource: resolvedFuel,
         ...(Object.keys(fuel).length ? { fuel } : {}),
     };
+    config = (await seedDriversFromDetection(config)).config;
     await saveConfig(config);
     const client = new ConduitClient(config);
     let heartbeatOk = true;
@@ -210,19 +213,24 @@ async function finishConnection(baseUrl, data, fuelSource) {
     console.log(`Connected machine: ${config.machineId}`);
     console.log(heartbeatOk ? "Runner credential and heartbeat: OK" : "Runner credential saved; heartbeat will retry when the runner starts");
     console.log(`Detected local clients: ${detected.join(", ") || "none"}`);
+    const lanes = listDriverLanes(config);
+    if (lanes.length) {
+        console.log(`Driver lanes (all offline until you bring one online): ${lanes.map((lane) => lane.id).join(", ")}`);
+    }
     console.log(`Confirmed capabilities (matching): ${config.capabilities.join(", ") || "none"}`);
     console.log(`Allowed actions: ${config.grants.join(", ") || "none"}`);
     console.log(`Fuel source: ${config.fuelSource === "local" ? "local subscription" : "Conduit pump"}`
         + (fuelAutoLocal ? " (auto: only Cursor/Kiro/Antigravity detected)" : ""));
     const localOnly = localFuelOnlyClients(detected);
     if (config.fuelSource === "conduit" && localOnly.length) {
-        console.log(`Note: ${localOnly.join(", ")} cannot use Conduit pump. Before --agent cursor|kiro|antigravity run: ${bridgeUsage("fuel", "local")}`);
+        console.log(`Note: ${localOnly.join(", ")} require local fuel per lane (set automatically for cursor/kiro/antigravity).`);
     }
     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(`Execute work: ${bridgeUsage("runner", "--agent", AGENT_PLACEHOLDER, "--workspace", "<repo>")}`);
-    console.log(`Keep on shift (macOS/Linux): ${bridgeUsage("install-service", "--agent", AGENT_PLACEHOLDER, "--workspace", "<repo>")}`);
-    console.log(`Flip fuel later: ${bridgeUsage("fuel", "local|conduit")} (cursor/kiro/antigravity require local fuel)`);
+    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(`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.");
     if (Object.keys(fuel).length) {
         console.log(`Fleet fueling: ${Object.keys(fuel).length} project key(s) configured for Conduit /v1`);
@@ -245,16 +253,26 @@ function openUrl(url) {
     }
 }
 async function installService() {
-    await loadConfig();
+    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" },
             "ensure-checkout": { type: "string" },
         } });
-    if (!values.agent || !values.workspace) {
-        throw new Error(`Usage: ${bridgeUsage("install-service", "--agent", AGENT_PLACEHOLDER, "--workspace", "<repository-path>", "[--ensure-checkout <repository-url>]")} (agent + workspace required; heartbeat-only services are not supported)`);
+    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)`);
     }
-    if (!DRIVERS[values.agent]) {
-        throw new Error(`Unknown agent driver: ${values.agent}. Available: ${Object.keys(DRIVERS).join(", ")}`);
+    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 saveConfig(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.`);
     }
     const workspace = resolve(values.workspace);
     if (values["ensure-checkout"]) {
@@ -263,14 +281,15 @@ 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({
-        agent: values.agent,
         workspace,
         interval: values.interval,
         agentTimeoutMinutes: values["agent-timeout-minutes"],
         ensureCheckout: values["ensure-checkout"],
     });
     console.log(`Installed Conduit runner service (${result.platform}): ${result.path}`);
+    console.log(`Online lanes: ${onlineDriverIds(config).join(", ")}. Toggle with \`${bridgeUsage("drivers", "online|offline", "…")}\`.`);
     console.log("The runner keeps executing after this terminal closes. Laptop sleep still pauses work.");
 }
 async function uninstallService() {
@@ -287,27 +306,83 @@ async function fuelCommand() {
     await saveConfig(config);
     const client = new ConduitClient(config);
     await heartbeat(client, config, null);
-    console.log(`Fuel source set to ${mode === "local" ? "local subscription" : "Conduit pump"} and reported on heartbeat.`);
+    console.log(`Machine fuel source set to ${mode === "local" ? "local subscription" : "Conduit pump"} and reported on heartbeat.`);
+}
+async function driversCommand() {
+    const sub = process.argv[3];
+    let config = await loadConfig();
+    config = (await seedDriversFromDetection(config)).config;
+    if (!sub || sub === "list") {
+        await saveConfig(config);
+        const lanes = listDriverLanes(config);
+        if (!lanes.length) {
+            console.log("No driver lanes registered. Install a supported agent CLI, then re-run this command.");
+            return;
+        }
+        console.log(`Computer ${config.machineId} — shared capacity ${config.leaseCapacity} (sum across online lanes, not per IDE)`);
+        for (const lane of lanes) {
+            console.log(`  ${lane.id.padEnd(14)} ${lane.state.padEnd(8)} fuel=${lane.fuel}  (${lane.label})`);
+        }
+        const online = onlineDriverIds(config);
+        console.log(online.length
+            ? `Online: ${online.join(", ")}. Toggle: ${bridgeUsage("drivers", "online|offline", "<id…>")}`
+            : `All offline — no new claims. Bring one online: ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}`);
+        return;
+    }
+    if (sub === "online" || sub === "offline") {
+        const ids = process.argv.slice(4).map((id) => id.trim()).filter(Boolean);
+        if (!ids.length)
+            throw new Error(`Usage: ${bridgeUsage("drivers", sub, AGENT_PLACEHOLDER, "[…]")}`);
+        for (const id of ids) {
+            if (!isSupportedDriverId(id))
+                throw new Error(`Unknown driver: ${id}. Available: ${Object.keys(DRIVERS).join(", ")}`);
+        }
+        config = seedDriverLanes(config, ids).config;
+        config = setDriversOnline(config, ids, sub === "online");
+        await saveConfig(config);
+        const client = new ConduitClient(config);
+        await heartbeat(client, config, null).catch(() => undefined);
+        console.log(`${sub === "online" ? "Online" : "Offline"}: ${ids.join(", ")}`);
+        console.log(`Now online: ${onlineDriverIds(config).join(", ") || "(none)"}`);
+        return;
+    }
+    if (sub === "fuel") {
+        const id = process.argv[4]?.trim();
+        const mode = process.argv[5];
+        if (!id || (mode !== "local" && mode !== "conduit")) {
+            throw new Error(`Usage: ${bridgeUsage("drivers", "fuel", "<driver-id>", "local|conduit")}`);
+        }
+        config = seedDriverLanes(config, [id]).config;
+        config = setDriverFuel(config, id, mode);
+        await saveConfig(config);
+        console.log(`${driverLabel(id)} lane fuel set to ${mode}`);
+        return;
+    }
+    throw new Error(`Usage: ${bridgeUsage("drivers", "[list|online|offline|fuel]", "…")}`);
 }
 async function runner() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: {
             agent: { type: "string" }, workspace: { type: "string" }, interval: { type: "string" }, once: { type: "boolean" },
             "agent-timeout-minutes": { type: "string" }, fuel: { type: "string" }, "ensure-checkout": { type: "string" },
         } });
-    const config = await loadConfig();
+    let config = await loadConfig();
     const fuelOverride = parseFuelSource(values.fuel);
     if (fuelOverride) {
         config.fuelSource = fuelOverride;
         await saveConfig(config);
     }
+    config = (await seedDriversFromDetection(config)).config;
+    await saveConfig(config);
     const client = new ConduitClient(config);
-    let driver = null;
+    let processDriver = null;
+    let processOnlineIds = null;
     if (values.agent) {
-        driver = DRIVERS[values.agent] ?? null;
-        if (!driver)
+        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>");
@@ -322,37 +397,53 @@ 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 fuelLabel = config.fuelSource === "local" ? "local subscription" : "Conduit pump";
-    if (!driver || !workspace) {
-        console.warn(`WARNING: heartbeat only — no work will execute. Use: ${bridgeUsage("runner", "--agent", AGENT_PLACEHOLDER, "--workspace", "<repo>")}`);
+    const canExecute = Boolean(workspace) && (Boolean(processDriver) || 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.log(`Conduit runner (bridge v${bridgeVersion()}) connected to ${config.baseUrl}${driver ? ` — executing via ${driver.name} in ${workspace}` : " — heartbeat only (no --agent)"} (fuel: ${fuelLabel})`);
+    const onlineLabel = (processOnlineIds?.join(", ") || 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 (;;) {
-        let executed = false;
+        let progressed = false;
         try {
+            // Reload drivers online/offline each cycle so CLI toggles apply without restart.
+            const latest = await loadConfig();
+            config.drivers = latest.drivers;
+            config.fuelSource = latest.fuelSource;
+            config.leaseCapacity = latest.leaseCapacity;
             await heartbeat(client, config, workspace ? await buildWorkspaceBrief(workspace).catch(() => brief) : null);
             await renewLeases(client, config);
-            if (driver && workspace) {
-                executed = await executeNextAssignment(client, config, driver, workspace, brief, timeoutMs, {
+            if (workspace && (processDriver || onlineDriverIds(config).length)) {
+                progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: async () => heartbeat(client, config, await buildWorkspaceBrief(workspace).catch(() => brief)),
                     heartbeatIntervalMs: intervalMs,
-                });
+                }, running, { driver: processDriver, processOnlineIds });
             }
         }
         catch (error) {
             console.error(`Runner cycle failed; retrying: ${redactSecrets(error instanceof Error ? error.message : "unknown error")}`);
         }
-        if (values.once && executed)
+        if (values.once && progressed) {
+            if (running.size)
+                await Promise.allSettled([...running.values()]);
             return;
+        }
         await new Promise((resolveSleep) => setTimeout(resolveSleep, intervalMs));
     }
 }
 async function heartbeat(client, config, brief) {
+    const online = onlineDriverIds(config);
+    const status = heartbeatStatusForDrivers(online);
     await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
-            status: "online",
+            status,
             capabilities: config.capabilities,
             lease_capacity: config.leaseCapacity,
             fuel_source: config.fuelSource === "local" ? "local" : "conduit",
+            drivers: driversHeartbeatReport(config, config.activeAttempts),
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
 }
@@ -363,6 +454,8 @@ try {
         await join();
     else if (command === "fuel")
         await fuelCommand();
+    else if (command === "drivers")
+        await driversCommand();
     else if (command === "mcp")
         await runMcp();
     else if (command === "runner")
@@ -372,7 +465,7 @@ try {
     else if (command === "uninstall-service")
         await uninstallService();
     else
-        throw new Error(`Usage: ${BRIDGE_NPX} <join|connect|fuel|mcp|runner|install-service|uninstall-service>`);
+        throw new Error(`Usage: ${BRIDGE_NPX} <join|connect|fuel|drivers|mcp|runner|install-service|uninstall-service>`);
 }
 catch (error) {
     console.error(error instanceof Error ? redactSecrets(error.message) : "Conduit command failed");

package/dist/config.js

@@ -2,7 +2,16 @@ import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+/** Default when join omits --capacity. */
 export const BRIDGE_LEASE_CAPACITY = 1;
+/** Hard ceiling for truthful concurrent Bridge slots (one agent + worktree each). */
+export const BRIDGE_MAX_LEASE_CAPACITY = 4;
+export function clampLeaseCapacity(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isInteger(n) || n < 1)
+        return BRIDGE_LEASE_CAPACITY;
+    return Math.min(n, BRIDGE_MAX_LEASE_CAPACITY);
+}
 const directory = process.env.CONDUIT_BRIDGE_CONFIG_DIR?.trim()
     ? resolve(process.env.CONDUIT_BRIDGE_CONFIG_DIR)
     : join(homedir(), ".config", "conduit");
@@ -39,9 +48,19 @@ export async function loadConfigIfPresent() {
         active.phase ??= "agent_running";
     if (config.fuelSource !== "local" && config.fuelSource !== "conduit")
         config.fuelSource = "conduit";
-    // The built-in Bridge runs one agent process synchronously. Keep legacy
-    // configurations truthful until isolated concurrent slot workers exist.
-    config.leaseCapacity = BRIDGE_LEASE_CAPACITY;
+    // Clamp to what concurrent slot workers can run (1..BRIDGE_MAX_LEASE_CAPACITY).
+    config.leaseCapacity = clampLeaseCapacity(config.leaseCapacity ?? BRIDGE_LEASE_CAPACITY);
+    if (config.drivers && typeof config.drivers === "object") {
+        const cleaned = {};
+        for (const [id, lane] of Object.entries(config.drivers)) {
+            if (!lane || typeof lane !== "object")
+                continue;
+            const state = lane.state === "online" ? "online" : "offline";
+            const fuel = lane.fuel === "local" || lane.fuel === "conduit" ? lane.fuel : undefined;
+            cleaned[id] = fuel ? { state, fuel } : { state };
+        }
+        config.drivers = cleaned;
+    }
     return config;
 }
 export async function saveConfig(config) {

package/dist/driver.js

@@ -130,7 +130,7 @@ export function buildAssignmentPrompt(context) {
             `- These are the ONLY shell commands you may run: ${runnableCommands.join("; ")}. Anything else is rejected — do not try variations, wrappers, or \`echo\`. Run the relevant ones and report their real output.`,
         ]
         : ["- You have no shell authority for this assignment. Do not attempt shell commands; verify by reading files and report what you could not verify as unknown."]), ...(mustCommit
-        ? ["- Commit your repository changes locally (git add + git commit on the current branch) and report the resulting sha as head_commit. A delivery that changed files without a commit is rejected. Local commits are required; pushing is a separate authority."]
+        ? ["- Your working branch is already checked out. Commit your repository changes on the current branch (git add + git commit) — do not create a new branch — and report the resulting sha as head_commit. A delivery that changed files without a commit is rejected. Local commits are required; pushing is a separate authority."]
         : ["- You have no repository write authority for this assignment. Do not create, modify, or commit any file; a delivery reporting repository changes will be rejected. Record all findings, verification output, and conclusions in your final report instead."]), "- Never merge, deploy, push to protected branches, or touch production.", `- Hard-denied commands (all drivers): ${deniedCommands.join("; ")}.`, "- Do not invent evidence. Report unknown when you could not verify a criterion.", 
     // A met claim with nothing backing it is rejected server-side ("Met acceptance criteria require
     // mapped evidence"). Observed live: six criteria marked met, evidence mapped to four, whole

package/dist/drivers.js

@@ -0,0 +1,172 @@
+/**
+ * Local driver lanes on one Bridge computer: operator online/offline set + shared slot pool.
+ * Matching stays computer-scoped; Bridge assigns each new claim to a free online driver.
+ */
+import { detectInstalledClients } from "./detect.js";
+import { DRIVERS, SUPPORTED_AGENTS } from "./driver.js";
+/** Display labels from detectInstalledClients → Bridge driver ids. */
+const LABEL_TO_DRIVER = {
+    "Claude Code": "claude-code",
+    "Codex CLI": "codex",
+    OpenCode: "opencode",
+    "Cursor Agent": "cursor",
+    Cursor: "cursor",
+    "Kiro CLI": "kiro",
+    Antigravity: "antigravity",
+};
+const LOCAL_FUEL_ONLY_DRIVERS = new Set(["cursor", "kiro", "antigravity"]);
+export function isSupportedDriverId(id) {
+    return Object.prototype.hasOwnProperty.call(DRIVERS, id);
+}
+export function driverLabel(id) {
+    return SUPPORTED_AGENTS.find((agent) => agent.id === id)?.label ?? id;
+}
+export function localFuelOnlyDriver(id) {
+    return LOCAL_FUEL_ONLY_DRIVERS.has(id);
+}
+/** Map PATH probe labels to unique driver ids. */
+export function driverIdsFromDetectedLabels(labels) {
+    const ids = new Set();
+    for (const label of labels) {
+        const id = LABEL_TO_DRIVER[label];
+        if (id)
+            ids.add(id);
+    }
+    return [...ids];
+}
+export function normalizeDrivers(raw) {
+    const out = {};
+    if (!raw || typeof raw !== "object")
+        return out;
+    for (const [id, lane] of Object.entries(raw)) {
+        if (!isSupportedDriverId(id) || !lane || typeof lane !== "object")
+            continue;
+        const state = lane.state === "online" ? "online" : "offline";
+        const fuel = lane.fuel === "local" || lane.fuel === "conduit" ? lane.fuel : undefined;
+        out[id] = fuel ? { state, fuel } : { state };
+    }
+    return out;
+}
+/**
+ * Ensure detected (or listed) drivers exist in config. New lanes default offline (fail-closed).
+ * Does not flip existing online/offline state.
+ */
+export function seedDriverLanes(config, driverIds) {
+    const drivers = normalizeDrivers(config.drivers);
+    const added = [];
+    for (const id of driverIds) {
+        if (!isSupportedDriverId(id))
+            continue;
+        if (drivers[id])
+            continue;
+        drivers[id] = localFuelOnlyDriver(id) ? { state: "offline", fuel: "local" } : { state: "offline" };
+        added.push(id);
+    }
+    return { config: { ...config, drivers }, added };
+}
+export async function seedDriversFromDetection(config) {
+    const labels = await detectInstalledClients();
+    return seedDriverLanes(config, driverIdsFromDetectedLabels(labels));
+}
+export function listDriverLanes(config) {
+    const drivers = normalizeDrivers(config.drivers);
+    return SUPPORTED_AGENTS
+        .filter((agent) => drivers[agent.id])
+        .map((agent) => {
+        const lane = drivers[agent.id];
+        return {
+            id: agent.id,
+            label: agent.label,
+            state: lane.state,
+            fuel: resolveDriverFuel(config, agent.id),
+        };
+    });
+}
+export function onlineDriverIds(config) {
+    const drivers = normalizeDrivers(config.drivers);
+    return SUPPORTED_AGENTS.map((agent) => agent.id).filter((id) => drivers[id]?.state === "online");
+}
+export function setDriversOnline(config, ids, online) {
+    const drivers = normalizeDrivers(config.drivers);
+    for (const id of ids) {
+        if (!isSupportedDriverId(id))
+            throw new Error(`Unknown driver: ${id}. Available: ${Object.keys(DRIVERS).join(", ")}`);
+        const prev = drivers[id] ?? (localFuelOnlyDriver(id) ? { state: "offline", fuel: "local" } : { state: "offline" });
+        drivers[id] = { ...prev, state: online ? "online" : "offline" };
+    }
+    return { ...config, drivers };
+}
+/** Fuel for a lane: per-driver override → machine default; local-only drivers always local. */
+export function resolveDriverFuel(config, driverId) {
+    if (localFuelOnlyDriver(driverId))
+        return "local";
+    const lane = normalizeDrivers(config.drivers)[driverId];
+    if (lane?.fuel === "local" || lane?.fuel === "conduit")
+        return lane.fuel;
+    return config.fuelSource === "local" ? "local" : "conduit";
+}
+export function setDriverFuel(config, driverId, fuel) {
+    if (!isSupportedDriverId(driverId))
+        throw new Error(`Unknown driver: ${driverId}`);
+    if (localFuelOnlyDriver(driverId) && fuel === "conduit") {
+        throw new Error(`${driverLabel(driverId)} requires local fuel`);
+    }
+    const drivers = normalizeDrivers(config.drivers);
+    const prev = drivers[driverId] ?? { state: "offline" };
+    drivers[driverId] = { ...prev, fuel };
+    return { ...config, drivers };
+}
+/** Heartbeat status: standby when no online lanes (supervisor mode). */
+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) {
+    const busyByDriver = new Map();
+    for (const active of Object.values(activeAttempts)) {
+        if (!active.driverId)
+            continue;
+        busyByDriver.set(active.driverId, (busyByDriver.get(active.driverId) ?? 0) + 1);
+    }
+    return listDriverLanes(config).map((lane) => ({
+        id: lane.id,
+        state: lane.state,
+        busy: (busyByDriver.get(lane.id) ?? 0) > 0,
+    }));
+}
+/**
+ * Pick an online driver for a new claim: least loaded among online (shared machine pool).
+ * `processOnlineIds` overrides config when runner was started with --agent.
+ */
+export function pickDriverForClaim(config, processOnlineIds) {
+    const online = (processOnlineIds?.length ? processOnlineIds : onlineDriverIds(config))
+        .filter((id) => isSupportedDriverId(id));
+    if (!online.length)
+        return null;
+    const load = new Map();
+    for (const id of online)
+        load.set(id, 0);
+    for (const active of Object.values(config.activeAttempts)) {
+        if (active.driverId && load.has(active.driverId)) {
+            load.set(active.driverId, (load.get(active.driverId) ?? 0) + 1);
+        }
+    }
+    let best = online[0];
+    let bestLoad = load.get(best) ?? 0;
+    for (const id of online.slice(1)) {
+        const n = load.get(id) ?? 0;
+        if (n < bestLoad) {
+            best = id;
+            bestLoad = n;
+        }
+    }
+    return best;
+}

package/dist/execution.js

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ConduitRequestError } from "./client.js";
 import { redactSecrets } from "./config.js";
-import { agentReportTemplate, buildAssignmentPrompt, evidenceKinds, parseAgentReport, pickModelCandidate, tierForRisk } from "./driver.js";
-import { attemptWorktreePath, createAttemptWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
+import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, parseAgentReport, pickModelCandidate, tierForRisk } from "./driver.js";
+import { pickDriverForClaim, resolveDriverFuel } from "./drivers.js";
+import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, isBaseCommitAncestor, normalizeRepositoryUrl } from "./brief.js";
 const assignmentSchema = z.object({
     id: z.string().uuid(),
@@ -66,13 +67,32 @@ export async function renewLeases(client, config) {
         }
     }
 }
-export async function recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision) {
-    const active = Object.values(config.activeAttempts)[0];
+function resolveAttemptDriver(config, active, fallback) {
+    if (active.driverId && DRIVERS[active.driverId])
+        return DRIVERS[active.driverId];
+    return fallback ?? null;
+}
+export async function recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision, taskId) {
+    const active = taskId ? config.activeAttempts[taskId] : Object.values(config.activeAttempts)[0];
     if (!active)
         return false;
+    const laneDriver = resolveAttemptDriver(config, active, driver);
+    if (!laneDriver) {
+        console.error(`No driver for attempt ${active.attemptId} (driverId=${active.driverId ?? "unset"})`);
+        return false;
+    }
     if (active.phase === "agent_running") {
-        // F-07: never resume a dirty shared checkout. Quarantine/remove the attempt worktree first.
         const worktree = active.worktreePath ?? attemptWorktreePath(workspace, active.attemptId);
+        const sessionId = config.sessions?.[active.taskId]?.trim() || "";
+        // F-07 safe resume: only when session + worktree identity are both proven. Otherwise interrupt.
+        if (sessionId && await proveResumeWorktree(workspace, active.attemptId, worktree)) {
+            console.log(`Resuming interrupted attempt ${active.attemptId} with proven worktree and session.`);
+            await runClaimedAssignment(client, config, laneDriver, workspace, brief, active.taskId, timeoutMs, supervision, {
+                existingWorktree: worktree,
+                forceResumeSessionId: sessionId,
+            });
+            return true;
+        }
         await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
         await client.updateAttempt(active.taskId, { worktreePath: undefined });
         await queueTerminal(client, active.taskId, {
@@ -89,20 +109,83 @@ export async function recoverActiveAttempt(client, config, driver, workspace, br
         await flushTerminal(client, active.taskId);
         return true;
     }
-    await runClaimedAssignment(client, config, driver, workspace, brief, active.taskId, timeoutMs, supervision);
+    await runClaimedAssignment(client, config, laneDriver, workspace, brief, active.taskId, timeoutMs, supervision);
     return true;
 }
-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);
+/**
+ * F-07 multi-slot + multi-driver supervisor: keep up to leaseCapacity concurrent agent runs
+ * (each with its own worktree). Shared pool across online lanes — not 4 per IDE.
+ * `running` is owned by the runner loop and must outlive a single pump call.
+ */
+export async function pumpExecutionSlots(client, config, workspace, brief, timeoutMs, supervision, running, options = {}) {
+    const fallbackDriver = options.driver ?? null;
+    const processOnlineIds = options.processOnlineIds
+        ?? (fallbackDriver
+            ? [Object.entries(DRIVERS).find(([, d]) => d === fallbackDriver)?.[0]].filter((id) => Boolean(id))
+            : null);
+    let progressed = running.size > 0;
+    for (const id of Object.keys(config.activeAttempts)) {
+        if (running.has(id))
+            continue;
+        const active = config.activeAttempts[id];
+        const laneDriver = resolveAttemptDriver(config, active, fallbackDriver);
+        if (!laneDriver) {
+            console.error(`Slot recovery skipped for ${id}: no driver lane`);
+            continue;
+        }
+        progressed = true;
+        const slot = recoverActiveAttempt(client, config, laneDriver, workspace, brief, timeoutMs, supervision, id)
+            .catch((error) => {
+            console.error(`Slot recovery failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        })
+            .then(() => undefined)
+            .finally(() => { running.delete(id); });
+        running.set(id, slot);
+    }
+    while (running.size < config.leaseCapacity) {
+        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]
+                ?? fallbackDriver.name;
+        }
+        else {
+            driverId = pickDriverForClaim(config, processOnlineIds);
+            laneDriver = driverId ? DRIVERS[driverId] ?? null : null;
+        }
+        if (!laneDriver || !driverId)
+            break;
+        const taskId = await claimNextAssignment(client, config, workspace, brief);
+        if (!taskId)
+            break;
+        await client.updateAttempt(taskId, { driverId });
+        progressed = true;
+        console.log(`Executing ${taskId} via ${laneDriver.name}`);
+        const slot = runClaimedAssignment(client, config, laneDriver, workspace, brief, taskId, timeoutMs, supervision)
+            .catch((error) => {
+            console.error(`Slot execution failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        })
+            .then(() => undefined)
+            .finally(() => { running.delete(taskId); });
+        running.set(taskId, slot);
+    }
+    return progressed;
+}
+/** Claim one assignment when under capacity; does not start the agent (multi-slot pump does). */
+export async function claimNextAssignment(client, config, workspace, brief) {
+    if (Object.keys(config.activeAttempts).length >= config.leaseCapacity)
+        return null;
     const data = await client.request("/runner/v1/assignments");
     const assignments = z.array(assignmentSchema).parse(data.assignments ?? []);
     const assignment = assignments[0];
     if (!assignment)
-        return false;
+        return null;
     if (assignment.execution_mode === "human") {
         console.log(`Human takeover assignment ${assignment.id} — use Bridge MCP tools to claim and submit (agent runner skips).`);
-        return false;
+        return null;
     }
     const liveBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
     const liveRepository = liveBrief?.repository ? normalizeRepositoryUrl(liveBrief.repository) : null;
@@ -122,14 +205,22 @@ export async function executeNextAssignment(client, config, driver, workspace, b
             body: JSON.stringify({ attempt_id: assignment.attempt_id, reason: rejection, idempotency_key: `bridge:preflight-reject:${assignment.attempt_id}:${rejection}` }),
         });
         console.error(`Assignment ${assignment.id} rejected before claim: ${rejection}`);
-        return true;
+        return null;
     }
     console.log(`Claiming assignment ${assignment.id} (attempt ${assignment.attempt_id})`);
     await client.claim(assignment.id, assignment.attempt_id);
-    await runClaimedAssignment(client, config, driver, workspace, brief, assignment.id, timeoutMs, supervision);
+    return assignment.id;
+}
+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 taskId = await claimNextAssignment(client, config, workspace, brief);
+    if (!taskId)
+        return false;
+    await runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision);
     return true;
 }
-async function runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision) {
+async function runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision, options = {}) {
     const active = client.attempt(taskId);
     const detail = await client.request(`/runner/v1/tasks/${taskId}`);
     const task = taskDetailSchema.parse(detail.task);
@@ -157,28 +248,45 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         return;
     }
     let attemptWorkspace;
-    try {
-        attemptWorkspace = await createAttemptWorktree({
-            sourceWorkspace: workspace,
-            attemptId: active.attemptId,
-            startCommit,
-        });
+    if (options.existingWorktree) {
+        attemptWorkspace = options.existingWorktree;
     }
-    catch (error) {
-        const code = error instanceof Error ? error.message : "worktree_create_failed";
-        const message = code === "source_workspace_dirty"
-            ? "Source workspace has uncommitted changes; refuse to start an isolated attempt"
-            : `Unable to create attempt worktree: ${code}`;
-        await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: true, idempotency_key: `bridge:worktree:${active.attemptId}:${code}` } });
-        console.error(`Assignment ${taskId} worktree create failed: ${redactSecrets(message)}`);
-        return;
+    else {
+        try {
+            attemptWorkspace = await createAttemptWorktree({
+                sourceWorkspace: workspace,
+                attemptId: active.attemptId,
+                startCommit,
+            });
+        }
+        catch (error) {
+            const code = error instanceof Error ? error.message : "worktree_create_failed";
+            const message = code === "source_workspace_dirty"
+                ? "Source workspace has uncommitted changes; refuse to start an isolated attempt"
+                : `Unable to create attempt worktree: ${code}`;
+            await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: true, idempotency_key: `bridge:worktree:${active.attemptId}:${code}` } });
+            console.error(`Assignment ${taskId} worktree create failed: ${redactSecrets(message)}`);
+            return;
+        }
+        await client.updateAttempt(taskId, { worktreePath: attemptWorkspace });
     }
-    await client.updateAttempt(taskId, { worktreePath: attemptWorkspace });
     // Same list the driver hands to the permission contract, so the prompt states exactly what is
     // executable rather than leaving the agent to guess and hit rejections.
     const prompt = buildAssignmentPrompt({ taskId, objective: task.objective, spec, grants, workspace: attemptWorkspace, currentHead: startCommit, reworkFeedback, workPackage, verificationCommands: liveBrief?.verification ?? [] });
-    await client.attemptRequest(taskId, "progress", { phase: "changing", message: `Starting ${driver.name} for this assignment${reworkFeedback ? " with review feedback" : ""}.`, idempotency_key: `bridge:progress:${active.attemptId}:start` });
-    const fuelSource = config.fuelSource === "local" ? "local" : "conduit";
+    const resuming = Boolean(options.forceResumeSessionId);
+    await client.attemptRequest(taskId, "progress", {
+        phase: "changing",
+        message: resuming
+            ? `Resuming ${driver.name} after Bridge restart with proven session and worktree.`
+            : `Starting ${driver.name} for this assignment${reworkFeedback ? " with review feedback" : ""}.`,
+        idempotency_key: resuming ? `bridge:progress:${active.attemptId}:resume` : `bridge:progress:${active.attemptId}:start`,
+    });
+    const driverId = active.driverId
+        ?? Object.entries(DRIVERS).find(([, d]) => d === driver)?.[0]
+        ?? "unknown";
+    if (!active.driverId && driverId !== "unknown")
+        await client.updateAttempt(taskId, { driverId });
+    const fuelSource = resolveDriverFuel(config, driverId);
     let fuel;
     if (fuelSource === "conduit") {
         const gatewayKey = await client.ensureFuel(task.project_id);
@@ -193,10 +301,12 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     // that was chosen. updateAttempt alone only moves local runner state, which the database never sees.
     await client.attemptRequest(taskId, "progress", {
         phase: "agent_running",
-        message: `Started ${driver.name}${selection.model ? ` on ${selection.model}` : " on its CLI default"}.`,
-        idempotency_key: `bridge:progress:${active.attemptId}:agent-start`,
+        message: resuming
+            ? `Resumed ${driver.name}${selection.model ? ` on ${selection.model}` : " on its CLI default"}.`
+            : `Started ${driver.name}${selection.model ? ` on ${selection.model}` : " on its CLI default"}.`,
+        idempotency_key: resuming ? `bridge:progress:${active.attemptId}:agent-resume` : `bridge:progress:${active.attemptId}:agent-start`,
     });
-    await client.updateAttempt(taskId, { phase: "agent_running", fuelMode: fuelSource });
+    await client.updateAttempt(taskId, { phase: "agent_running", fuelMode: fuelSource, worktreePath: attemptWorkspace, driverId });
     const renewTimer = setInterval(() => { void renewLeases(client, config).catch((error) => console.error(`Lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`)); }, 60_000);
     let heartbeatRunning = false;
     const heartbeatTimer = supervision ? setInterval(() => {
@@ -208,15 +318,17 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             .finally(() => { heartbeatRunning = false; });
     }, supervision.heartbeatIntervalMs) : null;
     try {
+        // Resume for (1) Bridge restart with proven session+worktree, or (2) review rework.
+        // A fresh attempt after a failed delivery must start clean: resuming a session whose last
+        // turn already "finished" makes the agent reply conversationally without the report block.
+        const resumeSessionId = options.forceResumeSessionId
+            ?? (reworkFeedback ? config.sessions?.[taskId] : undefined);
         const result = await driver.run({
             prompt,
             workspace: attemptWorkspace,
             grants,
             verificationCommands: liveBrief?.verification ?? [],
-            // Resume only for review rework, where continuing the prior conversation is the point.
-            // A fresh attempt after a failed delivery must start clean: resuming a session whose last
-            // turn already "finished" makes the agent reply conversationally without the report block.
-            resumeSessionId: reworkFeedback ? config.sessions?.[taskId] : undefined,
+            resumeSessionId,
             timeoutMs,
             model: selection.model,
             fuel,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.6.1",
-  "description": "Conduit Bridge CLI — join, connect, and run Claude Code / Codex / Cursor / OpenCode / Kiro / Antigravity agents for a Conduit organization",
+  "version": "0.8.0",
+  "description": "Conduit Bridge CLI — join, connect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Kiro / Antigravity agents for a Conduit organization",
   "type": "module",
   "bin": {
     "conduit": "dist/cli.js"