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

@@ -43,6 +43,41 @@ export async function isBaseCommitAncestor(workspace, baseCommit, headCommit) {
         throw error;
     }
 }
+/** True when `sha` is a local commit object, optionally after fetching it from origin. */
+export async function ensureCommitAvailable(workspace, sha) {
+    const present = async () => {
+        try {
+            await execFileAsync("git", ["-C", workspace, "cat-file", "-e", `${sha}^{commit}`], {
+                timeout: 10_000,
+                windowsHide: true,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (await present())
+        return true;
+    try {
+        await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "--depth=1", "origin", sha], {
+            timeout: 120_000,
+            windowsHide: true,
+        });
+    }
+    catch {
+        try {
+            await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "origin"], {
+                timeout: 120_000,
+                windowsHide: true,
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    return present();
+}
 async function gitRemoteUrl(workspace) {
     try {
         const { common } = await gitDirectories(workspace);

package/dist/cli.js

@@ -6,10 +6,11 @@ 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, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, 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, saveConfigPrefs, 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 { 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"}`
+    console.log(`Fuel source: ${config.fuelSource === "local" ? "local subscription" : "Conduit /v1 (project owner BYOK on open orgs; org credentials on invite-only)"}`
         + (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 saveConfigPrefs(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() {
@@ -285,30 +303,86 @@ async function fuelCommand() {
     }
     const config = await loadConfig();
     config.fuelSource = mode;
-    await saveConfig(config);
+    await saveConfigPrefs(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 saveConfigPrefs(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 saveConfigPrefs(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 saveConfigPrefs(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);
+        await saveConfigPrefs(config);
     }
+    config = (await seedDriversFromDetection(config)).config;
+    await saveConfigPrefs(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 {
-            await heartbeat(client, config, workspace ? await buildWorkspaceBrief(workspace).catch(() => brief) : null);
+            // 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, processOnlineIds);
             await renewLeases(client, config);
-            if (driver && workspace) {
-                progressed = await pumpExecutionSlots(client, config, driver, workspace, brief, timeoutMs, {
-                    heartbeat: async () => heartbeat(client, config, await buildWorkspaceBrief(workspace).catch(() => brief)),
+            if (workspace && (processDriver || onlineDriverIds(config).length)) {
+                progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
+                    heartbeat: async () => heartbeat(client, config, await buildWorkspaceBrief(workspace).catch(() => brief), processOnlineIds),
                     heartbeatIntervalMs: intervalMs,
-                }, running);
+                }, running, { driver: processDriver, processOnlineIds });
             }
         }
         catch (error) {
@@ -352,12 +435,16 @@ async function runner() {
         await new Promise((resolveSleep) => setTimeout(resolveSleep, intervalMs));
     }
 }
-async function heartbeat(client, config, brief) {
+async function heartbeat(client, config, brief, processOnlineIds) {
+    // Process-level `--agent` override must count as online even when saved lanes are offline.
+    const online = processOnlineIds?.length ? processOnlineIds : 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, processOnlineIds),
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
 }
@@ -368,6 +455,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 +466,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/client.js

@@ -1,4 +1,4 @@
-import { saveConfig } from "./config.js";
+import { removeRuntimeAttempt, saveConfigPrefs, saveRuntime } from "./config.js";
 export class ConduitRequestError extends Error {
     status;
     code;
@@ -10,10 +10,24 @@ export class ConduitRequestError extends Error {
 }
 export class ConduitClient {
     config;
-    persist;
-    constructor(config, persist = saveConfig) {
+    persistRuntime;
+    persistPrefs;
+    removeAttempt;
+    constructor(config, persist) {
         this.config = config;
-        this.persist = persist;
+        if (typeof persist === "function") {
+            this.persistRuntime = persist;
+            this.persistPrefs = persist;
+            this.removeAttempt = async (taskId) => {
+                delete this.config.activeAttempts[taskId];
+                await persist(this.config);
+            };
+        }
+        else {
+            this.persistRuntime = persist?.runtime ?? saveRuntime;
+            this.persistPrefs = persist?.prefs ?? saveConfigPrefs;
+            this.removeAttempt = persist?.removeAttempt ?? removeRuntimeAttempt;
+        }
     }
     async request(path, init = {}) {
         const response = await fetch(`${this.config.baseUrl}${path}`, {
@@ -25,11 +39,18 @@ export class ConduitClient {
             throw new ConduitRequestError(data.error?.message ?? `Conduit request failed (${response.status})`, response.status, data.error?.code);
         return data;
     }
-    async claim(taskId, attemptId) {
+    async claim(taskId, attemptId, extras) {
         const data = await this.request(`/runner/v1/tasks/${taskId}/claim`, { method: "POST", body: JSON.stringify({ attempt_id: attemptId, idempotency_key: `bridge:claim:${attemptId}` }) });
-        const active = { taskId, attemptId, leaseToken: String(data.lease_token), leaseExpiresAt: String(data.lease_expires_at), phase: "claimed" };
+        const active = {
+            taskId,
+            attemptId,
+            leaseToken: String(data.lease_token),
+            leaseExpiresAt: String(data.lease_expires_at),
+            phase: "claimed",
+            ...(extras?.driverId ? { driverId: extras.driverId } : {}),
+        };
         this.config.activeAttempts[taskId] = active;
-        await this.persist(this.config);
+        await this.persistRuntime(this.config);
         return { ...data, lease_token: "stored by Conduit Bridge" };
     }
     attempt(taskId) {
@@ -51,12 +72,15 @@ export class ConduitClient {
             else
                 Object.assign(active, { [key]: value });
         }
-        await this.persist(this.config);
+        await this.persistRuntime(this.config);
         return active;
     }
     async clearAttempt(taskId) {
+        const active = this.config.activeAttempts[taskId];
         delete this.config.activeAttempts[taskId];
-        await this.persist(this.config);
+        if (this.config.sessions)
+            delete this.config.sessions[taskId];
+        await this.removeAttempt(taskId, active?.attemptId);
     }
     /**
      * Ensure a project-scoped gateway fuel key for agent /v1 calls.
@@ -74,7 +98,7 @@ export class ConduitClient {
             gatewayKey = String(rotated.gateway_secret);
         }
         this.config.fuel = { ...this.config.fuel, [projectId]: { gatewayKey } };
-        await this.persist(this.config);
+        await this.persistPrefs(this.config);
         return gatewayKey;
     }
 }