@miraland-labs/conduit-bridge 0.16.103 → 0.16.105

package/dist/cli.js

@@ -14,7 +14,7 @@ import { detectInstalledClients, localFuelOnlyClients, suggestFuelSource } from
 import { DRIVERS, MODEL_TIERS } from "./driver.js";
 import { driversHeartbeatReport, driverLabel, heartbeatStatusForDrivers, isSupportedDriverId, listDriverLanes, onlineDriverIds, seedDriversFromDetection, seedDriverLanes, setDriverFuel, setDriverModels, setDriversOnline, formatLaneTiers, laneDispatchBlock, laneStatuses, } from "./drivers.js";
 import { buildWorkspaceBrief } from "./brief.js";
-import { parseAgentTimeoutMinutes } from "./execution-budget.js";
+import { parseAgentTimeoutMinutes, parseMaxTurns, resolveMaxTurns } from "./execution-budget.js";
 import { BOOTSTRAP_RESULTS, buildSovereignExecutionFacts } from "./execution-facts.js";
 import { ensureCheckout } from "./checkout.js";
 import { buildOnShiftIntentProof, maybeApplyOnShiftIntent } from "./on-shift-apply.js";
@@ -534,10 +534,26 @@ async function runner() {
     applyRunnerToolPath();
     const { values } = parseArgs({ args: process.argv.slice(3), options: {
             workspace: { type: "string" }, interval: { type: "string" }, once: { type: "boolean" },
-            "agent-timeout-minutes": { type: "string" }, fuel: { type: "string" }, "ensure-checkout": { type: "string" },
+            "agent-timeout-minutes": { type: "string" }, "max-turns": { type: "string" }, fuel: { type: "string" }, "ensure-checkout": { type: "string" },
             "bootstrap-result": { type: "string" },
         } });
     let config = await loadConfig();
+    // The cap is a machine setting, so it is written to the config the way `--fuel` is: the resident
+    // service, `ops status` and the readiness report then all read one number instead of each being
+    // told separately, and a runner started without the flag keeps the operator's last choice.
+    let maxTurnsOverride;
+    try {
+        maxTurnsOverride = parseMaxTurns(values["max-turns"]);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+        return;
+    }
+    if (maxTurnsOverride !== undefined) {
+        config.maxTurns = maxTurnsOverride;
+        await saveConfigPrefs(config);
+    }
     const fuelOverride = parseFuelSource(values.fuel);
     const bootstrapResult = values["bootstrap-result"]
         ? parseBootstrapResult(values["bootstrap-result"])
@@ -581,7 +597,7 @@ async function runner() {
         console.warn(`WARNING: no online driver lanes — ${bridgeUsage("drivers", "online", AGENT_PLACEHOLDER)}`);
     }
     const onlineLabel = onlineDriverIds(config).join(", ") || "(none)";
-    console.log(`Conduit runner (bridge v${bridgeVersion()}) connected to ${config.baseUrl}${workspace ? ` — workspace ${workspace}` : " — heartbeat only"} (lanes: ${onlineLabel}; machine fuel: ${config.fuelSource === "local" ? "local" : "conduit"}; slots: ${config.leaseCapacity})`);
+    console.log(`Conduit runner (bridge v${bridgeVersion()}) connected to ${config.baseUrl}${workspace ? ` — workspace ${workspace}` : " — heartbeat only"} (lanes: ${onlineLabel}; machine fuel: ${config.fuelSource === "local" ? "local" : "conduit"}; slots: ${config.leaseCapacity}; turn cap: ${resolveMaxTurns(config.maxTurns)})`);
     const running = new Map();
     for (;;) {
         let progressed = false;
@@ -591,6 +607,7 @@ async function runner() {
             config.drivers = latest.drivers;
             config.fuelSource = latest.fuelSource;
             config.leaseCapacity = latest.leaseCapacity;
+            config.maxTurns = latest.maxTurns;
             // Refresh before discovery: the brief and the readiness report must describe origin's code,
             // not whatever this checkout was left on. Cadence is the readiness report's own, not the beat.
             const refresh = workspace ? await reportedRefresh(workspace) : null;

package/dist/driver.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { boundedTail } from "./ensure-test-evidence.js";
-import { resolveAgentTimeout } from "./execution-budget.js";
-import { agentExitSignal, vendorKindForAntigravity } from "./failure-signal.js";
+import { resolveAgentTimeout, resolveMaxTurns } from "./execution-budget.js";
+import { agentExitSignal, turnCapSignal, vendorKindForAntigravity } from "./failure-signal.js";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
@@ -721,7 +721,8 @@ export const claudeCodeDriver = {
                 error: "No Bridge-mapped tools for active grants; refusing to start agent without an allow-list",
             };
         }
-        const args = ["-p", input.prompt, "--output-format", "json"];
+        const maxTurns = resolveMaxTurns(input.maxTurns);
+        const args = ["-p", input.prompt, "--output-format", "json", "--max-turns", String(maxTurns)];
         args.push(...modelArgs(claudeCodeDriver, input.model));
         if (input.resumeSessionId)
             args.push("--resume", input.resumeSessionId);
@@ -739,6 +740,18 @@ export const claudeCodeDriver = {
         }
         const sessionId = message?.session_id ?? null;
         const usage = claudeUsage(message);
+        // The CLI names this stop itself (`subtype: "error_max_turns"`, verified against claude 2.1.258),
+        // so the cap is read from the vendor's envelope rather than guessed from an exit code.
+        if (message?.subtype === "error_max_turns") {
+            return {
+                status: "failed",
+                resultText: message.result ?? null,
+                sessionId,
+                usage,
+                signal: turnCapSignal({ maxTurns, turns: usage.turns, model: input.model }),
+                error: `agent_turn_cap: the run reached the computer's cap of ${maxTurns} turns`,
+            };
+        }
         if (code !== 0 || !message || message.is_error) {
             return { status: "failed", resultText: message?.result ?? null, sessionId, usage, signal: agentExitSignal({ exit_code: code, stderr, stdout, model: input.model }), error: boundedTail(message?.result || stderr || `agent exited with code ${code}`, 20_000) };
         }

package/dist/ensure-test-evidence.js

@@ -45,14 +45,24 @@ export function pickVerificationCommand(commands) {
  * a declared gate neither dry-run nor witnessed unless an acceptance criterion happened to name it.
  * So the declared gates run beside the aggregate, in declared order, de-duplicated.
  */
-export function verificationEvidenceCommands(commands, declared = []) {
+export function verificationEvidenceCommands(commands, declared = [], acceptance = null) {
     const bounded = [...new Set(commands
             .map((command) => command.trim())
             .filter((command) => command && isRunnableVerificationCommand(command)))];
+    const declaredGates = bounded.filter((command) => declared.some((line) => line.trim() === command));
+    // T191: the gate is what the project declared for itself plus what the contract will be judged
+    // on — the commands its acceptance criteria name. Every other discovered script (this repository's
+    // ten-minute `npm run verify` for a docs change judged on `npm run typecheck`) is a candidate the
+    // planner may name, not a gate the Bridge runs unasked. When the criteria name no command the
+    // discovered rule below decides, as before (T31: a declared gate runs beside the aggregate).
+    if (acceptance !== null) {
+        const named = acceptanceVerificationCommands([...acceptance], commands).commands;
+        if (named.length)
+            return [...new Set([...declaredGates, ...named])];
+    }
     const aggregate = bounded.find((command) => /^(?:npm run|pnpm|yarn) verify$|^make check$/.test(command));
     if (!aggregate)
         return bounded;
-    const declaredGates = bounded.filter((command) => declared.some((line) => line.trim() === command));
     return [...new Set([...declaredGates, aggregate])];
 }
 /**
@@ -475,7 +485,7 @@ export async function ensureTestEvidence(input) {
     // The project's gate first, then every bounded command the criteria name that the workspace
     // authorizes. Each is witnessed on its own, so the reviewer sees the criterion's own proof.
     const commands = [...new Set([
-            ...verificationEvidenceCommands(input.verificationCommands, input.declaredVerificationCommands ?? []),
+            ...verificationEvidenceCommands(input.verificationCommands, input.declaredVerificationCommands ?? [], acceptance),
             ...named.commands,
         ])];
     if (commands.length === 0) {

package/dist/execution-budget.js

@@ -75,3 +75,48 @@ function usableMs(value) {
         return undefined;
     return Math.round(value);
 }
+/**
+ * How many turns one attempt may spend on a lane whose CLI can be told.
+ *
+ * A turn is not a minute. The agent CLI re-sends the whole conversation every turn, so the tokens
+ * one attempt bills grow with the square of its turn count: a one-paragraph documentation edit on
+ * 2026-09-15 ran 33 turns for 1,029,028 input tokens and $5.27, and the timer never came close.
+ * Forty turns is what ordinary delivery work has needed; beyond it a run is looping, not working.
+ */
+export const DEFAULT_MAX_TURNS = 40;
+/**
+ * The widest cap a configuration may ask for. Past this the number is far more likely to be a
+ * mistake than an intention — and an attempt that needs a thousand turns is the defect itself.
+ */
+export const MAX_MAX_TURNS = 500;
+export class InvalidMaxTurnsError extends Error {
+}
+/**
+ * A turn cap from a command line, validated.
+ *
+ * Validated at startup rather than at use, for the reason `parseAgentTimeoutMinutes` records:
+ * `Number("abc")` is `NaN`, `NaN` is not nullish, and an unvalidated value flows past every `??`
+ * default and becomes the bound itself.
+ */
+export function parseMaxTurns(value) {
+    if (value === undefined)
+        return undefined;
+    const turns = Number(value);
+    if (!Number.isInteger(turns) || turns < 1 || turns > MAX_MAX_TURNS) {
+        throw new InvalidMaxTurnsError(`--max-turns must be a whole number of turns between 1 and ${MAX_MAX_TURNS}, got ${JSON.stringify(value)}`);
+    }
+    return turns;
+}
+/**
+ * The effective turn cap for one run.
+ *
+ * The default applies here, at the point the flag is written, so a call site that knows nothing
+ * about the machine's configuration still runs capped. An uncapped run is the incident.
+ */
+export function resolveMaxTurns(configured) {
+    if (typeof configured !== "number" || !Number.isInteger(configured))
+        return DEFAULT_MAX_TURNS;
+    if (configured < 1 || configured > MAX_MAX_TURNS)
+        return DEFAULT_MAX_TURNS;
+    return configured;
+}

package/dist/execution.js

@@ -1285,7 +1285,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
         await removeReleasedDiagnosticWorktree(response);
         return;
     }
-    const evidenceCommands = verificationEvidenceCommands(attemptBrief?.verification ?? [], attemptBrief?.declared_verification ?? []);
+    const evidenceCommands = verificationEvidenceCommands(attemptBrief?.verification ?? [], attemptBrief?.declared_verification ?? [], spec.acceptance ?? []);
     // Ahead of the dry run and of the model: the contract requires test evidence and this worktree
     // offers no command that can witness it. Every fact is known here — the required evidence, the
     // test_run grant, the attempt worktree's own gates — and the same question was asked only after
@@ -1323,6 +1323,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             workspace: attemptWorkspace,
             verificationCommands: attemptBrief?.verification ?? [],
             declaredVerificationCommands: attemptBrief?.declared_verification ?? [],
+            acceptance: spec.acceptance ?? [],
             changeScope: spec.change_scope ?? [],
         });
         if (dryRun.ranNothing) {
@@ -1564,6 +1565,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             resumeSessionId,
             timeoutMs,
             maxDurationMs: workPackage?.max_duration_ms,
+            maxTurns: config.maxTurns,
             model: selection.model,
             fuel,
             fuelSource,
@@ -1706,9 +1708,14 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             // 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.
-            if (grants.includes("test_run") && !subscriptionExhausted(agentMessage))
+            // T197: the machine's turn cap is such a diagnosis too. Recovering a verification failure
+            // after it would retype the signal as a Bridge verification witness, which classifies as a
+            // transient retry — the one verdict that would run the capped work again at the same price.
+            const turnCapReached = result.signal?.kind === "turn_cap";
+            const recoverVerification = grants.includes("test_run") && !subscriptionExhausted(agentMessage) && !turnCapReached;
+            if (recoverVerification)
                 watchdog.phase("verification");
-            const verificationDetail = grants.includes("test_run") && !subscriptionExhausted(agentMessage)
+            const verificationDetail = recoverVerification
                 ? await captureVerificationFailure({
                     workspace: attemptWorkspace,
                     verificationCommands: attemptBrief?.verification ?? [],
@@ -1952,6 +1959,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                             resumeSessionId,
                             timeoutMs,
                             maxDurationMs: workPackage?.max_duration_ms,
+                            maxTurns: config.maxTurns,
                             model: selection.model,
                             fuel,
                             fuelSource,
@@ -2304,6 +2312,7 @@ async function runLandContinuationTurn(input) {
         resumeSessionId: input.resumeSessionId ?? undefined,
         timeoutMs: input.timeoutMs,
         maxDurationMs: input.maxDurationMs,
+        maxTurns: input.config.maxTurns,
         model: input.selection.model ?? undefined,
         fuel: input.fuel,
         fuelSource: input.fuelSource,
@@ -2791,7 +2800,7 @@ export function verificationScopeConflictDetail(paths, changeScope) {
  * discarded before the agent starts, so the agent always begins in the tree of the base commit.
  */
 export async function verificationScopeDryRun(input) {
-    const commands = verificationEvidenceCommands(input.verificationCommands, input.declaredVerificationCommands ?? []);
+    const commands = verificationEvidenceCommands(input.verificationCommands, input.declaredVerificationCommands ?? [], input.acceptance ?? null);
     if (!commands.length)
         return { ranNothing: null, redBase: null, outsideScope: [] };
     const run = input.runCommand ?? runBoundedVerificationCommand;

package/dist/failure-signal.js

@@ -17,7 +17,7 @@ export const failureSignalSchema = z.object({
     phase: z.enum(["claim", "checkout", "bootstrap", "agent", "verification", "delivery_report", "land"]),
     /** Who produced the evidence for this signal: Bridge itself, the agent CLI, or the vendor. */
     witness: z.enum(["bridge", "agent", "vendor"]),
-    kind: z.enum(["exit_code", "timeout", "denied_tool", "quota", "usage_error", "no_output", "contract", "verification_failed", "model_unbound", "stalled", "vendor_transient", "gateway_refusal", "unknown"]),
+    kind: z.enum(["exit_code", "timeout", "turn_cap", "denied_tool", "quota", "usage_error", "no_output", "contract", "verification_failed", "model_unbound", "stalled", "vendor_transient", "gateway_refusal", "unknown"]),
     /** The exact command when phase is verification or bootstrap. */
     command: z.string().max(2_000).optional(),
     /** The repository paths a Bridge check names as the cause, bounded so one signal stays readable. */
@@ -49,6 +49,17 @@ export const failureSignalSchema = z.object({
         pinned: z.string().max(200).nullable(),
         observed: z.string().max(200).nullable(),
     }).optional(),
+    /**
+     * The per-attempt turn cap the run reached, and the turns the vendor counted against it.
+     *
+     * Both numbers are the operator's own: the limit is this computer's setting, and the count is what
+     * the CLI said it spent. A card that only said "the run was stopped" would leave the operator
+     * unable to tell a cap that is too tight from work that is looping.
+     */
+    turn_cap: z.object({
+        limit: z.number().int().min(1),
+        turns: z.number().int().min(0),
+    }).optional(),
     /** The intelligence tier and driver named by a `model_unbound` signal: no configured candidate
      *  the retry could bind, so the run must not repeat the abort on the same or an unconfirmed name. */
     model_binding: z.object({
@@ -110,20 +121,45 @@ export function agentExitSignal(input) {
     const output = `${input.stderr ?? ""}\n${input.stdout ?? ""}`;
     const decisiveOutput = output.replace(CLAUDE_UNRECOGNIZED_MODEL_WARNING, "");
     const rejectedModel = Boolean(input.model) && MODEL_REJECTION.test(decisiveOutput);
+    const kind = TOOL_DENIAL.test(decisiveOutput) ? "denied_tool"
+        : GATEWAY_REFUSAL.test(decisiveOutput) ? "gateway_refusal"
+            : rejectedModel ? "usage_error"
+                : VENDOR_TRANSIENT.test(decisiveOutput) ? "vendor_transient"
+                    : "unknown";
+    // T196: the gateway's own words travel as the vendor message, whichever stream carried them.
+    // Claude Code prints "API Error: 400 Unknown model alias" on stdout, and the owner's card read
+    // "Conduit's gateway refused the agent's request:" followed by nothing (2026-09-15).
+    const refusalLine = kind === "gateway_refusal"
+        ? decisiveOutput.split("\n").map((line) => line.trim()).find((line) => GATEWAY_REFUSAL.test(line))
+        : undefined;
     return {
         phase: "agent",
         witness: "agent",
-        kind: TOOL_DENIAL.test(decisiveOutput) ? "denied_tool"
-            : GATEWAY_REFUSAL.test(decisiveOutput) ? "gateway_refusal"
-                : rejectedModel ? "usage_error"
-                    : VENDOR_TRANSIENT.test(decisiveOutput) ? "vendor_transient"
-                        : "unknown",
+        kind,
         exit_code: input.exit_code ?? null,
         ...(input.model ? { model: input.model } : {}),
+        ...(refusalLine ? { vendor_message: refusalLine.slice(0, 400) } : {}),
         ...(input.stderr?.trim() ? { stderr_tail: bounded2k(input.stderr) } : {}),
         ...(input.stdout?.trim() ? { stdout_tail: bounded2k(input.stdout) } : {}),
     };
 }
+/**
+ * The signal a driver emits when the machine's turn cap, not the work, ended the run.
+ *
+ * T197: the agent CLI re-sends the whole conversation every turn, so an attempt's token bill grows
+ * with the square of its turn count — 33 turns for one paragraph of documentation cost $5.27 on
+ * 2026-09-15, and nothing stopped it. The cap stops it; this signal makes the stop a decided
+ * environment Hold rather than a failure some later rule retries blind at the same price.
+ */
+export function turnCapSignal(input) {
+    return {
+        phase: "agent",
+        witness: "vendor",
+        kind: "turn_cap",
+        turn_cap: { limit: input.maxTurns, turns: input.turns },
+        ...(input.model ? { model: input.model } : {}),
+    };
+}
 /**
  * The signal Bridge emits when a pinned execution fact no longer matches the workspace.
  *
@@ -173,6 +209,24 @@ export function verificationScopeConflictSignal(paths) {
  * Bridge writes it, the classifier reads it, so the two sides agree on one string and not on prose.
  */
 export const VERIFICATION_FAILS_ON_BASE = "verification fails on the base commit";
+/**
+ * A shell reporting that a command the gate needs does not exist on this computer. Both the prose
+ * classifier and the base-gate rule read it: a gate that cannot start is a missing tool, never a
+ * red commit.
+ */
+export const WORKSPACE_DEPENDENCIES_MISSING_PATTERN = /(?:^|\n)\s*(?:\/(?:usr\/)?bin\/)?(?:ba|z|da)?sh:\s*(?:(?:\d+:\s*)?[^:\n]{1,120}:\s*(?:command\s+)?not found|command not found:\s*[^\n]+)\s*(?=\n|$)|(?:^|\n)\s*'[^'\n]+' is not recognized as an internal or external command/im;
+/** The one envelope for a gate whose tool is absent from the checkout, wherever it was noticed. */
+export function workspaceDependenciesMissingFailure(detail) {
+    return {
+        code: "workspace_dependencies_missing",
+        class: "environment",
+        disposition: "hold",
+        responsible_party: "conduit",
+        message: "The checkout is missing a locked tool required by its verification command.",
+        next_action: "Bridge must complete deterministic workspace bootstrap before authoring resumes. No plan or compiler constraints are needed from the owner.",
+        diagnostic_detail: detail,
+    };
+}
 /**
  * The signal Bridge emits when a gate exits non-zero on the base commit, before the agent starts.
  *
@@ -225,6 +279,8 @@ function quotedVendorText(signal) {
  * 8. verification run by Bridge, any other cause → the verify class: diagnose and brief a repair.
  * 9. contract, or a delivery_report phase → the delivery contract codes: rework.
  * 10. timeout → the turn reached its execution limit: stop.
+ * 11. turn_cap → the run reached the computer's per-attempt turn cap: Hold, on the operator, who
+ *     decides whether the work was looping or the cap is too tight. Never a silent retry.
  */
 export function classifyFailureSignal(signal) {
     // T90: ahead of every other rule, because a stalled attempt has no vendor evidence at all — the
@@ -335,6 +391,14 @@ export function classifyFailureSignal(signal) {
         && signal.vendor_message === VERIFICATION_FAILS_ON_BASE) {
         const command = signal.command ?? "the declared gate";
         const base = signal.base_commit ?? "the base commit";
+        const output = [signal.stderr_tail, signal.stdout_tail].filter(Boolean).join("\n");
+        // T198: a gate that could not start (`sh: tsc: not found`, exit 127) says nothing about the
+        // base commit. It is the computer's checkout that lacks a tool — an environment Hold that
+        // clears when the workspace is bootstrapped, not a contract Hold on the author that never
+        // clears. runner-2's first claim (2026-09-15) sat on the author for a missing `node_modules`.
+        if (signal.exit_code === 127 || WORKSPACE_DEPENDENCIES_MISSING_PATTERN.test(output)) {
+            return workspaceDependenciesMissingFailure([`$ ${command}`, `exit ${signal.exit_code ?? "unknown"}`, output].filter(Boolean).join("\n"));
+        }
         return {
             code: "verification_red_base",
             class: "contract",
@@ -425,6 +489,22 @@ export function classifyFailureSignal(signal) {
             diagnostic_detail: signal.stderr_tail,
         };
     }
+    // T197: the run was stopped by this computer's own turn cap. Retrying it spends the same money to
+    // reach the same cap, so the operator decides: raise the cap for work that genuinely needs the
+    // turns, or read the run and find why it was looping.
+    if (signal.kind === "turn_cap") {
+        const limit = signal.turn_cap?.limit ?? 0;
+        const spent = signal.turn_cap?.turns ?? 0;
+        return {
+            code: "agent_turn_cap_reached",
+            class: "environment",
+            disposition: "hold",
+            responsible_party: "computer_operator",
+            message: `The run hit this computer's turn cap of ${limit} turns after ${spent}, so Conduit stopped it before it spent more.`,
+            next_action: `Read the run: work that needs more turns gets a larger cap with \`npx @miraland-labs/conduit-bridge@latest runner --max-turns <n>\` on this computer, and a run that was looping needs the package narrowed. Then Recheck.`,
+            diagnostic_detail: `turn cap ${limit}; turns ${spent}`,
+        };
+    }
     return null;
 }
 /**

package/dist/investigation.js

@@ -325,6 +325,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             fuelSource: investigationFuel,
             fuel,
             timeoutMs: Math.min(timeoutMs ?? assignment.budget.max_duration_ms, assignment.budget.max_duration_ms),
+            maxTurns: config.maxTurns,
         });
         await learnDriverFuel(config, driver.name, investigationFuel, result);
         if (result.status === "failed") {

package/dist/preflight.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
+import { resolveMaxTurns } from "./execution-budget.js";
 import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, driverExecutable, } from "./driver.js";
 import { laneQuota, laneTierBindings, localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 /** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
@@ -228,7 +229,8 @@ export async function runBridgePreflight(input, deps = {}) {
         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,
+        drivers: driverChecks.map((check) => check.snapshot), models_fingerprint: modelsFingerprint(input.config),
+        max_turns: resolveMaxTurns(input.config.maxTurns), issues,
         ...(input.managedRoot?.trim() ? { managed_root: input.managedRoot.trim() } : {}) };
 }
 let cached = null;
@@ -240,7 +242,7 @@ export const PREFLIGHT_CACHE_TTL_MS = 5 * 60_000;
 /** Keep auth probes off the 15-second heartbeat hot path while still expiring readiness promptly. */
 export async function cachedBridgePreflight(input, options = {}) {
     const online = input.processOnlineIds?.length ? input.processOnlineIds : onlineDriverIds(input.config);
-    const key = JSON.stringify([input.workspace, input.expectedRepository ?? "", online, input.config.fuelSource, input.config.drivers,
+    const key = JSON.stringify([input.workspace, input.expectedRepository ?? "", online, input.config.fuelSource, input.config.drivers, input.config.maxTurns ?? 0,
         input.refresh?.state ?? "", input.refresh?.local_commits ?? 0, input.managedRoot ?? ""]);
     if (!options.force && cached?.key === key && Date.now() - cached.at < PREFLIGHT_CACHE_TTL_MS)
         return cached.report;
@@ -262,6 +264,7 @@ export function unavailableWorkspacePreflight(input) {
         drivers: online.map((id) => ({ id, version: null, ready: false, diagnosis_read_only: supportsReadOnlyDiagnosis(id), compatibility_fingerprint: null,
             tiers: laneTierBindings(input.config, id) })),
         models_fingerprint: modelsFingerprint(input.config),
+        max_turns: resolveMaxTurns(input.config.maxTurns),
         issues,
         ...(input.managedRoot?.trim() ? { managed_root: input.managedRoot.trim() } : {}),
     };

package/package.json

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