@miraland-labs/conduit-bridge 0.16.147 → 0.16.149

package/dist/ensure-test-evidence.js

@@ -208,7 +208,7 @@ export async function captureVerificationFailure(input) {
         // 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);
+        const text = boundedFailureDetail(command, outputLines(result), result.code, DIAGNOSIS_DETAIL_MAX_CHARS);
         if (text.trim())
             return { command, detail: text };
     }
@@ -232,18 +232,49 @@ const TAIL_HEAD_CHARS = 200;
  *
  * Returns the input unchanged when it already fits, so nothing short is ever decorated.
  */
-export function boundedDetailLines(lines, maxLines) {
+export function boundedDetailLines(lines, maxLines, identifiers = []) {
     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;
+    const middle = lines.slice(head, lines.length - tail);
+    // A criterion such as "its output shows privileged_wallet_holds_the_plan_without_payment as ok"
+    // is proved by one line in the middle of a long suite, and a reviewer must not infer it from the
+    // summary. So the lines that name an identifier the criteria name are kept too, in run order. The
+    // cap keeps a broad identifier that matches every line from storing the whole run.
+    const named = identifiers.length === 0
+        ? []
+        : [...new Set(middle.filter((line) => identifiers.some((id) => line.includes(id))))]
+            .slice(0, NAMED_DETAIL_LINES_MAX)
+            .map((line) => (line.length > 500 ? `${line.slice(0, 500)}…` : line));
+    const dropped = middle.length - named.length;
     return [
         ...lines.slice(0, head),
         `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`,
+        ...named,
         ...lines.slice(lines.length - tail),
     ];
 }
+const NAMED_DETAIL_LINES_MAX = 40;
+/**
+ * The test and symbol names the acceptance criteria name: every backticked string, and every
+ * snake_case, camelCase, dotted or `::` token of at least 8 characters. An ordinary English word has
+ * none of `_`, `::`, `.` or an inner capital, so it never counts.
+ */
+function criterionIdentifiers(acceptance) {
+    const found = new Set();
+    for (const criterion of acceptance) {
+        for (const match of criterion.matchAll(/`([^`]+)`/g)) {
+            if (match[1].trim())
+                found.add(match[1].trim());
+        }
+        for (const [token] of criterion.matchAll(/[A-Za-z_][A-Za-z0-9_]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_]*)*/g)) {
+            if (token.length >= 8 && /_|::|\.|[a-z0-9][A-Z]/.test(token))
+                found.add(token);
+        }
+    }
+    return [...found];
+}
 /**
  * Shorten a raw diagnostic message while keeping the end.
  *
@@ -263,6 +294,14 @@ export function boundedTail(text, maxChars) {
         return text.slice(text.length - maxChars);
     return `${text.slice(0, head)}${marker}${text.slice(text.length - tail)}`;
 }
+/**
+ * The lines of a run in the order the command wrote them. A run without the combined output (a
+ * test's fake runner) reads as stdout followed by stderr.
+ */
+function outputLines(result) {
+    const split = (text) => (text.trim() ? text.trim().split("\n") : []);
+    return result.output === undefined ? [...split(result.stdout), ...split(result.stderr)] : split(result.output);
+}
 /**
  * A failure detail that keeps the part which explains the failure.
  *
@@ -275,10 +314,13 @@ export function boundedTail(text, maxChars) {
  * So: the command line for orientation, a few opening lines, then the **tail**, and the exit code
  * always. What was dropped is stated rather than silently vanishing, because a reader must be able
  * to tell a short failure from a truncated one.
+ *
+ * The lines are in the order the command wrote them. Joining all stdout before all stderr made the
+ * tail of a failed `cargo test` its stderr `Running …` lines and elided the panic on stdout.
  */
-export function boundedFailureDetail(command, stdoutLines, stderrLines, code, maxChars = FAILURE_DETAIL_MAX_CHARS) {
+export function boundedFailureDetail(command, lines, code, maxChars = FAILURE_DETAIL_MAX_CHARS) {
     const cap = (line) => (line.length > 500 ? `${line.slice(0, 500)}…` : line);
-    const body = [...stdoutLines, ...stderrLines].map(cap);
+    const body = lines.map(cap);
     const first = `$ ${command}`;
     const last = `exit ${code}`;
     const marker = (dropped) => `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`;
@@ -322,20 +364,36 @@ export function boundedFailureDetail(command, stdoutLines, stderrLines, code, ma
  *
  * A gate the timeout stopped did not exit: `timedOut` says so, and stderr ends with the limit it
  * reached. Read as exit 1, a gate that hung on the untouched base was a red base on the author.
+ *
+ * `output` is stdout and stderr together, in the order the lines arrived: a failure detail reads its
+ * tail from it.
  */
 export async function runBoundedVerificationCommand(command, workspace, timeoutMs = VERIFICATION_TIMEOUT_MS) {
     const argv = argvForBoundedCommand(command);
     const bin = argv[0];
     if (!bin)
         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 collect = (stream) => (chunk) => {
+        const parts = `${partial[stream]}${String(chunk)}`.split("\n");
+        partial[stream] = parts.pop() ?? "";
+        lines.push(...parts);
+    };
+    const output = () => [...lines, ...[partial.stdout, partial.stderr].filter(Boolean)].join("\n");
     try {
-        const { stdout, stderr } = await execFileAsync(bin, argv.slice(1), {
+        const pending = execFileAsync(bin, argv.slice(1), {
             cwd: workspace,
             timeout: timeoutMs,
             maxBuffer: VERIFICATION_MAX_BUFFER_BYTES,
             env: process.env,
         });
-        return { stdout: String(stdout), stderr: String(stderr), code: 0 };
+        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;
@@ -347,9 +405,11 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         if (typeof err.code === "string")
             throw error;
         if (err.killed === true) {
+            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 ?? "")}\nBridge stopped the gate: it did not exit within ${Math.round(timeoutMs / 1_000)} seconds.`.trimStart(),
+                stderr: `${String(err.stderr ?? "")}\n${stopped}`.trimStart(),
+                output: `${output()}\n${stopped}`.trimStart(),
                 code: 1,
                 timedOut: true,
             };
@@ -358,6 +418,7 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         return {
             stdout: String(err.stdout ?? ""),
             stderr,
+            output: output() || stderr,
             code: typeof err.code === "number" ? err.code : 1,
         };
     }
@@ -536,12 +597,12 @@ export async function ensureTestEvidence(input) {
         // and would otherwise be witnessed as a passing test run that tested nothing.
         const ranNothing = detectGateRanNothing(command, result.stdout, result.stderr, result.code);
         if (ranNothing) {
-            const detail = boundedFailureDetail(command, stdoutLines, stderrLines, result.code);
+            const detail = boundedFailureDetail(command, outputLines(result), result.code);
             throw new VerificationGateRanNothingError(command, result.code, ranNothing, detail);
         }
         if (result.code !== 0) {
             // Prefix must match FINALIZE_CONTRACT_PATTERN ("Agent report") — not Bridge-fault laundering.
-            const detail = boundedFailureDetail(command, stdoutLines, stderrLines, result.code);
+            const detail = boundedFailureDetail(command, outputLines(result), 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.
@@ -563,11 +624,10 @@ export async function ensureTestEvidence(input) {
         }
         const rawDetails = [
             `$ ${command}`,
-            ...stdoutLines,
-            ...stderrLines,
+            ...outputLines(result),
             `exit ${result.code}`,
         ].map((line) => line.slice(0, 4_000));
-        const details = boundedDetailLines(rawDetails, 100);
+        const details = boundedDetailLines(rawDetails, 100, criterionIdentifiers(acceptance));
         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

@@ -526,7 +526,9 @@ export function buildDiagnosticPrompt(input) {
         ...(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")}`] : []),
         ...(gate ? ["", `GATE — Bridge re-runs \`${gate}\` after the next run; the agent cannot change or replace it.`
-                + " If the fix is not in the agent's hands, answer confident:false and name the gate in root_cause."] : []),
+                + " 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."
+                + " Answer confident:false only when no file change can fix the cause (the gate itself, the environment), and name the gate in root_cause."] : []),
         "",
         "WITNESSED FAILURE OUTPUT",
         redactSecrets(input.failureOutput),

package/package.json

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