@miraland-labs/conduit-bridge 0.16.14 → 0.16.16

package/dist/checkout.js

@@ -34,6 +34,18 @@ async function gitOriginUrl(workspace, exec) {
         return null;
     }
 }
+/** A control-plane repository fingerprint needs a transport before Git can clone it. */
+function cloneRepositoryUrl(repositoryUrl) {
+    const value = repositoryUrl.trim();
+    const slash = value.indexOf("/");
+    if (slash <= 0 || value.startsWith(".") || value.includes("\\") || /^[^/@\s]+@[^:]+:/.test(value))
+        return value;
+    const host = value.slice(0, slash);
+    const path = value.slice(slash + 1);
+    if (!host.includes(".") || /\s/.test(value) || path.split("/").filter(Boolean).length < 2)
+        return value;
+    return `https://${value}`;
+}
 /**
  * Ensure `workspace` is a checkout of `repositoryUrl`.
  *
@@ -49,11 +61,12 @@ export async function ensureCheckout(workspace, repositoryUrl, deps = {}) {
     const wanted = normalizeRepositoryUrl(repositoryUrl);
     if (!wanted)
         throw new Error("ensure_checkout_invalid_url");
+    const cloneUrl = cloneRepositoryUrl(repositoryUrl);
     const exists = await pathExists(workspace, accessFn);
     if (!exists) {
         await mkdirFn(dirname(workspace), { recursive: true });
         try {
-            await exec("git", ["clone", "--", repositoryUrl, workspace], {
+            await exec("git", ["clone", "--", cloneUrl, workspace], {
                 timeout: 300_000,
                 maxBuffer: 2_000_000,
             });
@@ -73,7 +86,7 @@ export async function ensureCheckout(workspace, repositoryUrl, deps = {}) {
         throw new Error("ensure_checkout_path_unreadable");
     if (entries.length === 0) {
         try {
-            await exec("git", ["clone", "--", repositoryUrl, workspace], {
+            await exec("git", ["clone", "--", cloneUrl, workspace], {
                 timeout: 300_000,
                 maxBuffer: 2_000_000,
             });

package/dist/config.js

@@ -85,12 +85,27 @@ export async function loadConfigIfPresent() {
                 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 };
+            // Every field a lane carries must be listed here. This sanitizer duplicates the shape check in
+            // `normalizeDrivers` (drivers.ts) — importing it would close the loop config → drivers → driver
+            // → config — so a new lane field has to be added in both, and forgetting here is silent: the
+            // value survives in memory, then vanishes on the next load. `quota` was lost exactly that way.
+            const quota = plainQuota(lane.quota);
+            cleaned[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}) };
         }
         config.drivers = cleaned;
     }
     return config;
 }
+/** A stored quota record, or nothing. Malformed is dropped rather than thrown — see normalizeQuota. */
+function plainQuota(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    if (typeof raw.exhausted !== "boolean" || typeof raw.observed_at !== "string")
+        return undefined;
+    if (raw.resets_at !== null && typeof raw.resets_at !== "string")
+        return undefined;
+    return { exhausted: raw.exhausted, resets_at: raw.resets_at, observed_at: raw.observed_at };
+}
 async function loadRuntime() {
     try {
         const raw = JSON.parse(await readFile(runtimePath, "utf8"));
@@ -169,6 +184,22 @@ export function mergeRuntimeState(disk, snapshot) {
         tombstones: Object.keys(tombstones).length ? tombstones : undefined,
     };
 }
+/**
+ * Quota is runner-learned state, not an operator preference. A prefs writer may have loaded its
+ * snapshot before another process recorded or cleared quota, so disk is authoritative for that one
+ * field. Lane presence and every operator-owned lane setting still come from the writer's snapshot.
+ */
+function mergeCurrentDriverQuota(disk, snapshot) {
+    if (!snapshot || !disk)
+        return snapshot;
+    const drivers = {};
+    for (const [id, lane] of Object.entries(snapshot)) {
+        const { quota: _staleQuota, ...prefs } = lane;
+        const quota = plainQuota(disk.drivers?.[id]?.quota);
+        drivers[id] = { ...prefs, ...(quota ? { quota } : {}) };
+    }
+    return drivers;
+}
 /**
  * Persist Bridge config. Operator prefs and runtime attempt state are written as separate files under
  * a cross-process lock so `drivers online|offline` cannot erase an in-flight claim (and vice versa).
@@ -178,26 +209,25 @@ export async function saveConfig(config, options = {}) {
     const run = async () => {
         await withConfigLock(async () => {
             await mkdir(directory, { recursive: true, mode: 0o700 });
+            let diskPrefs = null;
+            try {
+                diskPrefs = JSON.parse(await readFile(path, "utf8"));
+            }
+            catch { /* no prior config */ }
             // One-time migrate: if runtime.json is missing, preserve legacy activeAttempts from config.json.
             const existingRuntime = await loadRuntime();
-            if (!existingRuntime) {
-                let legacyAttempts = {};
-                let legacySessions;
-                try {
-                    const legacy = JSON.parse(await readFile(path, "utf8"));
-                    if (legacy.activeAttempts && typeof legacy.activeAttempts === "object") {
-                        legacyAttempts = legacy.activeAttempts;
-                    }
-                    if (legacy.sessions && typeof legacy.sessions === "object") {
-                        legacySessions = legacy.sessions;
-                    }
-                }
-                catch { /* no prior config */ }
+            if (!existingRuntime && diskPrefs) {
+                const legacyAttempts = diskPrefs.activeAttempts && typeof diskPrefs.activeAttempts === "object"
+                    ? diskPrefs.activeAttempts
+                    : {};
+                const legacySessions = diskPrefs.sessions && typeof diskPrefs.sessions === "object"
+                    ? diskPrefs.sessions
+                    : undefined;
                 if (Object.keys(legacyAttempts).length || legacySessions) {
                     await writeJsonAtomic(runtimePath, { activeAttempts: legacyAttempts, sessions: legacySessions });
                 }
             }
-            const prefs = { ...snapshot };
+            const prefs = { ...snapshot, drivers: mergeCurrentDriverQuota(diskPrefs, snapshot.drivers) };
             delete prefs.activeAttempts;
             delete prefs.sessions;
             const prefsForDisk = { ...prefs, activeAttempts: {}, sessions: undefined };
@@ -219,6 +249,42 @@ export async function saveConfig(config, options = {}) {
 export async function saveConfigPrefs(config) {
     await saveConfig(config, { prefsOnly: true });
 }
+/**
+ * Write one lane's observed quota without touching anything else on disk.
+ *
+ * A run can outlive the config it started with: the operator may take a lane offline, or change its
+ * fuel, while an agent is still working. Persisting the runner's whole in-memory snapshot at the end
+ * of that run would put the operator's change back the way it was — a `drivers offline` silently
+ * undone minutes later by an unrelated write. So this reads the current prefs under the same lock
+ * every other writer uses, edits only `drivers[id].quota`, and writes back.
+ *
+ * A lane the operator has since removed is left removed: quota describes a lane, and is worth
+ * nothing without one.
+ */
+export async function saveDriverQuota(driverId, quota) {
+    const run = async () => {
+        await withConfigLock(async () => {
+            let prefs;
+            try {
+                prefs = JSON.parse(await readFile(path, "utf8"));
+            }
+            catch {
+                return; // No prefs on disk yet: nothing to attach a quota to.
+            }
+            const lane = prefs.drivers?.[driverId];
+            if (!lane || typeof lane !== "object")
+                return;
+            if (quota)
+                lane.quota = quota;
+            else
+                delete lane.quota;
+            await writeJsonAtomic(path, { ...prefs, activeAttempts: {}, sessions: undefined });
+        });
+    };
+    const next = saveChain.then(run, run);
+    saveChain = next.catch(() => undefined);
+    await next;
+}
 /**
  * Claim/session write that leaves prefs untouched and merges with on-disk attempts from other
  * Bridge processes (supervisor vs MCP) instead of replacing the whole runtime snapshot.

package/dist/drivers.js

@@ -54,10 +54,67 @@ export function normalizeDrivers(raw) {
             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 };
+        const quota = normalizeQuota(lane.quota);
+        out[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}) };
     }
     return out;
 }
+/** Drop a malformed quota rather than fail the whole config: a bad record must not dark a lane. */
+function normalizeQuota(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const value = raw;
+    if (typeof value.exhausted !== "boolean" || typeof value.observed_at !== "string")
+        return undefined;
+    const resetsAt = typeof value.resets_at === "string" ? value.resets_at : null;
+    return { exhausted: value.exhausted, resets_at: resetsAt, observed_at: value.observed_at };
+}
+/**
+ * This lane's quota as of now, with a passed reset retired.
+ *
+ * The stored record says only what the vendor refused and when it said the window would refill.
+ * Deciding `exhausted` here rather than at write time is what keeps a refilled lane from staying
+ * dark until something happens to run on it — and it self-corrects a stale record, which matters
+ * because the preflight the control plane reads may be minutes old.
+ */
+export function laneQuota(config, driverId, now = Date.now()) {
+    const quota = normalizeDrivers(config.drivers)[driverId]?.quota;
+    if (!quota)
+        return null;
+    if (!quota.exhausted)
+        return quota;
+    const resets = quota.resets_at ? Date.parse(quota.resets_at) : Number.NaN;
+    if (Number.isFinite(resets) && resets <= now)
+        return { ...quota, exhausted: false };
+    // A refusal that named no reset time cannot expire on its own, and a lane held out of
+    // pickDriverForClaim can never run the work that would prove it well again. That is a deadlock
+    // one misread error message away, so an unreset claim is only believed for so long: after the
+    // longest window a vendor plausibly enforces, let the lane try and be refused again if it truly
+    // is spent. Costs one attempt to recover; costs the whole machine not to.
+    const observed = Date.parse(quota.observed_at);
+    if (!quota.resets_at && Number.isFinite(observed) && now - observed > UNRESET_QUOTA_TRUST_MS) {
+        return { ...quota, exhausted: false };
+    }
+    return quota;
+}
+/** How long a refusal with no stated reset is trusted. A week covers the longest plan windows. */
+const UNRESET_QUOTA_TRUST_MS = 7 * 24 * 60 * 60_000;
+/** True when this lane is not currently refused by its vendor. Lanes without a record are free. */
+export function driverFuelAvailable(config, driverId, now = Date.now()) {
+    if (resolveDriverFuel(config, driverId) !== "local")
+        return true;
+    return laneQuota(config, driverId, now)?.exhausted !== true;
+}
+/** Record (or clear) what the vendor said about this lane's window. */
+export function recordDriverQuota(config, driverId, quota) {
+    if (!isSupportedDriverId(driverId))
+        return config;
+    const drivers = normalizeDrivers(config.drivers);
+    const lane = drivers[driverId] ?? (localFuelOnlyDriver(driverId) ? { state: "offline", fuel: "local" } : { state: "offline" });
+    const { quota: _dropped, ...rest } = lane;
+    drivers[driverId] = quota ? { ...rest, quota } : rest;
+    return { ...config, drivers };
+}
 /**
  * Ensure detected (or listed) drivers exist in config. New lanes default offline (fail-closed).
  * Does not flip existing online/offline state.
@@ -160,12 +217,18 @@ export function driversHeartbeatReport(config, activeAttempts, processOnlineIds)
 /**
  * Pick an online driver for a new claim: least loaded among online (shared machine pool).
  * `processOnlineIds` overrides config online lanes (tests / harness).
+ *
+ * A lane whose subscription window is spent is excluded here rather than at each call site: there
+ * are five, and one forgotten would hand work to a lane whose vendor is refusing it — spending an
+ * attempt to relearn what the last refusal already told us. Every lane dry returns null, the same
+ * answer as no lane online, which the callers already handle.
  */
 export function pickDriverForClaim(config, processOnlineIds, eligible = () => true) {
     const candidates = processOnlineIds === undefined || processOnlineIds === null
         ? onlineDriverIds(config)
         : processOnlineIds;
     const online = candidates
+        .filter((id) => driverFuelAvailable(config, id))
         .filter((id) => isSupportedDriverId(id))
         .filter(eligible);
     if (!online.length)

package/dist/execution.js

@@ -2,10 +2,10 @@ import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ConduitRequestError } from "./client.js";
-import { redactSecrets } from "./config.js";
+import { redactSecrets, saveDriverQuota } from "./config.js";
 import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, requireStampedExecutionClass, tierForRisk } from "./driver.js";
 import { assertClassFloor } from "./execution-class.js";
-import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
+import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -68,6 +68,91 @@ export const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in
 export function forgeTransportFailure(message) {
     return FORGE_TRANSPORT_PATTERN.test(message);
 }
+/**
+ * A vendor refusing a local-fuel run because the operator's subscription window is spent.
+ *
+ * Distinct from `driver_not_authenticated`: the login is fine, the allowance is not. Conflating the
+ * two sends the owner to re-authenticate a CLI that is already signed in, which fixes nothing and
+ * 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;
+/**
+ * Does this failure mean the plan is spent, rather than the prompt being wrong?
+ *
+ * The distinction that matters is a context or output cap: the model refusing *this prompt* is not
+ * the plan refusing *this month*, and darking a lane for it is the worst outcome available — a
+ * refusal that carried no reset keeps the lane out of `pickDriverForClaim`, so nothing runs on it,
+ * so nothing can prove it well again until the trust window ages out.
+ *
+ * That is handled by requiring an explicit refusal phrase above rather than by vetoing "limit"
+ * separately. An earlier veto pass did both and made a concatenated error ("context limit exceeded;
+ * fallback failed: HTTP 429") read as healthy — hiding a genuine refusal behind an unrelated
+ * sentence in the same string.
+ */
+export function subscriptionExhausted(message) {
+    return SUBSCRIPTION_EXHAUSTED_PATTERN.test(message);
+}
+/**
+ * When the window refills, if the vendor said so.
+ *
+ * Vendors phrase this as an absolute clock time ("resets at 3pm"), a duration ("try again in 2h
+ * 14m"), or a Unix epoch. Returning null when none matches is fine — `laneQuota` treats a record
+ * without a reset as exhausted until something proves otherwise, and the next successful run clears
+ * it. Guessing a reset time would be worse: an invented one un-darks the lane early and the owner
+ * watches the same refusal twice.
+ */
+export function parseQuotaResetAt(message, now = Date.now()) {
+    const epoch = /\bresets?[ _-]?(?:at|in)?\b\D{0,12}(\d{10})\b/i.exec(message);
+    if (epoch)
+        return plausibleReset(Number(epoch[1]) * 1000, now);
+    // Units must end where they claim to. Unanchored, `m` swallowed the "m" of "500ms" and of
+    // "2 months" and read both as minutes — turning a 500-millisecond backoff into an eight-hour
+    // blackout of the only local lane.
+    const duration = /\b(?:try again|retry|resets?|available again)\b[^.\n]{0,24}?\bin\b\s*(?:(\d+)\s*(?:h|hrs?|hours?)\b(?!\w))?\s*(?:(\d+)\s*(?:m|mins?|minutes?)\b(?!\w))?\s*(?:(\d+)\s*(?:s|secs?|seconds?)\b(?!\w))?\s*(?:(\d+)\s*(?:ms|msecs?|milliseconds?)\b(?!\w))?/i.exec(message);
+    if (duration && (duration[1] || duration[2] || duration[3] || duration[4])) {
+        const ms = (Number(duration[1] ?? 0) * 3_600 + Number(duration[2] ?? 0) * 60 + Number(duration[3] ?? 0)) * 1_000
+            + Number(duration[4] ?? 0);
+        if (ms > 0)
+            return plausibleReset(now + ms, now);
+    }
+    const iso = /\bresets?\b[^.\n]{0,24}?(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)/i.exec(message);
+    if (iso)
+        return plausibleReset(Date.parse(iso[1]), now);
+    return null;
+}
+/**
+ * A reset time worth believing, or none at all.
+ *
+ * Two failure modes this closes. A number lifted from prose is not always a clock — a request id
+ * that happens to be ten digits reads as a date in 2286 and would dark the lane for centuries. And
+ * `new Date(x).toISOString()` *throws* on a non-finite or out-of-range value, which here would
+ * escape between the driver returning and `queueTerminal`, stranding the attempt in `agent_running`.
+ * Anything outside a plausible billing window is treated as "no reset stated", which is the honest
+ * answer and already a supported state.
+ */
+function plausibleReset(ms, now) {
+    if (!Number.isFinite(ms))
+        return null;
+    if (ms > now + MAX_PLAUSIBLE_RESET_MS)
+        return null;
+    // A reset that has just passed is kept, not discarded. Rejecting it returned null, which does not
+    // mean "already refilled" — it means "no reset stated", the one case trusted for a whole week. A
+    // second of clock skew or a slow stderr flush would then dark the lane for seven days instead of
+    // clearing it at once. Keeping the stale timestamp lets `laneQuota` retire it on the next read.
+    if (ms < now - MAX_STALE_RESET_MS)
+        return null;
+    try {
+        return new Date(ms).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+/** No vendor window runs longer than a month; past that the parse was a coincidence, not a clock. */
+const MAX_PLAUSIBLE_RESET_MS = 31 * 24 * 3_600_000;
+/** How far back a reset may sit and still be a real one the run simply outlived. */
+const MAX_STALE_RESET_MS = 24 * 3_600_000;
 /** Environment faults that must Hold — mirror CP ENVIRONMENT_FAILURES message patterns. */
 const FINALIZE_ENVIRONMENT_PATTERN = /base[_ ]not[_ ]ancestor|required base commit is not available|source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace|workspace[_ ]head[_ ]changed|workspace[_ ]repository|workspace[_ ]unavailable|driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required|no[_ ]online[_ ]driver|bridge[_ ]preflight|stale bridge|bridge version/i;
 /** Delivery-report / grant / evidence contract defects (non-retryable rework). */
@@ -87,6 +172,49 @@ export function classifyFinalizeFailure(message) {
     // Distinct from execution_contract_failed so owners see a Bridge fault, not a contract lie.
     return { retryable: false, error: `Bridge finalize interrupted: ${message}` };
 }
+/**
+ * Learn this lane's fuel state from what the run just did.
+ *
+ * A refusal records the window; any completed run clears it, because finishing work is proof the
+ * allowance is back — stronger evidence than a reset time the vendor may never have given. Only
+ * local fuel is tracked: a `conduit`-fuelled lane spends the organization's gateway credential,
+ * whose ceiling is the project budget, not a personal window.
+ */
+/**
+ * Observe this run's fuel signal and write it down.
+ *
+ * Persisting is not optional. The runner reloads `config.drivers` from disk every cycle so lane
+ * toggles apply without a restart, so a record kept only in memory is erased within seconds and the
+ * lane takes work again as if nothing happened — the feature looks like it works and does not.
+ *
+ * Every agent run goes through here, not just the first. A repair turn or a land continuation is
+ * often the request that actually crosses the limit, and an attempt that fails there would otherwise
+ * leave the lane eligible.
+ */
+export async function learnDriverFuel(config, driverId, fuelSource, result) {
+    const drivers = observeDriverFuel(config, driverId, fuelSource, result).drivers;
+    if (JSON.stringify(drivers ?? {}) === JSON.stringify(config.drivers ?? {}))
+        return;
+    config.drivers = drivers;
+    // Only this lane's quota reaches disk. Writing the whole snapshot would carry the rest of a config
+    // that may be minutes stale back over the operator's newer choices — see saveDriverQuota.
+    // A fuel record is worth less than the run it came from: never let a disk fault fail the attempt.
+    await saveDriverQuota(driverId, drivers?.[driverId]?.quota).catch(() => undefined);
+}
+export function observeDriverFuel(config, driverId, fuelSource, result, now = Date.now()) {
+    if (fuelSource !== "local")
+        return config;
+    if (result.status !== "failed")
+        return recordDriverQuota(config, driverId, null);
+    const message = result.error ?? "";
+    if (!subscriptionExhausted(message))
+        return config;
+    return recordDriverQuota(config, driverId, {
+        exhausted: true,
+        resets_at: parseQuotaResetAt(message, now),
+        observed_at: new Date(now).toISOString(),
+    });
+}
 /** Failures that require an operator/configuration change must never burn the remaining attempts. */
 export function retryableAgentFailure(message) {
     // `cannot enforce` is a driver projection refusing a class it structurally cannot bound (Pi and
@@ -115,6 +243,7 @@ const taskDetailSchema = z.object({
     execution_mode: z.enum(["agent", "human"]).optional().default("agent"),
     execution_kind: z.enum(["authoring", "diagnosis"]).optional().default("authoring"),
     source_attempt_id: z.string().uuid().nullable().optional().default(null),
+    repair_mode: z.enum(["none", "briefed", "blind"]).optional().default("none"),
 });
 const taskSpecSchema = z.object({
     goal: z.string().optional(), scope: z.array(z.string()).optional(), boundaries: z.array(z.string()).optional(),
@@ -824,7 +953,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         // A fresh attempt after a failed delivery must start clean: resuming a session whose last
         // turn already "finished" makes the agent reply conversationally without the report block.
         const resumeSessionId = options.forceResumeSessionId
-            ?? (reworkFeedback ? config.sessions?.[taskId] : undefined);
+            ?? (reworkFeedback && task.repair_mode !== "briefed" ? config.sessions?.[taskId] : undefined);
         const result = await driver.run({
             prompt,
             workspace: attemptWorkspace,
@@ -842,6 +971,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         });
         if (result.sessionId)
             config.sessions = { ...config.sessions, [taskId]: result.sessionId };
+        await learnDriverFuel(config, driver.name, fuelSource, result);
         if (diagnosis) {
             if (result.status === "failed") {
                 const message = result.error ?? "Read-only diagnosis failed";
@@ -938,6 +1068,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             agentReply: reportText,
         })) {
             const continuation = await runLandContinuationTurn({
+                config,
                 client,
                 taskId,
                 attemptId: active.attemptId,
@@ -973,6 +1104,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             if (requiresLandCommit({ grants, spec }) && gitEmpty && claimsWork) {
                 if (!landContinuationUsed) {
                     const continuation = await runLandContinuationTurn({
+                        config,
                         client,
                         taskId,
                         attemptId: active.attemptId,
@@ -1072,6 +1204,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                         console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
                         return;
                     }
+                    await learnDriverFuel(config, driver.name, fuelSource, repaired);
                     if (repaired.sessionId) {
                         config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
                         resumeSessionId = repaired.sessionId;
@@ -1133,6 +1266,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             && reportClaimsRepositoryWork(report)
             && await isLandTreeEmpty({ workspace: attemptWorkspace, spec, grants })) {
             const continuation = await runLandContinuationTurn({
+                config,
                 client,
                 taskId,
                 attemptId: active.attemptId,
@@ -1177,6 +1311,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
         try {
             report = await finalizeRepositoryLand({
+                config,
                 client,
                 taskId,
                 attemptId: active.attemptId,
@@ -1346,6 +1481,7 @@ async function runLandContinuationTurn(input) {
         fuel: input.fuel,
         fuelSource: input.fuelSource,
     });
+    await learnDriverFuel(input.config, input.driver.name, input.fuelSource ?? "conduit", continuation);
     if (continuation.status === "failed") {
         throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
     }
@@ -1386,6 +1522,7 @@ async function finalizeRepositoryLand(input) {
         throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
     }
     const continuation = await runLandContinuationTurn({
+        config: input.config,
         client: input.client,
         taskId: input.taskId,
         attemptId: input.attemptId,

package/dist/investigation.js

@@ -9,8 +9,9 @@ import { z } from "zod";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { redactSecrets } from "./config.js";
+import { learnDriverFuel } from "./execution.js";
 import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
-import { pickDriverForClaim, supportsReadOnlyDiagnosis } from "./drivers.js";
+import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { changedPathsSince } from "./execution.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -21,6 +22,7 @@ const budgetSchema = z.object({
 }).passthrough();
 export const investigationAssignmentSchema = z.object({
     id: z.string().uuid(),
+    project_id: z.string().uuid(),
     kind: z.literal("repository"),
     question: z.string().min(1).max(4_000),
     grants: z.array(z.string()).default([]),
@@ -181,6 +183,13 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             attemptId: assignment.id,
             startCommit: commit,
         });
+        // One value, used to run and to record. Read separately they drifted: nothing was passed to the
+        // driver, so it defaulted to Conduit fuel, while the result was filed against the lane's
+        // configured source — letting a gateway refusal mark the operator's personal subscription spent.
+        const investigationFuel = resolveDriverFuel(config, driver.name);
+        const fuel = investigationFuel === "conduit"
+            ? { baseUrl: config.baseUrl, gatewayKey: await client.ensureFuel(assignment.project_id) }
+            : undefined;
         const result = await driver.run({
             prompt: buildInvestigationPrompt(assignment, commit),
             workspace: attemptWorkspace,
@@ -190,8 +199,11 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             // The same signal the read-only diagnosis lane uses; it is what denies edits in the driver.
             workRole: "diagnose",
             executionClass: "verify",
+            fuelSource: investigationFuel,
+            fuel,
             timeoutMs: Math.min(timeoutMs ?? assignment.budget.max_duration_ms, assignment.budget.max_duration_ms),
         });
+        await learnDriverFuel(config, driver.name, investigationFuel, result);
         if (result.status === "failed") {
             const message = result.error ?? "Investigation run failed";
             await settle(client, assignment.id, { lease_token: leaseToken, status: "failed", error: redactSecrets(message).slice(0, 2_000), retryable: true });

package/dist/ops.js

@@ -5,7 +5,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
@@ -15,6 +15,7 @@ import { driverIdsFromDetectedLabels } from "./drivers.js";
 import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
 import { applyRunnerToolPath, runnerServiceWorkspaceWarnings } from "./service.js";
 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",
 ];
@@ -529,19 +530,35 @@ export async function runOps(verb, argv = [], deps = {}) {
         }
         const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
         const drivers = await (deps.resolveInstallDrivers ?? resolveInstallDrivers)(installEnv, installArgv);
-        for (const id of drivers) {
-            if (LOCAL_FUEL_DRIVERS.has(id))
-                runBridge(["drivers", "fuel", id, "local"]);
-        }
-        runBridge(["drivers", "online", ...drivers]);
-        applyRunnerToolPath();
         if (installEnv.CONDUIT_REPO) {
             const checkout = deps.ensureCheckout ?? ensureCheckout;
             const result = await checkout(workspace, installEnv.CONDUIT_REPO);
             console.log(result === "cloned"
                 ? `Cloned ${installEnv.CONDUIT_REPO} into ${workspace}`
                 : `Workspace already matches ${installEnv.CONDUIT_REPO}`);
+            const managedRoot = installEnv.CONDUIT_MANAGED_ROOT
+                ? resolve(expandOpsValue(installEnv.CONDUIT_MANAGED_ROOT))
+                : null;
+            const managedRelative = managedRoot ? relative(managedRoot, workspace) : "";
+            const managedCheckout = Boolean(managedRoot
+                && managedRelative
+                && managedRelative !== ".."
+                && !managedRelative.startsWith(`..${sep}`)
+                && !isAbsolute(managedRelative));
+            if (managedCheckout) {
+                const bootstrap = deps.bootstrapWorkspace ?? bootstrapManagedWorkspace;
+                const bootstrapResult = bootstrap(workspace);
+                if (bootstrapResult === "installed")
+                    console.log(`Installed locked project dependencies in ${workspace}`);
+            }
         }
+        // Do not advertise an executable lane until a managed checkout has completed bootstrap.
+        for (const id of drivers) {
+            if (LOCAL_FUEL_DRIVERS.has(id))
+                runBridge(["drivers", "fuel", id, "local"]);
+        }
+        runBridge(["drivers", "online", ...drivers]);
+        applyRunnerToolPath();
         // A managed root is intentionally empty until the console assigns its first repository. It
         // still needs a resident runner, and `ops install` is also the recovery path after enrollment.
         const waitingOnManagedAssignment = Boolean(installEnv.CONDUIT_MANAGED_ROOT

package/dist/preflight.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
 import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, resolveCodexExecutable, } from "./driver.js";
-import { localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
+import { laneQuota, localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 /** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
 // 4: each driver snapshot reports diagnosis_read_only, so the control plane can require a
 // capable diagnostic lane *before* dispatching instead of learning it from a failed attempt.
@@ -116,9 +116,22 @@ export async function runBridgePreflight(input, deps = {}) {
         if (fuel === "local" && !await localAuthenticationReady(driver, input.workspace, run)) {
             return { issue: { code: "driver_not_authenticated", driver }, snapshot: { id: driver, version: versionText, ready: false, diagnosis_read_only: diagnosisReadOnly } };
         }
-        return { issue: null, snapshot: { id: driver, version: versionText, ready: true, diagnosis_read_only: diagnosisReadOnly } };
+        // Reported, not probed: the window state was learned from the vendor's last refusal and read
+        // back through laneQuota, which retires a passed reset. Nothing is executed here, so a lane
+        // running dry costs the heartbeat nothing.
+        const quota = fuel === "local" ? laneQuota(input.config, driver) ?? undefined : undefined;
+        return {
+            issue: null,
+            snapshot: { id: driver, version: versionText, ready: quota?.exhausted !== true, diagnosis_read_only: diagnosisReadOnly, ...(quota ? { quota } : {}) },
+        };
     }));
     issues.push(...driverChecks.map((check) => check.issue).filter((issue) => issue !== null));
+    // One dry lane is not a broken machine — the others still take work, and marking the machine
+    // unready over it would strand a fuelled lane. Only a fleet with nothing left to spend is an
+    // issue, which is also what keeps `ready === (issues.length === 0)` true either way.
+    if (driverChecks.length > 0 && driverChecks.every((check) => check.snapshot.quota?.exhausted === true)) {
+        issues.push({ code: "driver_quota_exhausted" });
+    }
     return { ready: issues.length === 0, checked_at: new Date().toISOString(), workspace_clean: workspaceClean,
         drivers: driverChecks.map((check) => check.snapshot), models_fingerprint: modelsFingerprint(input.config), issues };
 }
@@ -165,5 +178,10 @@ export function describePreflightIssue(issue) {
         return `Agent CLI is missing from PATH${lane}`;
     if (issue.code === "driver_not_authenticated")
         return `Agent CLI is not logged in${lane}`;
+    // Named before the fallback: an exhausted lane fell through to "requires local fuel", which sends
+    // the operator to change a fuel setting when the lane is configured correctly and simply spent.
+    if (issue.code === "driver_quota_exhausted") {
+        return "Every online agent lane has spent its subscription allowance; work resumes when a window refills, or bring another lane online";
+    }
     return `Agent lane requires local fuel${lane}`;
 }

package/dist/workspace-bootstrap.js

@@ -0,0 +1,26 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function defaultRunner(command, args, workspace) {
+    const result = spawnSync(command, args, {
+        cwd: workspace,
+        env: process.env,
+        stdio: "inherit",
+        timeout: 10 * 60_000,
+    });
+    return { status: result.status, ...(result.error ? { error: result.error } : {}) };
+}
+/** Install locked JavaScript dependencies before a Conduit-managed checkout advertises readiness. */
+export function bootstrapManagedWorkspace(workspace, run = defaultRunner) {
+    if (!existsSync(join(workspace, "package.json")))
+        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);
+    if (result.error)
+        throw new Error(`managed_workspace_bootstrap_failed:${result.error.message}`);
+    if (result.status !== 0)
+        throw new Error(`managed_workspace_bootstrap_failed:exit_${result.status ?? "unknown"}`);
+    return "installed";
+}

package/package.json

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