@miraland-labs/conduit-bridge 0.16.28 → 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/driver.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { boundedTail } from "./ensure-test-evidence.js";
 import { resolveAgentTimeout } from "./execution-budget.js";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
@@ -523,7 +524,7 @@ export const claudeCodeDriver = {
         }
         const sessionId = message?.session_id ?? null;
         if (code !== 0 || !message || message.is_error) {
-            return { status: "failed", resultText: message?.result ?? null, sessionId, error: (message?.result || stderr || `agent exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: message?.result ?? null, sessionId, error: boundedTail(message?.result || stderr || `agent exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: message.result ?? "", sessionId };
     },
@@ -624,7 +625,7 @@ export const codexDriver = {
         const parsed = parseCodexJsonl(stdout);
         const resultText = parsed.resultText ?? (stdout || null);
         if (code !== 0) {
-            return { status: "failed", resultText, sessionId: parsed.sessionId, error: (stderr || stdout || `codex exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || stdout || `codex exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText, sessionId: parsed.sessionId };
     },
@@ -756,7 +757,7 @@ export const cursorDriver = {
         const { code, stdout, stderr } = configured;
         const parsed = parseCursorOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: (stderr || parsed.resultText || `cursor agent exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `cursor agent exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -923,7 +924,7 @@ export const openCodeDriver = {
         const { code, stdout, stderr } = await withOpenCodePermissions(input.workspace, () => execute(input.executable ?? "opencode", args, input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource));
         const parsed = parseOpenCodeOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: (stderr || parsed.resultText || `opencode exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `opencode exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -988,7 +989,7 @@ export const kiroDriver = {
         args.push(input.prompt);
         const { code, stdout, stderr } = await execute(executable, args, input.workspace, agentTurnTimeoutMs(input), undefined, "local");
         if (code !== 0) {
-            return { status: "failed", resultText: stdout || null, sessionId: null, error: (stderr || stdout || `kiro-cli exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: stdout || null, sessionId: null, error: boundedTail(stderr || stdout || `kiro-cli exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: stdout, sessionId: null };
     },
@@ -1036,7 +1037,7 @@ export const antigravityDriver = {
         // agy print mode emits plain text and does not surface a resumable id, so rework resume is not wired.
         const { code, stdout, stderr } = await execute(input.executable ?? "agy", antigravityRunArgs({ prompt: input.prompt, grants: input.grants }, mode), input.workspace, agentTurnTimeoutMs(input), undefined, "local");
         if (code !== 0) {
-            return { status: "failed", resultText: stdout || null, sessionId: null, error: (stderr || stdout || `agy exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: stdout || null, sessionId: null, error: boundedTail(stderr || stdout || `agy exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: stdout, sessionId: null };
     },
@@ -1089,7 +1090,7 @@ export const piDriver = {
                 status: "failed",
                 resultText: parsed.resultText,
                 sessionId: parsed.sessionId,
-                error: (stderr || parsed.resultText || `pi exited with code ${code}`).slice(0, 20_000),
+                error: boundedTail(stderr || parsed.resultText || `pi exited with code ${code}`, 20_000),
             };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
@@ -1221,7 +1222,7 @@ export const grokDriver = {
         const { code, stdout, stderr } = await execute(executable, grokRunArgs(input), input.workspace, agentTurnTimeoutMs(input), undefined, "local");
         const parsed = parseGrokOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: (stderr || parsed.resultText || `grok exited with code ${code}`).slice(0, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `grok exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -1290,7 +1291,7 @@ function execute(executable, args, cwd, timeoutMs, fuel, fuelSource = "conduit",
                 stdout,
                 // Never let vendor stderr appended before SIGTERM turn a local timer into a quota refusal.
                 // This stable prefix is classified by Bridge and the control plane as execution timeout.
-                stderr: timedOut ? `agent_turn_timeout: agent turn exceeded ${timeoutMs}ms` : stderr.slice(0, 20_000),
+                stderr: timedOut ? `agent_turn_timeout: agent turn exceeded ${timeoutMs}ms` : boundedTail(stderr, 20_000),
             });
         });
         if (stdinText !== undefined && child.stdin) {

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/ensure-test-evidence.js

@@ -84,13 +84,10 @@ export async function captureVerificationFailure(input) {
         }
         if (result.code === 0)
             continue;
-        const lines = [
-            `$ ${command}`,
-            ...(result.stdout.trim() ? result.stdout.trim().split("\n") : []),
-            ...(result.stderr.trim() ? result.stderr.trim().split("\n") : []),
-            `exit ${result.code}`,
-        ].map((line) => line.slice(0, 4_000)).slice(0, 120);
-        const text = lines.join("\n").slice(0, 12_000);
+        // Same rule as the pre-delivery gate: this is the diagnosis a repair brief is written from, so
+        // it must keep the end. It carried its own head-truncating copy of that logic until the two were
+        // shown to be the same bug.
+        const text = boundedFailureDetail(command, result.stdout.trim() ? result.stdout.trim().split("\n") : [], result.stderr.trim() ? result.stderr.trim().split("\n") : [], result.code, DIAGNOSIS_DETAIL_MAX_CHARS);
         if (text.trim())
             return text;
     }
@@ -99,8 +96,52 @@ export async function captureVerificationFailure(input) {
 }
 /** Longest failure detail Bridge will attach. Enough to diagnose; short enough to store and read. */
 export const FAILURE_DETAIL_MAX_CHARS = 4_000;
+/** A recovered diagnosis may be longer: Conductor writes a repair brief from it. */
+export const DIAGNOSIS_DETAIL_MAX_CHARS = 12_000;
 /** Leading lines kept for orientation before the elision. */
 const FAILURE_DETAIL_HEAD_LINES = 3;
+/** Head kept for orientation when a raw message must be shortened. */
+const TAIL_HEAD_CHARS = 200;
+/**
+ * Keep a bounded number of lines without losing the last ones.
+ *
+ * Used for the evidence stored when verification *passes*. The proof that a suite passed is its
+ * summary — `Ran 500 tests` and `OK` — and that is the final line. Keeping the first hundred lines
+ * of a long verbose run stored a screen of `... ok` and discarded the only line that settles it.
+ *
+ * Returns the input unchanged when it already fits, so nothing short is ever decorated.
+ */
+export function boundedDetailLines(lines, maxLines) {
+    if (lines.length <= maxLines)
+        return lines;
+    const head = Math.min(3, Math.max(0, maxLines - 2));
+    const tail = maxLines - head - 1;
+    const dropped = lines.length - head - tail;
+    return [
+        ...lines.slice(0, head),
+        `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`,
+        ...lines.slice(lines.length - tail),
+    ];
+}
+/**
+ * Shorten a raw diagnostic message while keeping the end.
+ *
+ * For a message with no line structure worth preserving — an agent's stderr, a check's failure text —
+ * the same rule holds as for command output: the beginning is a banner and the end is the reason.
+ * Keeping a short head preserves the label or error code that usually leads the string.
+ *
+ * Returns the input unchanged when it already fits, so a short message is never decorated.
+ */
+export function boundedTail(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const marker = "\n… truncated …\n";
+    const head = Math.min(TAIL_HEAD_CHARS, Math.floor((maxChars - marker.length) / 4));
+    const tail = maxChars - marker.length - head;
+    if (tail <= 0)
+        return text.slice(text.length - maxChars);
+    return `${text.slice(0, head)}${marker}${text.slice(text.length - tail)}`;
+}
 /**
  * A failure detail that keeps the part which explains the failure.
  *
@@ -119,24 +160,39 @@ export function boundedFailureDetail(command, stdoutLines, stderrLines, code, ma
     const body = [...stdoutLines, ...stderrLines].map(cap);
     const first = `$ ${command}`;
     const last = `exit ${code}`;
-    // The exit code is never a candidate for elision: it is the one line that always carries meaning.
-    const fixed = `${first}\n${last}`.length;
-    const budget = Math.max(0, maxChars - fixed - 1);
-    const head = body.slice(0, FAILURE_DETAIL_HEAD_LINES);
-    const rest = body.slice(FAILURE_DETAIL_HEAD_LINES);
+    const marker = (dropped) => `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`;
+    // The command and the exit code are never candidates for elision, and every separator the join
+    // will insert is charged for. Adding the head lines without charging them is what let a 200-char
+    // budget produce 218 characters.
+    let budget = maxChars - first.length - last.length - 2;
+    if (budget <= 0)
+        return [first, last].join("\n");
+    // Head is a convenience for orientation, so it may take only a small share and is dropped entirely
+    // when it does not fit. The tail is the diagnosis and gets whatever remains.
+    const headBudget = Math.floor(budget / 4);
+    const head = [];
+    let headUsed = 0;
+    for (const line of body.slice(0, FAILURE_DETAIL_HEAD_LINES)) {
+        if (headUsed + line.length + 1 > headBudget)
+            break;
+        head.push(line);
+        headUsed += line.length + 1;
+    }
+    budget -= headUsed;
+    const rest = body.slice(head.length);
     const tail = [];
-    let used = head.join("\n").length;
+    let tailUsed = 0;
     for (let index = rest.length - 1; index >= 0; index -= 1) {
         const line = rest[index];
-        if (used + line.length + 1 > budget)
+        // Reserve room for the marker while anything is still being dropped.
+        const reserve = index > 0 ? marker(index).length + 1 : 0;
+        if (tailUsed + line.length + 1 + reserve > budget)
             break;
         tail.unshift(line);
-        used += line.length + 1;
+        tailUsed += line.length + 1;
     }
     const dropped = rest.length - tail.length;
-    const middle = dropped > 0
-        ? [...head, `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`, ...tail]
-        : [...head, ...tail];
+    const middle = dropped > 0 ? [...head, marker(dropped), ...tail] : [...head, ...tail];
     return [first, ...middle, last].join("\n");
 }
 async function defaultRunCommand(command, workspace) {
@@ -217,18 +273,33 @@ export async function ensureTestEvidence(input) {
         const stderrLines = result.stderr.trim() ? result.stderr.trim().split("\n") : [];
         if (result.code !== 0) {
             // Prefix must match FINALIZE_CONTRACT_PATTERN ("Agent report") — not Bridge-fault laundering.
-            throw new Error(`Agent report: Verification failed (${command}): ${boundedFailureDetail(command, stdoutLines, stderrLines, result.code)}`);
+            const detail = boundedFailureDetail(command, stdoutLines, stderrLines, result.code);
+            // One line an operator can grep when a stored failure looks head-truncated. Reading the shape
+            // back out of the database could not distinguish "the fix did not run" from "something
+            // downstream re-truncated it"; this says which, at the moment it is produced.
+            console.error(JSON.stringify({
+                event: "verification_failure_detail",
+                command,
+                exit_code: result.code,
+                stdout_lines: stdoutLines.length,
+                stderr_lines: stderrLines.length,
+                detail_chars: detail.length,
+                elided: detail.includes("omitted"),
+                ends_with_exit: detail.trimEnd().endsWith(`exit ${result.code}`),
+            }));
+            throw new Error(`Agent report: Verification failed (${command}): ${detail}`);
         }
         // Empty exit-0 is not proof — a no-op recipe (`@true`) must not clear required_evidence: test.
         if (stdoutLines.length === 0 && stderrLines.length === 0) {
             throw new Error(`Agent report: Verification produced no output for test evidence (${command}). A bounded test command must print observable stdout or stderr.`);
         }
-        const details = [
+        const rawDetails = [
             `$ ${command}`,
             ...stdoutLines,
             ...stderrLines,
             `exit ${result.code}`,
-        ].map((line) => line.slice(0, 4_000)).slice(0, 100);
+        ].map((line) => line.slice(0, 4_000));
+        const details = boundedDetailLines(rawDetails, 100);
         if (details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN) {
             throw new Error(`Agent report: Verification produced insufficient output for test evidence (${command})`);
         }

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/dist/investigation.js

@@ -6,6 +6,7 @@
  * the worktree it reads is deleted whichever way the run ends.
  */
 import { z } from "zod";
+import { boundedTail } from "./ensure-test-evidence.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { redactSecrets } from "./config.js";
@@ -206,7 +207,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
         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 });
+            await settle(client, assignment.id, { lease_token: leaseToken, status: "failed", error: boundedTail(redactSecrets(message), 2_000), retryable: true });
             console.error(`Investigation ${assignment.id} failed: ${redactSecrets(message)}`);
             return true;
         }
@@ -216,7 +217,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             // The answer may be perfectly good, but it is no longer an answer about the pinned commit.
             // Report what happened rather than settling a brief whose ground moved under it.
             await settle(client, assignment.id, {
-                lease_token: leaseToken, status: "failed", error: `${check.error}: ${check.detail}`.slice(0, 2_000), retryable: true,
+                lease_token: leaseToken, status: "failed", error: boundedTail(`${check.error}: ${check.detail}`, 2_000), retryable: true,
             });
             console.error(`Investigation ${assignment.id} discarded — ${check.error}: ${check.detail}`);
             return true;
@@ -247,7 +248,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
         await settle(client, assignment.id, {
             lease_token: leaseToken,
             status: "failed",
-            error: redactSecrets(message).slice(0, 2_000),
+            error: boundedTail(redactSecrets(message), 2_000),
             // A malformed brief is worth one more try; a broken worktree is not fixed by repeating it.
             retryable: message === UNUSABLE_BRIEF,
         }).catch((settleError) => console.error(`Investigation settle failed: ${redactSecrets(settleError instanceof Error ? settleError.message : "unknown")}`));

package/package.json

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