@miraland-labs/conduit-bridge 0.16.150 → 0.16.152

package/dist/ensure-test-evidence.js

@@ -569,6 +569,23 @@ export class VerificationGateRanNothingError extends Error {
         this.vendorMessage = vendorMessage;
     }
 }
+/**
+ * A declared gate the verification timeout stopped after the agent run: it never exited, so it says
+ * nothing about the change. Carries the command and the output tails the timeout signal needs — the
+ * classifier holds this on the computer operator and never diagnoses or repairs it.
+ */
+export class VerificationGateTimedOutError extends Error {
+    command;
+    stdout;
+    stderr;
+    constructor(command, stdout, stderr, detail) {
+        super(`Agent report: Verification gate did not finish (${command}): ${detail}`);
+        this.name = "VerificationGateTimedOutError";
+        this.command = command;
+        this.stdout = stdout;
+        this.stderr = stderr;
+    }
+}
 /**
  * If test evidence is required, run the bounded verification commands in the attempt workspace
  * and attach verbatim stdout/stderr with Bridge witness markers.
@@ -593,6 +610,13 @@ export async function ensureTestEvidence(input) {
         const result = await run(command, input.workspace);
         const stdoutLines = result.stdout.trim() ? result.stdout.trim().split("\n") : [];
         const stderrLines = result.stderr.trim() ? result.stderr.trim().split("\n") : [];
+        // First, as in the dry run: a gate the timeout stopped never exited, so its partial output and
+        // exit code say nothing about the change. Read as a failed test, it sent a slow computer's
+        // timeout to diagnosis and repair (2026-10-10).
+        if (result.timedOut) {
+            const detail = boundedFailureDetail(command, outputLines(result), result.code);
+            throw new VerificationGateTimedOutError(command, result.stdout, result.stderr, detail);
+        }
         // Checked ahead of both the exit-code and the pass path: `go test` on an empty package exits 0
         // and would otherwise be witnessed as a passing test run that tested nothing.
         const ranNothing = detectGateRanNothing(command, result.stdout, result.stderr, result.code);

package/dist/execution.js

@@ -28,7 +28,7 @@ import { checkpointWorkInProgress, ensureLandCommit } from "./ensure-land-commit
 import { AGENT_NO_LAND_COMMIT_PREFIX, AgentNoLandCommitError, agentNoLandCommitMessage, requiresLandCommit } from "./land-contract.js";
 import { agentClaimsRepositoryWork, claimsVsGitMismatch, isLandTreeEmpty, reportClaimsRepositoryWork, } from "./land-git-reality.js";
 const execFileAsync = promisify(execFile);
-import { boundedTail, captureVerificationFailure, DeliveryReportDefectError, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationFailedError, VerificationGateRanNothingError, VERIFICATION_TIMEOUT_MS } from "./ensure-test-evidence.js";
+import { boundedTail, captureVerificationFailure, DeliveryReportDefectError, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationFailedError, VerificationGateRanNothingError, VerificationGateTimedOutError, VERIFICATION_TIMEOUT_MS } from "./ensure-test-evidence.js";
 import { ensureChangeEvidence } from "./ensure-change-evidence.js";
 import { ensureDemonstrationEvidence } from "./ensure-demonstration-evidence.js";
 import { ensureNormativeEvidence } from "./ensure-normative-evidence.js";
@@ -524,7 +524,10 @@ export function buildDiagnosticPrompt(input) {
         ...(acceptance.length ? ["", `APPROVED ACCEPTANCE CRITERIA\n${acceptance.map((item) => `- ${item}`).join("\n")}`] : []),
         ...(changeScope.length ? ["", `APPROVED CHANGE SCOPE\n${changeScope.map((item) => `- ${item}`).join("\n")}`] : []),
         ...(decisions.length ? ["", `OWNER DECISIONS\n${decisions.map((item) => `- ${item.question}: ${item.decision}`).join("\n")}`] : []),
-        ...(input.verificationCommands.length ? ["", `BOUNDED VERIFICATION COMMANDS\n${input.verificationCommands.map((item) => `- ${item}`).join("\n")}`] : []),
+        // The next authoring agent's shell accepts these commands and git, nothing else. A brief that
+        // prescribes another command (SV1b: `cargo run … > openapi.json`) sends that run into the same failure.
+        ...(input.verificationCommands.length ? ["", `BOUNDED VERIFICATION COMMANDS\n${input.verificationCommands.map((item) => `- ${item}`).join("\n")}`,
+            "The next authoring agent can edit files, but its shell accepts only these commands and git. fix_direction must not tell it to run any other command."] : []),
         ...(gate ? ["", `GATE — Bridge re-runs \`${gate}\` after the next run; the agent cannot change or replace it.`
                 + " A fix that needs a file outside the APPROVED CHANGE SCOPE is still a grounded diagnosis."
                 + " Answer confident:true and write the full repository path of each such file in fix_direction. Conductor makes it a scope decision."
@@ -2252,6 +2255,24 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             validateDeliveryReport(report, spec, grants, actualPaths ?? undefined, deliveryBaseCommit);
         }
         catch (error) {
+            // A gate the timeout stopped never exited, so nothing says the change is at fault: the same
+            // timeout signal the dry run emits, held on the computer operator — never a diagnosis or a
+            // repair brief. Task ce673ef1 (2026-10-10) ran two diagnoses on a CPU-starved `npm run test`.
+            if (error instanceof VerificationGateTimedOutError) {
+                const response = await queueTerminal(client, taskId, {
+                    action: "fail",
+                    body: {
+                        error: error.message,
+                        retryable: false,
+                        signal: verificationGateTimeoutSignal({ command: error.command, stderr: error.stderr, stdout: error.stdout }),
+                        ...(report.pull_request_url ? { pull_request_url: report.pull_request_url } : {}),
+                        idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
+                    },
+                });
+                retainAttemptWorktree = response.retain_worktree === true;
+                console.error(`Assignment ${taskId} verification gate did not finish: ${redactSecrets(error.message)}`);
+                return;
+            }
             // A gate that ran no tests is a misconfigured gate, not a failed verification: the delivery
             // pack may be entirely correct. Emit the T1 typed signal and Hold on the computer operator —
             // never a repair attempt or a blind retry, which is what burned six deliveries on 2026-09-04

package/dist/failure-signal.js

@@ -403,6 +403,9 @@ export function verificationRedBaseSignal(input) {
  * The signal Bridge emits when the verification timeout stops a gate on the base commit, before the
  * agent starts. The gate never exited, so it says nothing about the base: read as exit 1, a gate
  * that hung (waiting for input or the network, or on a slow computer) was a red base on the author.
+ *
+ * The delivery gate after the agent run emits it without a base commit: the gate ran on the change,
+ * and a gate that never exited says nothing about the change either.
  */
 export function verificationGateTimeoutSignal(input) {
     return {
@@ -410,7 +413,7 @@ export function verificationGateTimeoutSignal(input) {
         witness: "bridge",
         kind: "timeout",
         command: input.command,
-        base_commit: input.baseCommit,
+        ...(input.baseCommit ? { base_commit: input.baseCommit } : {}),
         exit_code: null,
         ...(input.stderr?.trim() ? { stderr_tail: bounded2k(input.stderr) } : {}),
         ...(input.stdout?.trim() ? { stdout_tail: bounded2k(input.stdout) } : {}),
@@ -562,13 +565,16 @@ export function classifyFailureSignal(signal) {
     // base commit nor a change is known to be at fault. The generic rule read it as a failed test.
     if (signal.phase === "verification" && signal.kind === "timeout") {
         const command = signal.command ?? "the declared gate";
-        const base = signal.base_commit ? shortCommit(signal.base_commit) : "the base commit";
+        // No base commit: the delivery gate after the agent run, on the agent's change.
+        const message = signal.base_commit
+            ? `The verification gate \`${command}\` did not finish on the base commit ${shortCommit(signal.base_commit)} within Bridge's 10-minute limit, so Bridge stopped it before any change was made.`
+            : `The verification gate \`${command}\` did not finish on the agent's change within Bridge's 10-minute limit, so Bridge stopped it before delivery.`;
         return {
             code: "verification_gate_timeout",
             class: "environment",
             disposition: "hold",
             responsible_party: "computer_operator",
-            message: `The verification gate \`${command}\` did not finish on the base commit ${base} within Bridge's 10-minute limit, so Bridge stopped it before any change was made.`,
+            message,
             next_action: `Run \`${command}\` on this computer and find where it hangs — a test that waits for input or the network, or a computer too slow for the gate — then fix it and Recheck. Conduit does not retry or repair a gate that does not finish.`,
             diagnostic_detail: [`$ ${command}`, "stopped after 10 minutes", signal.stderr_tail, signal.stdout_tail].filter(Boolean).join("\n"),
         };

package/package.json

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