@miraland-labs/conduit-bridge 0.16.24 → 0.16.26

package/README.md

@@ -2,7 +2,7 @@
 
 Local Bridge CLI for [Conduit](https://github.com/miralandlabs/conduit). Connects a computer to one organization, claims work, and drives a local agent.
 
-**Package version:** `0.16.21` — mutate_repo with `pr_create` opens a pull request even when `change_scope` is empty. `ops disconnect` now asks before it removes the runner service and clears credentials; pass `--yes` to skip the question. `ops.env` is enrollment/bootstrap defaults only: an explicit workspace does not inherit an old repository, and project switches do not rewrite global project state. `ops enroll` exchanges a single-use token, registers the machine, binds project affinity, provisions fuel keys, brings detected drivers online, and starts the runner in one command. On Linux, `ops install` refuses any effective systemd drop-in. A switch intent remains queued until the target runner heartbeat proves Bound. After every Bridge publish, operators must re-run `ops install` (LaunchAgent pins an absolute `cli.js`).
+**Package version:** `0.16.26` — local-fuel provider refusals make the affected lane unavailable instead of repeatedly spending attempts; an operator who changes the lane's account or plan can invalidate that observation with `ops quota-clear <driver>`. Bridge discovers bounded repository verification commands, including Make targets `test`, `check`, `verify`, `replay`, `typecheck`, `lint`, and `build`. `ops disconnect` asks before it removes the runner service and clears credentials; pass `--yes` to skip the question. `ops.env` is enrollment/bootstrap defaults only: an explicit workspace does not inherit an old repository, and project switches do not rewrite global project state. `ops enroll` exchanges a single-use token, registers the machine, binds project affinity, provisions fuel keys, brings detected drivers online, and starts the runner in one command. On Linux, `ops install` refuses any effective systemd drop-in. A switch intent remains queued until the target runner heartbeat proves Bound. After every Bridge publish, operators must re-run `ops install` (LaunchAgent pins an absolute `cli.js`).
 
 ## Prerequisites
 
@@ -48,6 +48,7 @@ Later:
 ```bash
 npx @miraland-labs/conduit-bridge@latest ops online cursor
 npx @miraland-labs/conduit-bridge@latest ops offline cursor
+npx @miraland-labs/conduit-bridge@latest ops quota-clear cursor  # after changing its account or plan
 npx @miraland-labs/conduit-bridge@latest ops disconnect   # then join again to change organizations
 ```
 
@@ -78,8 +79,12 @@ npx @miraland-labs/conduit-bridge disconnect --yes
 Before agent spend, Bridge checks that the workspace is readable, matches the expected repository,
 and is clean; each online driver must be installed, compatible with its configured fuel, and signed
 in when local fuel is used. The same bounded report is sent on heartbeat so Conduit can place an
-environment failure on Hold without consuming an execution attempt. Fix the named issue and let a
-fresh heartbeat land before choosing **Recheck** in Activity.
+environment failure on Hold without consuming an execution attempt. A local provider refusal is
+persisted and excludes only that lane; `online`/`offline` does not erase it. `ops doctor` proves CLI
+installation and authentication, not remaining vendor allowance. After deliberately changing an
+account or plan, run `ops quota-clear <driver>` to clear the old observation; this does not probe the
+provider, and the next real claim records another refusal if the new allowance is still unavailable.
+Fix the named issue and let a fresh heartbeat land before choosing **Recheck** in Activity.
 
 Conduit labels an exact driver/CLI version **Certified** only after two consecutive real canaries:
 repository delivery with PR/evidence and a successful rework cycle. All other lanes are

package/dist/brief.js

@@ -2,6 +2,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { isBoundedVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const MANIFESTS = [
     "package.json", "wrangler.jsonc", "wrangler.toml", "tsconfig.json",
@@ -10,6 +11,7 @@ const MANIFESTS = [
 ];
 /** Prefer test before typecheck/lint so discovery order matches what pickVerificationCommand wants. */
 const VERIFICATION_SCRIPTS = ["test", "verify", "typecheck", "lint", "build"];
+const MAKE_VERIFICATION_TARGETS = ["test", "check", "verify", "replay", "typecheck", "lint", "build"];
 const EXCLUDED_DIRECTORIES = new Set(["node_modules", "dist", "build", "target", "coverage", ".venv", "venv"]);
 export async function buildWorkspaceBrief(workspace) {
     const entries = await readdir(workspace, { withFileTypes: true });
@@ -197,8 +199,40 @@ async function gitDirectories(workspace) {
     }
 }
 /** Exported for tests — discovers bounded verification commands from workspace manifests. */
+/**
+ * Commands a project declares for itself, in `.conduit/verification` — one per line, `#` comments
+ * ignored.
+ *
+ * Discovery below recognises the conventional names (`test`, `check`, `npm run verify`, …). A project
+ * whose gate is named anything else had no way to say so, and an acceptance criterion naming that
+ * gate was unrunnable and therefore unverifiable — which is how four agent attempts died on a target
+ * that was declared in the very Makefile Bridge had already read.
+ *
+ * The file is repository content and therefore UNTRUSTED. Every line must pass the same shape check
+ * every discovered command passes, so a declaration can name a gate but can never smuggle a command:
+ * one tool, one identifier, no shell metacharacters. That check is the boundary, not the name — a
+ * recipe body was always repository-authored.
+ */
+const MAX_DECLARED_VERIFICATION = 8;
+export function parseDeclaredVerification(text) {
+    const declared = [];
+    for (const raw of text.split("\n")) {
+        const line = raw.split("#")[0].trim();
+        if (!line || !isBoundedVerificationCommand(line))
+            continue;
+        if (!declared.includes(line))
+            declared.push(line);
+        if (declared.length >= MAX_DECLARED_VERIFICATION)
+            break;
+    }
+    return declared;
+}
 export async function discoverVerificationCommands(workspace, files) {
     const commands = [];
+    try {
+        commands.push(...parseDeclaredVerification(await readFile(join(workspace, ".conduit", "verification"), "utf8")));
+    }
+    catch { /* no declaration, or unreadable: discovery below still applies */ }
     if (files.has("package.json")) {
         try {
             const manifest = JSON.parse(await readFile(join(workspace, "package.json"), "utf8"));
@@ -209,9 +243,10 @@ export async function discoverVerificationCommands(workspace, files) {
     if (files.has("Makefile")) {
         try {
             const makefile = await readFile(join(workspace, "Makefile"), "utf8");
-            for (const target of ["test", "check"])
+            for (const target of MAKE_VERIFICATION_TARGETS) {
                 if (new RegExp(`^${target}\\s*:`, "m").test(makefile))
                     commands.push(`make ${target}`);
+            }
         }
         catch { /* unreadable Makefiles do not broaden execution */ }
     }

package/dist/cli.js

@@ -8,7 +8,7 @@ import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { ConduitClient, ConduitRequestError } from "./client.js";
-import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearLocalConnection, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, saveConfigPrefs, savePendingConnection, suggestMachineName, } from "./config.js";
+import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearLocalConnection, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, saveConfigPrefs, saveDriverQuota, savePendingConnection, suggestMachineName, } from "./config.js";
 import { runMcp } from "./mcp.js";
 import { detectInstalledClients, localFuelOnlyClients, suggestFuelSource } from "./detect.js";
 import { DRIVERS } from "./driver.js";
@@ -382,7 +382,7 @@ async function initOps() {
     console.log(`Config file (separate): ${envPath}`);
     console.log("");
     console.log("Works the same on macOS, Linux, and Windows via:");
-    console.log(`  ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>")}`);
+    console.log(`  ${bridgeUsage("ops", "<connect|install|switch|online|offline|quota-clear|status|doctor|disconnect|uninstall>")}`);
     console.log("");
     console.log("1. Set enrollment/bootstrap defaults once:");
     console.log(`   Create folder: ${configDir}`);
@@ -401,12 +401,12 @@ async function initOps() {
         console.log("3. Install runner:");
         console.log(`   ${pathJoin(target, "install.sh")}`);
     }
-    console.log("Later: status · online · offline · disconnect (same names .sh / .cmd)");
+    console.log("Later: status · online · offline · quota-clear · disconnect (same names .sh / .cmd)");
 }
 async function opsCommand() {
     const verb = process.argv[3];
     if (!verb || !OPS_VERBS.includes(verb)) {
-        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")} (install also takes --workspace <path> [--repo <url>])`);
+        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|quota-clear|status|doctor|disconnect|uninstall>", "[driver…]")} (install also takes --workspace <path> [--repo <url>])`);
     }
     await runOps(verb, process.argv.slice(4));
 }
@@ -458,6 +458,23 @@ async function driversCommand() {
         console.log(`Now online: ${onlineDriverIds(config).join(", ") || "(none)"}`);
         return;
     }
+    if (sub === "quota") {
+        const action = process.argv[4]?.trim();
+        const id = process.argv[5]?.trim();
+        if (action !== "clear" || !id || process.argv[6]) {
+            throw new Error(`Usage: ${bridgeUsage("drivers", "quota", "clear", AGENT_PLACEHOLDER)}`);
+        }
+        if (!isSupportedDriverId(id))
+            throw new Error(`Unknown driver: ${id}. Available: ${Object.keys(DRIVERS).join(", ")}`);
+        if (!listDriverLanes(config).some((lane) => lane.id === id))
+            throw new Error(`Driver lane is not registered: ${id}`);
+        // A login or plan change happens outside Bridge, so only the operator can invalidate the last
+        // observed refusal. This intentionally does not toggle the lane or synthesize a successful probe:
+        // the next real claim is the proof, and will record another refusal if allowance is still spent.
+        await saveDriverQuota(id, undefined);
+        console.log(`Cleared recorded provider allowance refusal for ${id}. The next claim will recheck this lane.`);
+        return;
+    }
     if (sub === "fuel") {
         const id = process.argv[4]?.trim();
         const mode = process.argv[5];
@@ -470,7 +487,7 @@ async function driversCommand() {
         console.log(`${driverLabel(id)} lane fuel set to ${mode}`);
         return;
     }
-    throw new Error(`Usage: ${bridgeUsage("drivers", "[list|online|offline|fuel]", "…")}`);
+    throw new Error(`Usage: ${bridgeUsage("drivers", "[list|online|offline|fuel|quota]", "…")}`);
 }
 async function runner() {
     applyRunnerToolPath();

package/dist/client.js

@@ -80,6 +80,30 @@ export class ConduitClient {
         const active = this.attempt(taskId);
         return this.request(`/runner/v1/tasks/${taskId}/${action}`, { method: "POST", body: JSON.stringify({ ...body, attempt_id: active.attemptId, lease_token: active.leaseToken }) });
     }
+    async listInstructions(taskId, after = "") {
+        const active = this.attempt(taskId);
+        const query = new URLSearchParams({ attempt_id: active.attemptId, ...(after ? { after } : {}) });
+        const data = await this.request(`/runner/v1/tasks/${taskId}/instructions?${query}`);
+        return Array.isArray(data.instructions)
+            ? data.instructions.flatMap((row) => {
+                if (!row || typeof row !== "object")
+                    return [];
+                const instruction = row;
+                return typeof instruction.id === "string"
+                    && typeof instruction.payload_json === "string"
+                    && typeof instruction.created_at === "string"
+                    ? [{ id: instruction.id, payload_json: instruction.payload_json, created_at: instruction.created_at }]
+                    : [];
+            })
+            : [];
+    }
+    async acknowledgeInstruction(taskId, instructionId) {
+        const active = this.attempt(taskId);
+        await this.attemptRequest(taskId, `instructions/${instructionId}/ack`, {
+            instruction_id: instructionId,
+            idempotency_key: `bridge:instruction-ack:${active.attemptId}:${instructionId}`,
+        });
+    }
     async updateAttempt(taskId, patch) {
         const active = this.attempt(taskId);
         for (const key of Object.keys(patch)) {

package/dist/execution-class.js

@@ -5,7 +5,12 @@
 /** Bounded verification commands a `test_run` grant may execute. */
 export function isBoundedVerificationCommand(command) {
     // Exact forms only — a trailing `.*` on pytest would admit `pytest ; curl … | sh`.
-    return /^(npm run (verify|typecheck|lint|test|build)|pnpm (verify|typecheck|lint|test|build)|yarn (verify|typecheck|lint|test|build)|cargo (test|check)|go test(?: \.\/\.\.\.)?|make (test|check)|python -m pytest|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command);
+    // A target or script NAME is not a trust boundary: `make check` already runs whatever recipe the
+    // repository authored, so restricting the name to check/test grants no safety — it only stops a
+    // project from naming its own gate, which is what forced four attempts to die on a command they
+    // could not run. The boundary that matters is the SHAPE: one tool, one identifier, no shell
+    // metacharacters, so nothing can be smuggled in through the name.
+    return /^(npm run [A-Za-z0-9][A-Za-z0-9._:-]*|pnpm [A-Za-z0-9][A-Za-z0-9._:-]*|yarn [A-Za-z0-9][A-Za-z0-9._:-]*|cargo (test|check)|go test(?: \.\/\.\.\.)?|make [A-Za-z0-9][A-Za-z0-9._-]*|python -m pytest|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command);
 }
 /** Shell commands each grant authorizes — mapped per driver so they cannot drift. */
 export const branchCreateCommands = [
@@ -76,7 +81,9 @@ export function executionClassPromptRules(input) {
     const artifact = executionClass === "publish_artifact";
     const rules = [];
     const grantShell = [
-        ...(grants.includes("test_run") ? verificationCommands.filter(isBoundedVerificationCommand) : []),
+        ...(grants.includes("test_run")
+            ? verificationCommands.filter((command) => isBoundedVerificationCommand(command) && !deniedCommands.includes(command))
+            : []),
         ...(grants.includes("branch_create") ? branchCreateCommands : []),
         ...(grants.includes("pr_create") ? prCreateCommands : []),
     ];

package/dist/execution.js

@@ -79,7 +79,7 @@ export function forgeTransportFailure(message) {
  * costs an evening. Deliberately narrow — an unmatched refusal degrades to an ordinary agent
  * failure, which is exactly today's behaviour.
  */
-export const SUBSCRIPTION_EXHAUSTED_PATTERN = /\b(?:usage|rate)[ _-]?limit(?:ed|s)?\b|\bquota (?:exceeded|exhausted|reached)\b|\b(?:http|status|code)\W{0,3}429\b|\b429\b(?=\W{0,3}too many)|too many requests|out of (?:credits|usage)/i;
+export const SUBSCRIPTION_EXHAUSTED_PATTERN = /\b(?:usage|rate|session)[ _-]?limit(?:ed|s)?\b|\b(?:daily|weekly|monthly) limit\b|\bquota (?:exceeded|exhausted|reached)\b|\b(?:http|status|code)\W{0,3}429\b|\b429\b(?=\W{0,3}too many)|too many requests|out of (?:credits|usage)/i;
 /**
  * Does this failure mean the plan is spent, rather than the prompt being wrong?
  *
@@ -411,6 +411,79 @@ export async function renewLeases(client, config) {
         }
     }
 }
+/**
+ * Poll while the headless CLI owns the worktree, then hand owner guidance to its next session turn.
+ * Driver stdin is intentionally closed after the initial prompt, so pretending a mid-process write
+ * is portable would silently lose guidance on most lanes. The first safe common checkpoint is the
+ * driver's completed turn, before Bridge validates or submits its delivery.
+ */
+function pollCheckpointInstructions(client, taskId, state, intervalMs = 15_000) {
+    let stopped = false;
+    let inFlight = null;
+    const pending = new Map();
+    const poll = async () => {
+        const rows = await client.listInstructions(taskId, state.cursor);
+        for (const row of rows) {
+            state.cursor = `${row.created_at}|${row.id}`;
+            if (state.seen.has(row.id))
+                continue;
+            state.seen.add(row.id);
+            const parsed = parseCheckpointInstruction(row);
+            if (parsed && state.acceptedCount < 10 && state.acceptedCharacters + parsed.message.length <= 40_000) {
+                pending.set(parsed.id, parsed);
+                state.acceptedCount += 1;
+                state.acceptedCharacters += parsed.message.length;
+            }
+            else if (parsed) {
+                console.error(`Instruction ${parsed.id} exceeded the checkpoint guidance bound and was not acknowledged.`);
+            }
+        }
+    };
+    const runPoll = () => {
+        if (stopped || inFlight)
+            return;
+        inFlight = poll()
+            .catch((error) => console.error(`Instruction poll failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`))
+            .finally(() => { inFlight = null; });
+    };
+    runPoll();
+    const timer = setInterval(runPoll, intervalMs);
+    timer.unref?.();
+    return {
+        stop: async () => {
+            stopped = true;
+            clearInterval(timer);
+            await inFlight;
+            await poll().catch((error) => console.error(`Final instruction poll failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+            return [...pending.values()];
+        },
+    };
+}
+function parseCheckpointInstruction(row) {
+    try {
+        const payload = JSON.parse(row.payload_json);
+        if (payload.changes_scope === true) {
+            console.error(`Refusing scope-changing instruction ${row.id}; revise the approved initiative contract instead.`);
+            return null;
+        }
+        const message = typeof payload.message === "string" ? payload.message.trim() : "";
+        return message ? { id: row.id, message: message.slice(0, 20_000), createdAt: row.created_at } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function checkpointInstructionPrompt(instructions) {
+    return [
+        "OWNER INSTRUCTIONS AT CHECKPOINT",
+        "These messages refine the current run only. They do not amend approved scope, boundaries, acceptance criteria, or grants.",
+        ...instructions.map((instruction) => `- ${instruction.message}`),
+        "",
+        "Apply the guidance within the approved contract, re-check the resulting work, then return a complete final report.",
+        "Return only one fenced ```json object with exactly this shape:",
+        agentReportTemplate,
+    ].join("\n");
+}
 function resolveAttemptDriver(config, active, fallback) {
     if (active.driverId && DRIVERS[active.driverId])
         return DRIVERS[active.driverId];
@@ -983,7 +1056,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         // turn already "finished" makes the agent reply conversationally without the report block.
         const resumeSessionId = options.forceResumeSessionId
             ?? (reworkFeedback && task.repair_mode !== "briefed" ? config.sessions?.[taskId] : undefined);
-        const result = await driver.run({
+        const runInput = {
             prompt,
             workspace: attemptWorkspace,
             grants,
@@ -997,7 +1070,40 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             model: selection.model,
             fuel,
             fuelSource,
-        });
+        };
+        let result;
+        let currentRunInput = runInput;
+        const instructionPollState = {
+            cursor: "",
+            seen: new Set(),
+            acceptedCount: 0,
+            acceptedCharacters: 0,
+        };
+        let instructionsInPrompt = [];
+        for (let round = 0;; round += 1) {
+            const instructionPoll = diagnosis ? null : pollCheckpointInstructions(client, taskId, instructionPollState);
+            let polled = [];
+            try {
+                result = await driver.run(currentRunInput);
+            }
+            finally {
+                polled = await instructionPoll?.stop() ?? polled;
+            }
+            if (instructionsInPrompt.length > 0) {
+                await Promise.all(instructionsInPrompt.map((instruction) => client.acknowledgeInstruction(taskId, instruction.id).catch((error) => console.error(`Instruction acknowledgement failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`))));
+            }
+            // One initial turn plus at most two bounded checkpoint turns. Guidance arriving after that
+            // remains unacknowledged rather than creating an unbounded owner-driven agent loop.
+            if (diagnosis || result.status !== "completed" || polled.length === 0 || round >= 2)
+                break;
+            instructionsInPrompt = polled;
+            const followup = checkpointInstructionPrompt(instructionsInPrompt);
+            currentRunInput = {
+                ...runInput,
+                prompt: result.sessionId ? followup : `${prompt}\n\n${followup}`,
+                resumeSessionId: result.sessionId ?? undefined,
+            };
+        }
         if (result.sessionId)
             config.sessions = { ...config.sessions, [taskId]: result.sessionId };
         await learnDriverFuel(config, driver.name, fuelSource, result);
@@ -1052,7 +1158,10 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             // reason", leaving Conductor nothing to diagnose. Re-run the project's bounded verification
             // in the attempt worktree to recover the real errors. Best-effort: keep the agent's own
             // message when there is no command, the command cannot run, or the tree actually verifies.
-            const verificationDetail = grants.includes("test_run")
+            // A vendor allowance refusal is already a precise environment diagnosis. Running repository
+            // verification after it can surface an unrelated pre-existing failure and overwrite the lane
+            // Hold with a false source-repair brief.
+            const verificationDetail = grants.includes("test_run") && !subscriptionExhausted(agentMessage)
                 ? await captureVerificationFailure({
                     workspace: attemptWorkspace,
                     verificationCommands: attemptBrief?.verification ?? [],

package/dist/ops.js

@@ -19,7 +19,7 @@ import { applyRunnerToolPath, readActiveRunnerServiceWorkspace, readStoredRunner
 import { bridgeVersion } from "./version.js";
 import { bootstrapManagedWorkspace } from "./workspace-bootstrap.js";
 export const OPS_VERBS = [
-    "connect", "enroll", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
+    "connect", "enroll", "install", "switch", "online", "offline", "quota-clear", "status", "doctor", "disconnect", "uninstall",
 ];
 const LOCAL_FUEL_DRIVERS = new Set(["cursor", "pi", "kiro", "antigravity", "grok"]);
 /**
@@ -343,12 +343,18 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log(`- ${describePreflightIssue(issue)}`);
         throw new Error("Fix the preflight issues before retrying Conduit work");
     }
-    // Lane toggles only need Bridge config + optional driver ids — not a full ops.env.
+    // Lane controls only need Bridge config + optional driver ids — not a full ops.env.
     if (verb === "online" || verb === "offline") {
         const drivers = await resolveDrivers(env, argv);
         runBridge(["drivers", verb, ...drivers]);
         return;
     }
+    if (verb === "quota-clear") {
+        if (argv.length !== 1)
+            throw new Error("Usage: ops quota-clear <driver>");
+        runBridge(["drivers", "quota", "clear", argv[0]]);
+        return;
+    }
     // Explicit install arguments are active-run inputs, not machine-wide defaults. Enrollment may
     // seed ops.env once; later project changes must not mutate it.
     let installEnv = env;

package/dist/workspace-bootstrap.js

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 function defaultRunner(command, args, workspace) {
     const result = spawnSync(command, args, {
@@ -10,17 +10,64 @@ function defaultRunner(command, args, workspace) {
     });
     return { status: result.status, ...(result.error ? { error: result.error } : {}) };
 }
-/** Install locked JavaScript dependencies before a Conduit-managed checkout advertises readiness. */
+/** Install dependencies with the repository's own committed package-manager identity. */
 export function bootstrapManagedWorkspace(workspace, run = defaultRunner) {
-    if (!existsSync(join(workspace, "package.json")))
+    const packagePath = join(workspace, "package.json");
+    if (!existsSync(packagePath))
         return "not_applicable";
-    if (!existsSync(join(workspace, "package-lock.json"))) {
-        throw new Error("managed_workspace_bootstrap_package_lock_required");
-    }
-    const result = run("npm", ["ci", "--include=optional", "--no-audit", "--no-fund"], workspace);
+    const install = lockedInstall(workspace, packagePath);
+    const result = run(install.command, install.args, workspace);
     if (result.error)
-        throw new Error(`managed_workspace_bootstrap_failed:${result.error.message}`);
+        throw new Error(`managed_workspace_bootstrap_failed:${install.id}:${result.error.message}`);
     if (result.status !== 0)
-        throw new Error(`managed_workspace_bootstrap_failed:exit_${result.status ?? "unknown"}`);
+        throw new Error(`managed_workspace_bootstrap_failed:${install.id}:exit_${result.status ?? "unknown"}`);
     return "installed";
 }
+function lockedInstall(workspace, packagePath) {
+    const declared = declaredPackageManager(packagePath);
+    const managers = [
+        existsSync(join(workspace, "package-lock.json")) || existsSync(join(workspace, "npm-shrinkwrap.json")) ? "npm" : null,
+        existsSync(join(workspace, "pnpm-lock.yaml")) ? "pnpm" : null,
+        existsSync(join(workspace, "yarn.lock")) ? "yarn" : null,
+        existsSync(join(workspace, "bun.lock")) || existsSync(join(workspace, "bun.lockb")) ? "bun" : null,
+    ].filter((manager) => manager !== null);
+    if (managers.length === 0)
+        throw new Error("managed_workspace_bootstrap_lockfile_required");
+    if (declared && !managers.includes(declared)) {
+        throw new Error(`managed_workspace_bootstrap_package_manager_lockfile_mismatch:${declared}:${managers.join(",")}`);
+    }
+    const selected = declared ?? (managers.length === 1 ? managers[0] : null);
+    if (!selected)
+        throw new Error(`managed_workspace_bootstrap_lockfile_ambiguous:${managers.join(",")}`);
+    if (selected === "npm")
+        return { id: selected, command: "npm", args: ["ci", "--include=optional", "--no-audit", "--no-fund"] };
+    if (selected === "pnpm")
+        return { id: selected, command: "pnpm", args: ["install", "--frozen-lockfile"] };
+    if (selected === "bun")
+        return { id: selected, command: "bun", args: ["install", "--frozen-lockfile"] };
+    const modernYarn = existsSync(join(workspace, ".yarnrc.yml")) || declaredPackageManagerMajor(packagePath, "yarn") >= 2;
+    return { id: selected, command: "yarn", args: ["install", modernYarn ? "--immutable" : "--frozen-lockfile"] };
+}
+function declaredPackageManager(packagePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+        const match = typeof parsed.packageManager === "string" ? /^(npm|pnpm|yarn|bun)@/.exec(parsed.packageManager.trim()) : null;
+        const id = match?.[1];
+        return id === "npm" || id === "pnpm" || id === "yarn" || id === "bun" ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+function declaredPackageManagerMajor(packagePath, manager) {
+    try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+        const match = typeof parsed.packageManager === "string"
+            ? new RegExp(`^${manager}@(\\d+)`).exec(parsed.packageManager.trim())
+            : null;
+        return match ? Number(match[1]) : 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/package.json

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