@miraland-labs/conduit-bridge 0.7.0 → 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

@@ -11,6 +11,14 @@ 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 });
@@ -40,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) {

package/dist/cli.js

@@ -10,6 +10,7 @@ import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, c
 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 { pumpExecutionSlots, renewLeases } from "./execution.js";
@@ -187,7 +188,7 @@ 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),
@@ -199,6 +200,7 @@ async function finishConnection(baseUrl, data, fuelSource) {
         fuelSource: resolvedFuel,
         ...(Object.keys(fuel).length ? { fuel } : {}),
     };
+    config = (await seedDriversFromDetection(config)).config;
     await saveConfig(config);
     const client = new ConduitClient(config);
     let heartbeatOk = true;
@@ -211,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`);
@@ -246,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)`);
+    }
+    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}).`);
     }
-    if (!DRIVERS[values.agent]) {
-        throw new Error(`Unknown agent driver: ${values.agent}. Available: ${Object.keys(DRIVERS).join(", ")}`);
+    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"]) {
@@ -264,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() {
@@ -288,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>");
@@ -323,22 +397,31 @@ 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}; slots: ${config.leaseCapacity})`);
+    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 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) {
-                progressed = await pumpExecutionSlots(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);
+                }, running, { driver: processDriver, processOnlineIds });
             }
         }
         catch (error) {
@@ -353,11 +436,14 @@ async function runner() {
     }
 }
 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 } : {}),
         }) });
 }
@@ -368,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")
@@ -377,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

@@ -50,6 +50,17 @@ export async function loadConfigIfPresent() {
         config.fuelSource = "conduit";
     // 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,7 +2,8 @@ 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 { 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({
@@ -66,17 +67,27 @@ export async function renewLeases(client, config) {
         }
     }
 }
+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") {
         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, driver, workspace, brief, active.taskId, timeoutMs, supervision, {
+            await runClaimedAssignment(client, config, laneDriver, workspace, brief, active.taskId, timeoutMs, supervision, {
                 existingWorktree: worktree,
                 forceResumeSessionId: sessionId,
             });
@@ -98,20 +109,32 @@ 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;
 }
 /**
- * F-07 multi-slot: keep up to leaseCapacity concurrent agent runs (each with its own worktree).
+ * 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, driver, workspace, brief, timeoutMs, supervision, running) {
+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, driver, workspace, brief, timeoutMs, supervision, id)
+        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")}`);
         })
@@ -120,11 +143,28 @@ export async function pumpExecutionSlots(client, config, driver, workspace, brie
         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;
-        const slot = runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision)
+        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")}`);
         })
@@ -241,7 +281,12 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             : `Starting ${driver.name} for this assignment${reworkFeedback ? " with review feedback" : ""}.`,
         idempotency_key: resuming ? `bridge:progress:${active.attemptId}:resume` : `bridge:progress:${active.attemptId}:start`,
     });
-    const fuelSource = config.fuelSource === "local" ? "local" : "conduit";
+    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);
@@ -261,7 +306,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             : `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, worktreePath: attemptWorkspace });
+    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(() => {

package/package.json

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