@miraland-labs/conduit-bridge 0.13.1 → 0.14.4

package/dist/client.js

@@ -40,11 +40,15 @@ export class ConduitClient {
         return data;
     }
     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}` }) });
+        // The lease token is this machine's bearer credential for the attempt. The server stores only
+        // its hash, so the client mints it and re-sends the identical token if it ever retries the
+        // claim (the idempotency key is deterministic per attempt exactly so that replay works).
+        const leaseToken = `lease_${crypto.randomUUID()}${crypto.randomUUID()}`;
+        const data = await this.request(`/runner/v1/tasks/${taskId}/claim`, { method: "POST", body: JSON.stringify({ attempt_id: attemptId, lease_token: leaseToken, idempotency_key: `bridge:claim:${attemptId}` }) });
         const active = {
             taskId,
             attemptId,
-            leaseToken: String(data.lease_token),
+            leaseToken,
             leaseExpiresAt: String(data.lease_expires_at),
             phase: "claimed",
             ...(extras?.driverId ? { driverId: extras.driverId } : {}),

package/dist/execution.js

@@ -463,13 +463,23 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
     });
     return { taskId: assignment.id, driverId: selectedDriverId };
 }
+export function claimedAssignmentDriver(fallback, driverId) {
+    if (!driverId)
+        return fallback;
+    const selected = DRIVERS[driverId];
+    if (!selected)
+        throw new Error(`Claimed assignment selected unavailable driver ${driverId}`);
+    return selected;
+}
 export async function executeNextAssignment(client, config, driver, workspace, brief, timeoutMs, supervision) {
     if (Object.keys(config.activeAttempts).length)
         return recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision);
-    const claimed = await claimNextAssignment(client, config, workspace, brief);
+    const preferredDriverId = Object.entries(DRIVERS).find(([, candidate]) => candidate === driver)?.[0] ?? null;
+    const claimed = await claimNextAssignment(client, config, workspace, brief, preferredDriverId);
     if (!claimed)
         return false;
-    await runClaimedAssignment(client, config, driver, workspace, brief, claimed.taskId, timeoutMs, supervision);
+    const selectedDriver = claimedAssignmentDriver(driver, claimed.driverId);
+    await runClaimedAssignment(client, config, selectedDriver, workspace, brief, claimed.taskId, timeoutMs, supervision);
     return true;
 }
 async function runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision, options = {}) {
@@ -1071,7 +1081,7 @@ export async function conduitAliases(fuel) {
         return null;
     }
 }
-async function resolveAssignmentModel(driver, config, spec, taskId, workspace, fuel) {
+export async function resolveAssignmentModel(driver, config, spec, taskId, workspace, fuel) {
     const tier = tierForRisk(spec.risk_level);
     const configured = config.models?.[tier];
     const risk = spec.risk_level === "low" || spec.risk_level === "medium" || spec.risk_level === "high" ? spec.risk_level : "unset";
@@ -1094,7 +1104,18 @@ async function resolveAssignmentModel(driver, config, spec, taskId, workspace, f
         return { risk, tier };
     }
     const candidates = Array.isArray(configured) ? configured : [configured];
-    const { model, skipped } = pickModelCandidate(candidates, await list());
+    const available = await list();
+    // Model names are driver-specific, but the tier -> model map is machine-wide, so switching the
+    // online lane silently invalidates it. Under local fuel the lane's own default is authenticated
+    // and works; a configured name we cannot confirm it supports hard-fails ("No API key found for
+    // <vendor>") — Pi resolved a Claude-era "opus" to amazon-bedrock and Held. When we cannot verify a
+    // local model, prefer the authenticated default over a guess that breaks the run. Under Conduit
+    // fuel the CLI default cannot resolve, so the mapped alias is still the right bet even unverified.
+    if (!fuel && available === null) {
+        console.error(`Assignment ${taskId} intelligence tier ${tier} (risk ${risk}): configured model not confirmed available on ${driver.name}; using its authenticated default. Set this lane's own default model to pin a specific one.`);
+        return { risk, tier };
+    }
+    const { model, skipped } = pickModelCandidate(candidates, available);
     const skippedNote = skipped.length ? ` (skipped unavailable/unsafe: ${skipped.join(", ")})` : "";
     if (!model) {
         const none = `Assignment ${taskId} intelligence tier ${tier} (risk ${risk}): no configured candidate available — CLI default${skippedNote}`;

package/dist/preflight.js

@@ -1,10 +1,22 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
 import { hasAntigravityLogin, hasClaudeLogin, hasOpenAiLogin, hasOpenCodeLogin, resolveCodexExecutable, } from "./driver.js";
-import { localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel } from "./drivers.js";
+import { localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 /** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
-export const BRIDGE_PROTOCOL_VERSION = 3;
+// 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.
+/** Stable digest of the tier -> model mapping, so a model change moves the readiness fingerprint. */
+function modelsFingerprint(config) {
+    const models = config.models ?? {};
+    const canonical = Object.keys(models).sort().map((tier) => {
+        const value = models[tier];
+        return `${tier}=${(Array.isArray(value) ? value : [value]).join("|")}`;
+    }).join(";");
+    return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+export const BRIDGE_PROTOCOL_VERSION = 4;
 const execFileAsync = promisify(execFile);
 async function defaultCommandRunner(command, args, cwd) {
     try {
@@ -83,22 +95,27 @@ export async function runBridgePreflight(input, deps = {}) {
             issues.push({ code: status.code === 0 ? "workspace_dirty" : "workspace_unavailable" });
     }
     const driverChecks = await Promise.all(online.map(async (driver) => {
+        // Whether this lane can combine bounded test execution with enforced read-only repository
+        // access. Reported here so dispatch can require it; the control plane must not keep its own
+        // copy of driver-name policy.
+        const diagnosisReadOnly = supportsReadOnlyDiagnosis(driver);
         const fuel = resolveDriverFuel(input.config, driver);
         if (localFuelOnlyDriver(driver) && fuel !== "local") {
-            return { issue: { code: "driver_fuel_mismatch", driver }, snapshot: { id: driver, version: null, ready: false } };
+            return { issue: { code: "driver_fuel_mismatch", driver }, snapshot: { id: driver, version: null, ready: false, diagnosis_read_only: diagnosisReadOnly } };
         }
         const version = await run(executableFor(driver), ["--version"], input.workspace);
         const versionText = `${version.stdout}${version.stderr}`.trim().slice(0, 200) || null;
         if (version.code !== 0 || !`${version.stdout}${version.stderr}`.trim()) {
-            return { issue: { code: "driver_missing", driver }, snapshot: { id: driver, version: versionText, ready: false } };
+            return { issue: { code: "driver_missing", driver }, snapshot: { id: driver, version: versionText, ready: false, diagnosis_read_only: diagnosisReadOnly } };
         }
         if (fuel === "local" && !await localAuthenticationReady(driver, input.workspace, run)) {
-            return { issue: { code: "driver_not_authenticated", driver }, snapshot: { id: driver, version: versionText, ready: false } };
+            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 } };
+        return { issue: null, snapshot: { id: driver, version: versionText, ready: true, diagnosis_read_only: diagnosisReadOnly } };
     }));
     issues.push(...driverChecks.map((check) => check.issue).filter((issue) => issue !== null));
-    return { ready: issues.length === 0, checked_at: new Date().toISOString(), workspace_clean: workspaceClean, drivers: driverChecks.map((check) => check.snapshot), issues };
+    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 };
 }
 let cached = null;
 /** Keep auth probes off the 15-second heartbeat hot path while still expiring readiness promptly. */
@@ -122,7 +139,8 @@ export function unavailableWorkspacePreflight(input) {
         ready: false,
         checked_at: new Date().toISOString(),
         workspace_clean: false,
-        drivers: online.map((id) => ({ id, version: null, ready: false })),
+        drivers: online.map((id) => ({ id, version: null, ready: false, diagnosis_read_only: supportsReadOnlyDiagnosis(id) })),
+        models_fingerprint: modelsFingerprint(input.config),
         issues,
     };
 }

package/package.json

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