@miraland-labs/conduit-bridge 0.16.111 → 0.16.113

package/dist/investigation.js

@@ -16,13 +16,22 @@ import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from ".
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { diffStatSince } from "./git-witness.js";
 import { switchManagedWorkspace } from "./on-shift-apply.js";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { isRunnableVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
+const tsxLoader = (() => {
+    try {
+        return createRequire(import.meta.url).resolve("tsx");
+    }
+    catch {
+        return "tsx";
+    }
+})();
 const budgetSchema = z.object({
     max_files: z.number().int().min(1).max(24).optional().default(8),
     max_duration_ms: z.number().int().min(10_000).max(15 * 60_000).optional().default(5 * 60_000),
@@ -265,6 +274,70 @@ const PROBE_MAX = 20;
 const PROBE_COMMAND_MAX = 300;
 const PROBE_CHECKS_MAX = 500;
 const PROBE_KEY_MAX = 40;
+export const BRIDGE_PACKAGE_NAME = "@miraland-labs/conduit-bridge";
+export const BRIDGE_SRC_PREFIX = "packages/conduit-bridge/src/";
+export const PROBE_RUN_ENTRY = "packages/conduit-bridge/src/probe-run.ts";
+export const DELIVERED_PROBE_SELF_CHECK_TAIL = "delivered probe instrument failed its self-check";
+export const KNOWN_ANSWER_PROBES = [
+    { key: "[known-holds]", lang: "sh", source: "echo 'PROBE HOLDS'\nexit 0", checks: "known answer: holds" },
+    { key: "[known-fails]", lang: "sh", source: "echo 'PROBE FAILS'\nexit 1", checks: "known answer: fails" },
+];
+/**
+ * True when this is Conduit's own repository and a changed path between base and the delivered
+ * commit is under the Bridge source. Git errors are not a change: the running instrument stays.
+ */
+export async function probeInstrumentChanged(workspace, baseCommit, commit) {
+    if (baseCommit === null)
+        return false;
+    try {
+        const { stdout: raw } = await execFileAsync("git", ["show", `${commit}:packages/conduit-bridge/package.json`], {
+            cwd: workspace,
+            timeout: 30_000,
+            maxBuffer: 1_000_000,
+        });
+        const name = JSON.parse(raw).name;
+        if (name !== BRIDGE_PACKAGE_NAME)
+            return false;
+        const { stdout: diff } = await execFileAsync("git", ["diff", "--name-only", `${baseCommit}..${commit}`], {
+            cwd: workspace,
+            timeout: 30_000,
+            maxBuffer: 8_000_000,
+        });
+        return diff.split("\n").some((path) => {
+            const trimmed = path.trim();
+            return trimmed === "packages/conduit-bridge/src" || trimmed.startsWith(BRIDGE_SRC_PREFIX);
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export function knownAnswerProbesPassed(witnesses) {
+    return witnesses.length === 2 && witnesses[0]?.verdict === "holds" && witnesses[1]?.verdict === "fails";
+}
+const PROBE_HOLDS_LINE = "PROBE HOLDS";
+const PROBE_FAILS_LINE = "PROBE FAILS";
+function lastNonEmptyLine(text) {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    return lines.at(-1) ?? "";
+}
+function sourceProbeVerdict(exitCode, stdout) {
+    const last = lastNonEmptyLine(stdout);
+    if (exitCode === 0 && last === PROBE_HOLDS_LINE)
+        return "holds";
+    if (exitCode === 1 && last === PROBE_FAILS_LINE)
+        return "fails";
+    return "broken";
+}
+function testProbeVerdict(ran, exitCode) {
+    if (!ran)
+        return "broken";
+    return exitCode === 0 ? "holds" : "fails";
+}
+function probeTail(stderr, stdout) {
+    const stderrTail = stderr.length > PROBE_TAIL_CHARS ? stderr.slice(stderr.length - PROBE_TAIL_CHARS) : stderr;
+    return boundedTail(`${stderrTail}\n${stdout}`, PROBE_TAIL_CHARS);
+}
 function probeEnv() {
     const env = {};
     if (process.env.PATH !== undefined)
@@ -282,14 +355,14 @@ function probeInterpreter(language) {
 }
 function probeFilename(language) {
     if (language === "ts")
-        return "probe.ts";
+        return "probe.mts";
     if (language === "py")
         return "probe.py";
     return "probe.sh";
 }
 function probeArgv(language, file) {
     if (language === "ts")
-        return ["node", "--import", "tsx", file];
+        return ["node", "--import", tsxLoader, file];
     if (language === "py")
         return ["python3", file];
     return ["bash", file];
@@ -314,9 +387,11 @@ async function execProbe(argv, workspace) {
         const err = error;
         if (typeof err.code === "string")
             throw error;
+        const stdout = String(err.stdout ?? "");
+        const stderr = String(err.stderr ?? "");
         return {
-            stdout: String(err.stdout ?? ""),
-            stderr: String(err.stderr || err.message || "probe failed"),
+            stdout,
+            stderr: stdout === "" && stderr === "" ? String(err.message || "probe failed") : stderr,
             code: err.killed === true || typeof err.code !== "number" ? -1 : err.code,
         };
     }
@@ -327,8 +402,10 @@ function witnessRecord(input) {
         kind: input.kind,
         command: clipWitnessField(input.command, PROBE_COMMAND_MAX),
         exit_code: input.exitCode,
-        tail: boundedTail(`${input.stderr.trim()}\n${input.stdout.trim()}`.trim(), PROBE_TAIL_CHARS),
+        tail: probeTail(input.stderr, input.stdout),
         checks: clipWitnessField(input.checks, PROBE_CHECKS_MAX),
+        verdict: input.verdict,
+        instrument: "running",
     };
 }
 /**
@@ -346,17 +423,20 @@ export async function runDeliveryVerificationProbes(input) {
             if (!isRunnableVerificationCommand(named)) {
                 witnesses.push(witnessRecord({
                     key: probe.key, kind: "test", command: named, exitCode: -1, stdout: "", stderr: "not a registered command", checks,
+                    verdict: "broken",
                 }));
                 continue;
             }
             let exitCode = -1;
             let stdout = "";
             let stderr = "";
+            let ran = false;
             try {
                 const result = await (input.runCommand ?? runBoundedVerificationCommand)(named, input.workspace);
                 exitCode = result.code;
                 stdout = result.stdout;
                 stderr = result.stderr;
+                ran = true;
             }
             catch (error) {
                 stderr = error instanceof Error ? error.message : String(error);
@@ -364,6 +444,7 @@ export async function runDeliveryVerificationProbes(input) {
             }
             witnesses.push(witnessRecord({
                 key: probe.key, kind: "test", command: named, exitCode, stdout, stderr, checks,
+                verdict: testProbeVerdict(ran, exitCode),
             }));
             continue;
         }
@@ -394,10 +475,111 @@ export async function runDeliveryVerificationProbes(input) {
         }
         witnesses.push(witnessRecord({
             key: probe.key, kind: "probe", command, exitCode, stdout, stderr, checks,
+            verdict: sourceProbeVerdict(exitCode, stdout),
         }));
     }
     return witnesses;
 }
+const deliveredWitnessSchema = z.object({
+    witnesses: z.array(z.object({
+        key: z.string(),
+        kind: z.enum(["test", "probe"]),
+        command: z.string(),
+        exit_code: z.number(),
+        tail: z.string(),
+        checks: z.string(),
+        verdict: z.enum(["holds", "fails", "broken"]),
+        instrument: z.enum(["running", "delivered"]).optional(),
+    }).passthrough()),
+});
+function stampInstrument(witnesses, instrument) {
+    return witnesses.map((witness) => ({ ...witness, instrument }));
+}
+function markSelfCheckBroken(witnesses) {
+    return stampInstrument(witnesses.map((witness) => ({
+        ...witness,
+        verdict: "broken",
+        tail: DELIVERED_PROBE_SELF_CHECK_TAIL,
+    })), "running");
+}
+function toStepWitness(witness) {
+    return {
+        key: witness.key,
+        kind: witness.kind,
+        command: witness.command,
+        exit_code: witness.exit_code,
+        tail: witness.tail,
+        checks: witness.checks,
+        verdict: witness.verdict,
+        instrument: witness.instrument === "delivered" ? "delivered" : "running",
+    };
+}
+async function execDeliveredProbeRun(argv, stdin, workspace, timeoutMs) {
+    const [file, ...args] = argv;
+    if (!file)
+        throw new Error("delivered probe command is empty");
+    return await new Promise((resolve, reject) => {
+        const child = spawn(file, args, {
+            cwd: workspace,
+            env: probeEnv(),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => { stdout += String(chunk); });
+        child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? -1, stdout, stderr });
+        });
+        child.stdin?.on("error", () => undefined);
+        child.stdin?.end(stdin);
+    });
+}
+export async function runDeliveredProbeInstrument(input) {
+    const entry = join(input.workspace, PROBE_RUN_ENTRY);
+    const timeoutMs = PROBE_TIMEOUT_MS * (input.probes.length + 1);
+    const stdin = JSON.stringify({ probes: input.probes });
+    const argv = ["node", "--import", tsxLoader, entry];
+    const result = await (input.exec ?? execDeliveredProbeRun)(argv, stdin, input.workspace, timeoutMs);
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || `delivered probe-run exited ${result.code}`);
+    }
+    try {
+        return stampInstrument(deliveredWitnessSchema.parse(JSON.parse(result.stdout)).witnesses.map(toStepWitness), "delivered");
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("delivered probe instrument returned no witness list");
+    }
+}
+export async function runDeliveryVerificationProbesForAttempt(input) {
+    const runRunning = () => runDeliveryVerificationProbes({
+        workspace: input.workspace,
+        probes: input.probes,
+        runCommand: input.runCommand,
+    });
+    if (!input.instrumentChanged) {
+        return stampInstrument(await runRunning(), "running");
+    }
+    const runDelivered = input.runDeliveredProbes ?? ((args) => runDeliveredProbeInstrument(args));
+    try {
+        const check = await runDelivered({ workspace: input.workspace, probes: KNOWN_ANSWER_PROBES });
+        if (knownAnswerProbesPassed(check)) {
+            return stampInstrument(await runDelivered({ workspace: input.workspace, probes: input.probes }), "delivered");
+        }
+    }
+    catch {
+        // Known-answer failure and a delivered-instrument throw take the same path: running probes, then broken.
+    }
+    return markSelfCheckBroken(await runRunning());
+}
 async function settle(client, investigationId, body) {
     await client.request(`/runner/v1/investigations/${investigationId}/settle`, {
         method: "POST",
@@ -562,10 +744,12 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             return true;
         }
         const stepWitness = deliveryVerification
-            ? await runDeliveryVerificationProbes({
+            ? await runDeliveryVerificationProbesForAttempt({
                 workspace: attemptWorkspace,
                 probes: observed.probes ?? [],
+                instrumentChanged: await probeInstrumentChanged(attemptWorkspace, assignment.base_commit, commit),
                 runCommand: options.runProbeCommand,
+                runDeliveredProbes: options.runDeliveredProbes,
             })
             : [];
         if (deliveryVerification)

package/dist/probe-run.js

@@ -0,0 +1,28 @@
+/** Delivered probe instrument entry. `{ "probes": [...] }` on stdin, `{ witnesses }` on stdout. */
+import { z } from "zod";
+import { runDeliveryVerificationProbes } from "./investigation.js";
+const probeRunInputSchema = z.object({
+    probes: z.array(z.object({
+        key: z.string().trim().min(1).max(40),
+        test: z.string().max(300).optional(),
+        lang: z.enum(["ts", "py", "sh"]).optional(),
+        source: z.string().max(8_000).optional(),
+        checks: z.string().max(500).optional().default(""),
+    })).max(20),
+});
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+try {
+    const parsed = probeRunInputSchema.parse(JSON.parse(await readStdin()));
+    const witnesses = await runDeliveryVerificationProbes({ workspace: process.cwd(), probes: parsed.probes });
+    process.stdout.write(`${JSON.stringify({ witnesses })}\n`);
+}
+catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+}

package/package.json

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