@miraland-labs/conduit-bridge 0.16.29 → 0.16.30

package/dist/cli.js

@@ -440,7 +440,10 @@ async function driversCommand() {
         for (const lane of laneStatuses(config)) {
             const when = lane.observed_at ? ` observed=${lane.observed_at}` : "";
             const reset = lane.resets_at ? ` resets=${lane.resets_at}` : lane.allowance === "unavailable" ? " resets=unknown" : "";
-            console.log(`  ${lane.id.padEnd(14)} ${lane.state.padEnd(8)} fuel=${lane.fuel}  allowance=${lane.allowance}${when}${reset}  (${lane.label})`);
+            // A degraded provider never refuses, so allowance stays "unknown" while every turn times out.
+            // Printing the count is the only way an operator sees why dispatch keeps avoiding this lane.
+            const slow = lane.timeouts ? `  timeouts=${lane.timeouts} (demoted)` : "";
+            console.log(`  ${lane.id.padEnd(14)} ${lane.state.padEnd(8)} fuel=${lane.fuel}  allowance=${lane.allowance}${when}${reset}${slow}  (${lane.label})`);
         }
         const blocked = laneDispatchBlock(laneStatuses(config));
         console.log(blocked

package/dist/drivers.js

@@ -55,10 +55,21 @@ export function normalizeDrivers(raw) {
         const state = lane.state === "online" ? "online" : "offline";
         const fuel = lane.fuel === "local" || lane.fuel === "conduit" ? lane.fuel : undefined;
         const quota = normalizeQuota(lane.quota);
-        out[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}) };
+        const outcome = normalizeOutcome(lane.outcome);
+        out[id] = { state, ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}), ...(outcome ? { outcome } : {}) };
     }
     return out;
 }
+/** Same rule as quota: a malformed outcome is dropped, never allowed to hold a lane back. */
+function normalizeOutcome(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const value = raw;
+    if (!Number.isFinite(value.consecutive_timeouts) || typeof value.last_timeout_at !== "string")
+        return undefined;
+    const count = Math.max(0, Math.floor(value.consecutive_timeouts));
+    return { consecutive_timeouts: count, last_timeout_at: value.last_timeout_at };
+}
 /** 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")
@@ -159,11 +170,14 @@ export function laneStatuses(config, now = Date.now()) {
         const allowance = !local || !quota
             ? "unknown"
             : quota.exhausted ? "unavailable" : "available";
+        const outcome = normalizeDrivers(config.drivers)[lane.id]?.outcome;
         return {
             ...lane,
             allowance,
             observed_at: quota?.observed_at,
             resets_at: quota?.resets_at ?? undefined,
+            ...(laneTimedOutRecently(config, lane.id, now) ? { timeouts: outcome?.consecutive_timeouts } : {}),
+            // Timeouts demote but never make a lane ineligible: see pickDriverForClaim.
             eligible: lane.state === "online" && allowance !== "unavailable",
         };
     });
@@ -178,6 +192,53 @@ export function laneDispatchBlock(statuses) {
         return "every lane is offline";
     return "every online lane has an allowance the provider refused";
 }
+/** Timeouts in a row before a lane stops being preferred. One is noise; two is a pattern. */
+export const TIMEOUT_SUPPRESSION_THRESHOLD = 2;
+/** How long a timeout pattern is believed. Short, because the cause is often the budget, not the lane. */
+export const TIMEOUT_SUPPRESSION_MS = 60 * 60_000;
+/** Record a turn that ended at the execution ceiling. Never touches the quota record. */
+export function recordDriverTimeout(config, driverId, now = Date.now()) {
+    if (!isSupportedDriverId(driverId))
+        return config;
+    const drivers = normalizeDrivers(config.drivers);
+    const lane = drivers[driverId] ?? { state: "offline" };
+    const previous = lane.outcome?.consecutive_timeouts ?? 0;
+    drivers[driverId] = {
+        ...lane,
+        outcome: { consecutive_timeouts: previous + 1, last_timeout_at: new Date(now).toISOString() },
+    };
+    return { ...config, drivers };
+}
+/**
+ * Clear what the last runs said about this lane.
+ *
+ * A run that finished is the strongest evidence there is, and it is worth more than any older claim
+ * — a lane that just worked is not spent and is not slow.
+ */
+export function clearDriverOutcome(config, driverId) {
+    if (!isSupportedDriverId(driverId))
+        return config;
+    const drivers = normalizeDrivers(config.drivers);
+    const lane = drivers[driverId];
+    if (!lane?.outcome)
+        return config;
+    const { outcome: _cleared, ...rest } = lane;
+    drivers[driverId] = rest;
+    return { ...config, drivers };
+}
+/**
+ * Whether this lane's recent timeouts should push it behind others.
+ *
+ * Expires on its own, because a timeout usually means the budget was too small for the work rather
+ * than that the lane is bad, and the next package may be smaller.
+ */
+export function laneTimedOutRecently(config, driverId, now = Date.now()) {
+    const outcome = normalizeDrivers(config.drivers)[driverId]?.outcome;
+    if (!outcome || outcome.consecutive_timeouts < TIMEOUT_SUPPRESSION_THRESHOLD)
+        return false;
+    const seen = Date.parse(outcome.last_timeout_at);
+    return !Number.isFinite(seen) || now - seen <= TIMEOUT_SUPPRESSION_MS;
+}
 export function onlineDriverIds(config) {
     const drivers = normalizeDrivers(config.drivers);
     return SUPPORTED_AGENTS.map((agent) => agent.id).filter((id) => drivers[id]?.state === "online");
@@ -290,14 +351,17 @@ export function pickDriverForClaim(config, processOnlineIds, eligible = () => tr
             load.set(active.driverId, (load.get(active.driverId) ?? 0) + 1);
         }
     }
+    // Demote, never exclude. A lane held out of selection can never run the work that would prove it
+    // well again, and suppressing the last candidate would idle the machine over a claim about the
+    // past. Ordering is enough: a healthy lane wins while one exists, and a suppressed lane is still
+    // picked when it is all there is.
+    const rank = (id) => (laneTimedOutRecently(config, id) ? 1 : 0);
     let best = online[0];
-    let bestLoad = load.get(best) ?? 0;
     for (const id of online.slice(1)) {
-        const n = load.get(id) ?? 0;
-        if (n < bestLoad) {
+        const better = rank(id) < rank(best)
+            || (rank(id) === rank(best) && (load.get(id) ?? 0) < (load.get(best) ?? 0));
+        if (better)
             best = id;
-            bestLoad = n;
-        }
     }
     return best;
 }

package/dist/execution.js

@@ -6,7 +6,7 @@ import { ConduitRequestError } from "./client.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, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis } from "./drivers.js";
+import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis, clearDriverOutcome, recordDriverTimeout } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -231,7 +231,11 @@ export function classifyFinalizeFailure(message) {
  * leave the lane eligible.
  */
 export async function learnDriverFuel(config, driverId, fuelSource, result) {
-    const drivers = observeDriverFuel(config, driverId, fuelSource, result).drivers;
+    // Fuel is what the vendor said; outcome is what the run did. Both are learned here so every path
+    // that already reports a result learns both, and no new call site can forget one of them.
+    let next = observeDriverFuel(config, driverId, fuelSource, result);
+    next = observeDriverOutcome(next, driverId, result);
+    const drivers = next.drivers;
     if (JSON.stringify(drivers ?? {}) === JSON.stringify(config.drivers ?? {}))
         return;
     config.drivers = drivers;
@@ -240,6 +244,21 @@ export async function learnDriverFuel(config, driverId, fuelSource, result) {
     // 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);
 }
+/**
+ * Learn from what the run did, not from what a vendor said about it.
+ *
+ * A provider that degrades instead of refusing — a spent Cursor subscription still answering from a
+ * slow free tier — produces no refusal to learn from, so the quota record stays empty and the lane
+ * looks healthy while every turn runs to the ceiling. The timeout itself is the evidence.
+ *
+ * Recorded separately from quota on purpose. A timeout means the budget was too small or the lane is
+ * degraded; a refusal means the allowance is spent. They call for different operator actions.
+ */
+export function observeDriverOutcome(config, driverId, result) {
+    if (result.status !== "failed")
+        return clearDriverOutcome(config, driverId);
+    return agentTurnTimedOut(result.error ?? "") ? recordDriverTimeout(config, driverId) : config;
+}
 export function observeDriverFuel(config, driverId, fuelSource, result, now = Date.now()) {
     if (fuelSource !== "local")
         return config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.29",
+  "version": "0.16.30",
   "description": "Conduit Bridge CLI \u2014 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": {