@miraland-labs/conduit-bridge 0.16.157 → 0.16.159

package/dist/client.js

@@ -69,10 +69,16 @@ export class ConduitClient {
             signal: init.signal ?? AbortSignal.timeout(CONTROL_PLANE_TIMEOUT_MS),
             headers: { authorization: `Bearer ${this.config.runnerKey}`, "content-type": "application/json", ...init.headers },
         });
-        const data = await response.json();
-        if (!response.ok)
-            throw new ConduitRequestError(data.error?.message ?? `Conduit request failed (${response.status})`, response.status, data.error?.code, data.error?.details);
-        return data;
+        if (!response.ok) {
+            const text = await response.text();
+            let data = null;
+            try {
+                data = JSON.parse(text);
+            }
+            catch { /* A proxy may answer with a non-JSON error page. */ }
+            throw new ConduitRequestError(data?.error?.message ?? `Conduit request failed (${response.status})`, response.status, data?.error?.code, data?.error?.details);
+        }
+        return await response.json();
     }
     async claim(taskId, attemptId, extras) {
         // The lease token is this machine's bearer credential for the attempt. The server stores only

package/dist/driver.js

@@ -1895,7 +1895,7 @@ const OWN_PROCESS_GROUP = process.platform !== "win32";
 /** Process groups of the agents running now, stopped when the runner itself is stopped. */
 const runningGroups = new Set();
 let shutdownHookInstalled = false;
-function signalGroup(pid, signal) {
+export function signalGroup(pid, signal) {
     try {
         process.kill(-pid, signal);
     }

package/dist/ensure-land-commit.js

@@ -37,7 +37,7 @@ export async function ensureLandCommit(input) {
         return { kind: "skipped" };
     const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
     const readHead = input.readHeadCommit ?? readHeadCommit;
-    const listPending = input.listUncommittedPaths ?? uncommittedPaths;
+    const listPending = input.listUncommittedPaths ?? ((workspace) => uncommittedPaths(workspace, { untracked: "all" }));
     const commitPaths = input.commitPaths ?? commitScopedPaths;
     const ahead = await countAhead(input.workspace, base);
     if (ahead !== null && ahead > 0) {
@@ -69,7 +69,7 @@ async function currentBranch(workspace) {
 export async function checkpointWorkInProgress(input) {
     if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
         return null;
-    const pending = filterPathsInScope(await uncommittedPaths(input.workspace), input.spec.change_scope ?? []);
+    const pending = filterPathsInScope(await uncommittedPaths(input.workspace, { untracked: "all" }), input.spec.change_scope ?? []);
     if (pending.length) {
         await commitScopedPaths(input.workspace, pending, "Conduit: work in progress at the package budget");
     }

package/dist/ensure-pull-request.js

@@ -8,10 +8,13 @@ import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
 import { readHeadCommit } from "./git.js";
 import { forgeTransportFailure } from "./transport-fault.js";
+import { ConduitRequestError } from "./client.js";
+import { redactSecrets } from "./secret-redaction.js";
 import { agentNoLandCommitMessage } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
 /** Keep the pull request body inside forge limits, even for a very large delivery packet. */
 const PULL_REQUEST_BODY_MAX_BYTES = 60_000;
+export const CONTROL_PLANE_TRANSIENT_PREFIX = "Control plane did not answer the change request open: ";
 /**
  * What the packet says when the control plane refused to open the change request.
  *
@@ -289,14 +292,16 @@ export async function ensureDeliveryPullRequest(input) {
             head_branch: headBranch,
             head_commit: report.head_commit,
             title: (input.title ?? "Conduit delivery").slice(0, 200),
-            body: composePullRequestBody(report),
+            body: redactSecrets(composePullRequestBody(report)),
             idempotency_key: `bridge:open-pr:${input.attemptId}`,
         });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const code = typeof error.code === "string" ? error.code : "";
-        throw new Error(`${PULL_REQUEST_OPEN_FAILURE_PREFIX}: ${message}${code ? ` (${code})` : ""}`);
+        if (error instanceof ConduitRequestError && error.status < 500) {
+            throw new Error(`${PULL_REQUEST_OPEN_FAILURE_PREFIX}: ${message}${error.code ? ` (${error.code})` : ""}`);
+        }
+        throw new Error(`${CONTROL_PLANE_TRANSIENT_PREFIX}${message}`);
     }
     const pullRequestUrl = typeof response.pull_request_url === "string" ? response.pull_request_url : "";
     // Any https URL: the control plane resolved which forge this project uses and parsed the response
@@ -304,7 +309,7 @@ export async function ensureDeliveryPullRequest(input) {
     // GitLab merge request — after the branch was already pushed. The head-commit cross-check below is
     // what actually proves the returned change request is this delivery's.
     if (!isAbsoluteHttpsUrl(pullRequestUrl)) {
-        throw new Error("Control plane did not return a pull_request_url");
+        throw new Error("Control plane answered without a change request link");
     }
     const openedHead = typeof response.head_commit === "string" ? response.head_commit : "";
     const deliveredHead = report.head_commit ?? "";

package/dist/ensure-test-evidence.js

@@ -3,15 +3,13 @@
  * commands and attaches their verbatim results. Agent prose may supplement those runs;
  * it never substitutes for it.
  */
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { boundedEnvironment, criterionKey, resolveCriterionReference } from "./driver.js";
+import { spawn } from "node:child_process";
+import { boundedEnvironment, criterionKey, resolveCriterionReference, signalGroup, STDIO_DRAIN_MS } from "./driver.js";
 import { isBoundedVerificationCommand, isRunnableVerificationCommand } from "./execution-class.js";
-const execFileAsync = promisify(execFile);
 const TEST_EVIDENCE_DETAILS_MIN = 32;
 /** Cold `cargo test` in an attempt worktree routinely exceeds two minutes of compile. */
 export const VERIFICATION_TIMEOUT_MS = 600_000;
-/** rustc + cargo logs routinely exceed 2 MiB; Node kills the child when maxBuffer is hit. */
+/** rustc + cargo logs routinely exceed 2 MiB; keep a bounded tail per stream. */
 export const VERIFICATION_MAX_BUFFER_BYTES = 32_000_000;
 /**
  * Contract requires test + test_run — Bridge always runs; agent paste is not a substitute.
@@ -203,6 +201,10 @@ export async function captureVerificationFailure(input) {
             // Diagnosis is best-effort: try the next command rather than failing the attempt again.
             continue;
         }
+        if (result.timedOut) {
+            return { command, detail: boundedTail(outputLines(result).join("\n"), DIAGNOSIS_DETAIL_MAX_CHARS),
+                timedOut: true, stdout: result.stdout, stderr: result.stderr };
+        }
         if (result.code === 0)
             continue;
         // Same rule as the pre-delivery gate: this is the diagnosis a repair brief is written from, so
@@ -375,55 +377,128 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         throw new Error("Verification command is empty");
     // Chunks are not whole lines. Each stream keeps its partial last line until the line ends, so a
     // stderr write between two stdout chunks cannot split a stdout line.
-    const lines = [];
-    const partial = { stdout: "", stderr: "" };
+    const boundedOutput = (limit) => {
+        const chunks = [];
+        let bytes = 0;
+        return {
+            append(text) {
+                const chunk = Buffer.from(text);
+                if (!chunk.length)
+                    return;
+                const last = chunks.at(-1);
+                if (last && last.length + chunk.length <= 64 * 1024)
+                    chunks[chunks.length - 1] = Buffer.concat([last, chunk]);
+                else
+                    chunks.push(chunk);
+                bytes += chunk.length;
+                while (bytes > limit) {
+                    const first = chunks[0];
+                    const excess = bytes - limit;
+                    if (first.length <= excess) {
+                        bytes -= first.length;
+                        chunks.shift();
+                    }
+                    else {
+                        chunks[0] = first.subarray(excess);
+                        bytes = limit;
+                    }
+                }
+            },
+            text() {
+                const buffer = Buffer.concat(chunks, bytes);
+                let start = 0;
+                while (start < buffer.length && (buffer[start] & 0xc0) === 0x80)
+                    start += 1;
+                return buffer.subarray(start).toString("utf8");
+            },
+            clear() { chunks.length = 0; bytes = 0; },
+        };
+    };
+    const lines = boundedOutput(2 * VERIFICATION_MAX_BUFFER_BYTES);
+    const partial = { stdout: boundedOutput(VERIFICATION_MAX_BUFFER_BYTES), stderr: boundedOutput(VERIFICATION_MAX_BUFFER_BYTES) };
     const collect = (stream) => (chunk) => {
-        const parts = `${partial[stream]}${String(chunk)}`.split("\n");
-        partial[stream] = parts.pop() ?? "";
-        lines.push(...parts);
+        const parts = String(chunk).split("\n");
+        partial[stream].append(parts[0]);
+        if (parts.length === 1)
+            return;
+        lines.append(`${partial[stream].text()}\n`);
+        partial[stream].clear();
+        if (parts.length > 2)
+            lines.append(`${parts.slice(1, -1).join("\n")}\n`);
+        partial[stream].append(parts.at(-1));
     };
-    const output = () => [...lines, ...[partial.stdout, partial.stderr].filter(Boolean)].join("\n");
-    try {
-        const pending = execFileAsync(bin, argv.slice(1), {
-            cwd: workspace,
-            timeout: timeoutMs,
-            maxBuffer: VERIFICATION_MAX_BUFFER_BYTES,
-            // The agent's environment, not the runner's: a gate that passes only with a variable the
-            // agent never sees ties the project to this computer (acme-sim DATABASE_URL, 2026-10-10).
-            env: boundedEnvironment(),
-        });
-        pending.child.stdout?.on("data", collect("stdout"));
-        pending.child.stderr?.on("data", collect("stderr"));
-        const { stdout, stderr } = await pending;
-        return { stdout: String(stdout), stderr: String(stderr), output: output(), code: 0 };
-    }
-    catch (error) {
-        const err = error;
-        // A spawn failure carries a string code (`ENOENT` when the tool is not on PATH); a gate that
-        // ran carries its numeric exit code. Reporting a missing tool as exit 1 made the dry run read
-        // it as a red base and put the computer's missing tool on the initiative author. A command that
-        // never started says nothing, so it is thrown: the dry run skips it, and the delivery gate's
-        // message reaches the `enoent` rule that Holds it on the computer operator.
-        if (typeof err.code === "string")
-            throw error;
-        if (err.killed === true) {
+    const output = () => [lines.text().replace(/\n$/, ""), partial.stdout.text(), partial.stderr.text()].filter(Boolean).join("\n");
+    return new Promise((resolve, reject) => {
+        const ownGroup = process.platform !== "win32";
+        const child = spawn(bin, argv.slice(1), { cwd: workspace, env: boundedEnvironment(),
+            stdio: ["ignore", "pipe", "pipe"], detached: ownGroup });
+        const stop = (signal) => {
+            if (ownGroup && child.pid !== undefined)
+                signalGroup(child.pid, signal);
+            else
+                child.kill(signal);
+        };
+        const stdout = boundedOutput(VERIFICATION_MAX_BUFFER_BYTES);
+        const stderr = boundedOutput(VERIFICATION_MAX_BUFFER_BYTES);
+        let timedOut = false;
+        let settled = false;
+        let exited = false;
+        let drainTimer = null;
+        let graceTimer = null;
+        const cleanup = () => {
+            clearTimeout(timer);
+            if (drainTimer)
+                clearTimeout(drainTimer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            stop("SIGTERM");
+            setTimeout(() => stop("SIGKILL"), 5_000).unref?.();
+        };
+        const settle = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
             const stopped = `Bridge stopped the gate: it did not exit within ${Math.round(timeoutMs / 1_000)} seconds.`;
-            return {
-                stdout: String(err.stdout ?? ""),
-                stderr: `${String(err.stderr ?? "")}\n${stopped}`.trimStart(),
-                output: `${output()}\n${stopped}`.trimStart(),
-                code: 1,
-                timedOut: true,
-            };
-        }
-        const stderr = String(err.stderr || err.message || "verification failed");
-        return {
-            stdout: String(err.stdout ?? ""),
-            stderr,
-            output: output() || stderr,
-            code: typeof err.code === "number" ? err.code : 1,
+            resolve(timedOut ? { stdout: stdout.text(), stderr: `${stderr.text()}\n${stopped}`.trimStart(),
+                output: `${output()}\n${stopped}`.trimStart(), code: 1, timedOut: true }
+                : { stdout: stdout.text(), stderr: stderr.text(), output: output(), code: code ?? 1 });
         };
-    }
+        const timer = setTimeout(() => {
+            if (exited)
+                return;
+            timedOut = true;
+            stop("SIGTERM");
+            setTimeout(() => stop("SIGKILL"), 10_000).unref?.();
+            graceTimer = setTimeout(() => settle(null), 20_000);
+        }, timeoutMs);
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => { stdout.append(chunk); collect("stdout")(chunk); });
+        child.stderr?.on("data", (chunk) => { stderr.append(chunk); collect("stderr")(chunk); });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            if (typeof error.code === "string") {
+                settled = true;
+                cleanup();
+                reject(error);
+            }
+            else {
+                if (!stderr.text())
+                    stderr.append(error.message);
+                settle(1);
+            }
+        });
+        child.on("close", (code) => settle(code));
+        child.on("exit", (code) => {
+            exited = true;
+            clearTimeout(timer);
+            drainTimer = setTimeout(() => settle(code), STDIO_DRAIN_MS);
+        });
+    });
 }
 /**
  * Bridge may attach genuine command output; it must not invent which criteria that output proves.

package/dist/execution.js

@@ -23,7 +23,7 @@ import { formatResetMinute, parseQuotaResetAt } from "./quota-reset.js";
 import { headCommitOrNull } from "./git.js";
 import { BRIDGE_PROTOCOL_VERSION } from "./preflight.js";
 import { bridgeVersion } from "./version.js";
-import { PULL_REQUEST_OPEN_FAILURE_PREFIX, commitsMatch, ensureDeliveryPullRequest } from "./ensure-pull-request.js";
+import { CONTROL_PLANE_TRANSIENT_PREFIX, PULL_REQUEST_OPEN_FAILURE_PREFIX, commitsMatch, ensureDeliveryPullRequest } from "./ensure-pull-request.js";
 import { checkpointWorkInProgress, ensureLandCommit } from "./ensure-land-commit.js";
 import { AGENT_NO_LAND_COMMIT_PREFIX, AgentNoLandCommitError, agentNoLandCommitMessage, requiresLandCommit } from "./land-contract.js";
 import { agentClaimsRepositoryWork, claimsVsGitMismatch, isLandTreeEmpty, reportClaimsRepositoryWork, } from "./land-git-reality.js";
@@ -219,6 +219,8 @@ const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_wr
 export function classifyFinalizeFailure(message) {
     if (forgeTransportFailure(message))
         return { retryable: true, error: message, failure: bridgeCause("forge_unreachable", message) };
+    if (message.startsWith(CONTROL_PLANE_TRANSIENT_PREFIX))
+        return { retryable: true, error: message };
     // The control plane refused to open the change request — no forge connection resolves for this
     // organization or project, or the task's repository is not one that connection can open a change
     // request on. No retry and no rework can supply a connection. The cause travels as an envelope so
@@ -1800,6 +1802,19 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                     acceptance: spec.acceptance ?? [],
                 })
                 : null;
+            if (capturedVerification?.timedOut) {
+                retainAttemptWorktree = true;
+                const response = await queueTerminal(client, taskId, { action: "fail", body: {
+                        error: capturedVerification.detail,
+                        retryable: false,
+                        signal: verificationGateTimeoutSignal({ command: capturedVerification.command,
+                            stderr: capturedVerification.stderr ?? "", stdout: capturedVerification.stdout ?? "" }),
+                        idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
+                    } });
+                retainAttemptWorktree = response.retain_worktree === true;
+                console.error(`Assignment ${taskId} verification gate did not finish: ${redactSecrets(capturedVerification.detail)}`);
+                return;
+            }
             const verificationDetail = capturedVerification?.detail ?? null;
             // The vendor named the model as the cause, so the model is what the retry must change. The
             // model rides in the prefix: the control plane cannot read Bridge's selection any other way.
@@ -2750,7 +2765,8 @@ async function prepareDelivery(client, attemptId, taskId, report) {
     const fuelMode = client.attempt(taskId).fuelMode;
     const evidence = [];
     const evidenceByCriterion = new Map();
-    for (const [index, item] of report.evidence.entries()) {
+    for (const [index, evidenceItem] of report.evidence.entries()) {
+        const item = redactSecretsDeep(evidenceItem);
         const uri = item.uri ?? `urn:conduit:attempt:${attemptId}:evidence:${index + 1}`;
         // Publication receipts require a digest on every acceptance artifact. Textual agent
         // evidence has no file to hash, so default to a canonical content digest of the
@@ -3001,6 +3017,7 @@ export async function runDeliveryVerificationGates(input) {
             results.push({
                 command,
                 exitCode: result.code,
+                timedOut: result.timedOut === true,
                 stdoutTail: boundedTail(result.stdout, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
                 stderrTail: boundedTail(result.stderr, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
             });
@@ -3011,6 +3028,7 @@ export async function runDeliveryVerificationGates(input) {
             results.push({
                 command,
                 exitCode: -1,
+                timedOut: false,
                 stdoutTail: "",
                 stderrTail: boundedTail(message, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
             });

package/dist/integration-obligations.js

@@ -41,7 +41,7 @@ export function parseIntegrationObligations(value) {
 async function symbolReferencedFrom(workspace, symbol, globs) {
     const pathspecs = globs.map((glob) => `:(glob)${glob}`);
     try {
-        const { stdout } = await execFileAsync("git", ["-C", workspace, "grep", "-l", "-F", "--untracked", symbol, "--", ...pathspecs], { timeout: 30_000, maxBuffer: 4_000_000 });
+        const { stdout } = await execFileAsync("git", ["-C", workspace, "grep", "-l", "-F", "--untracked", "-e", symbol, "--", ...pathspecs], { timeout: 30_000, maxBuffer: 4_000_000 });
         return stdout.trim().length > 0;
     }
     catch (error) {

package/dist/investigation.js

@@ -5,7 +5,7 @@
  * held to repo_read + test_run by the same driver projection that enforces read-only diagnosis, and
  * the worktree it reads is deleted whichever way the run ends.
  */
-import { redactSecrets } from "./secret-redaction.js";
+import { redactSecrets, redactSecretsDeep } from "./secret-redaction.js";
 import { z } from "zod";
 import { boundedTail, runBoundedVerificationCommand } from "./ensure-test-evidence.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
@@ -191,9 +191,10 @@ function formatGatesRunBlock(gates) {
         return `${header}\n- none`;
     return `${header}\n${gates.map((gate) => {
         const tail = gate.stderrTail.trim() || gate.stdoutTail.trim();
+        const verdict = gate.timedOut ? "did not finish (stopped by Bridge)" : `exit ${gate.exitCode}`;
         return tail
-            ? `- ${gate.command} — exit ${gate.exitCode}\n  ${tail.replace(/\n/g, "\n  ")}`
-            : `- ${gate.command} — exit ${gate.exitCode}`;
+            ? `- ${gate.command} — ${verdict}\n  ${tail.replace(/\n/g, "\n  ")}`
+            : `- ${gate.command} — ${verdict}`;
     }).join("\n")}`;
 }
 function gateFailureLine(tail) {
@@ -444,8 +445,8 @@ function sourceProbeVerdict(exitCode, stdout) {
         return "fails";
     return "broken";
 }
-function testProbeVerdict(ran, exitCode) {
-    if (!ran)
+function testProbeVerdict(ran, exitCode, timedOut) {
+    if (!ran || timedOut)
         return "broken";
     return exitCode === 0 ? "holds" : "fails";
 }
@@ -553,12 +554,14 @@ export async function runDeliveryVerificationProbes(input) {
             let stdout = "";
             let stderr = "";
             let ran = false;
+            let timedOut = false;
             try {
                 const result = await (input.runCommand ?? runBoundedVerificationCommand)(named, input.workspace);
                 exitCode = result.code;
                 stdout = result.stdout;
                 stderr = result.stderr;
                 ran = true;
+                timedOut = result.timedOut === true;
             }
             catch (error) {
                 stderr = error instanceof Error ? error.message : String(error);
@@ -566,7 +569,7 @@ export async function runDeliveryVerificationProbes(input) {
             }
             witnesses.push(witnessRecord({
                 key: probe.key, kind: "test", command: named, exitCode, stdout, stderr, checks,
-                verdict: testProbeVerdict(ran, exitCode),
+                verdict: testProbeVerdict(ran, exitCode, timedOut),
             }));
             continue;
         }
@@ -688,7 +691,10 @@ export async function runDeliveryVerificationProbesForAttempt(input) {
 async function settle(client, investigationId, body) {
     await client.request(`/runner/v1/investigations/${investigationId}/settle`, {
         method: "POST",
-        body: JSON.stringify(body),
+        body: JSON.stringify({ ...body,
+            ...(body.result !== undefined ? { result: redactSecretsDeep(body.result) } : {}),
+            ...(body.error !== undefined ? { error: redactSecrets(body.error) } : {}),
+        }),
     });
 }
 /**
@@ -901,7 +907,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
                 limitations: observed.limitations,
                 criteria: observed.criteria,
                 command_failures: deliveryVerification
-                    ? gatesRun.filter((gate) => gate.exitCode !== 0).map(gateFailureFact).slice(0, 10)
+                    ? gatesRun.filter((gate) => gate.exitCode !== 0 && !gate.timedOut).map(gateFailureFact).slice(0, 10)
                     : observed.command_failures,
                 step_witness: stepWitness,
                 no_behaviour: deliveryVerification ? observed.no_behaviour : [],

package/dist/land-git-reality.js

@@ -18,7 +18,7 @@ export async function isLandTreeEmpty(input) {
     const ahead = await countAhead(input.workspace, base);
     if (ahead !== null && ahead > 0)
         return false;
-    const pending = filterPathsInScope(await (input.listUncommittedPaths ?? listUncommittedPaths)(input.workspace), input.spec.change_scope ?? []);
+    const pending = filterPathsInScope(await (input.listUncommittedPaths ?? ((workspace) => listUncommittedPaths(workspace, { untracked: "all" })))(input.workspace), input.spec.change_scope ?? []);
     return pending.length === 0;
 }
 function deliveryObjectClaimsWork(raw) {

package/dist/normative-refs.js

@@ -197,7 +197,7 @@ function isConduitPath(path) {
     return normalized === ".conduit" || normalized.startsWith(".conduit/");
 }
 async function markerPresent(workspace, marker, paths) {
-    const args = ["-C", workspace, "grep", "-l", "-F", "--untracked", marker, "--", ...paths];
+    const args = ["-C", workspace, "grep", "-l", "-F", "--untracked", "-e", marker, "--", ...paths];
     try {
         const { stdout } = await execFileAsync("git", args, {
             timeout: 30_000,

package/package.json

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