@miraland-labs/conduit-bridge 0.13.0 → 0.14.3

package/dist/driver.js

@@ -152,7 +152,7 @@ export function extractAgentReportJsonText(text) {
     const fromUnclosed = unclosed?.[1]?.trim();
     if (fromUnclosed)
         return fromUnclosed;
-    const start = text.lastIndexOf("{");
+    const start = text.indexOf("{");
     if (start < 0)
         throw new Error("Agent did not emit the required structured report");
     return text.slice(start).trim();

package/dist/execution.js

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ConduitRequestError } from "./client.js";
@@ -9,6 +10,30 @@ import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quaran
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
 import { captureVerificationFailure, ensureTestEvidence } from "./ensure-test-evidence.js";
+/** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
+export function startIdleSleepGuard(options = {}) {
+    if ((options.platform ?? process.platform) !== "darwin")
+        return () => undefined;
+    const launch = options.launch ?? ((command, args) => spawn(command, args, { stdio: "ignore" }));
+    let guard;
+    try {
+        // -w ties the assertion to the runner as a crash-safe ceiling; normal completion kills it sooner.
+        guard = launch("caffeinate", ["-i", "-w", String(options.pid ?? process.pid)]);
+    }
+    catch (error) {
+        console.error(`Idle-sleep guard unavailable: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        return () => undefined;
+    }
+    guard.once("error", (error) => console.error(`Idle-sleep guard unavailable: ${redactSecrets(error.message)}`));
+    guard.unref();
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        guard.kill("SIGTERM");
+    };
+}
 /** Feedback text for changes_requested summaries (plain string or `{ feedback }`). */
 function changesRequestedFeedback(summary) {
     if (!summary)
@@ -438,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 = {}) {
@@ -710,6 +745,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         executionKind,
         sourceAttemptId: sourceAttemptId ?? undefined,
     });
+    const releaseIdleSleep = startIdleSleepGuard();
     const renewTimer = setInterval(() => { void renewLeases(client, config).catch((error) => console.error(`Lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`)); }, 60_000);
     let heartbeatRunning = false;
     const heartbeatTimer = supervision ? setInterval(() => {
@@ -948,6 +984,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         console.log(`Assignment ${taskId} delivered for review and acceptance.`);
     }
     finally {
+        releaseIdleSleep();
         clearInterval(renewTimer);
         if (heartbeatTimer)
             clearInterval(heartbeatTimer);
@@ -1044,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";
@@ -1067,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.0",
+  "version": "0.14.3",
   "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": {