@miraland-labs/conduit-bridge 0.16.112 → 0.16.114

package/dist/cli.js

@@ -655,13 +655,6 @@ async function runner() {
                 await heartbeat(client, config, workspace, currentBrief, preflight, intentProof, bootstrapResult);
             }
             await renewLeases(client, config);
-            if (workspace && onlineDriverIds(config).length) {
-                // Observation runs before authoring: an owner waiting on an answer should not queue behind
-                // a long delivery, and the control plane already counted this slot as busy.
-                progressed = await executeNextInvestigation(client, config, workspace, brief, timeoutMs, {
-                    managedRoot: hb.on_shift?.managed_workspace_root ?? null,
-                }) || progressed;
-            }
             if (workspace && onlineDriverIds(config).length) {
                 // Read the workspace again, then publish it. The last brief stands if the read fails.
                 const publishWorkspaceState = async (options = {}) => {
@@ -671,6 +664,15 @@ async function runner() {
                     const hb = await heartbeat(client, config, workspace, currentBrief, preflight, undefined, bootstrapResult);
                     return { preflight, hb };
                 };
+                // Observation runs before authoring: an owner waiting on an answer should not queue behind
+                // a long delivery, and the control plane already counted this slot as busy.
+                progressed = await executeNextInvestigation(client, config, workspace, brief, timeoutMs, {
+                    managedRoot: hb.on_shift?.managed_workspace_root ?? null,
+                    heartbeat: async () => {
+                        await publishWorkspaceState();
+                    },
+                    heartbeatIntervalMs: intervalMs,
+                }) || progressed;
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: async () => {
                         await publishWorkspaceState();

package/dist/investigation.js

@@ -16,7 +16,7 @@ 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";
@@ -100,6 +100,8 @@ export const DELIVERY_VERIFICATION_HEADER = "DELIVERY VERIFICATION";
 export const DELIVERY_VERIFICATION_PROBE_INSTRUCTION = 'For every BRIEF KEY that states behaviour, add one entry to probes: either {"key":"[sN]","test":"<registered command that asserts it>","checks":"<one line: what it proves>"} or {"key":"[sN]","lang":"ts|py|sh","source":"<a short script that exits 0 only when the key holds at this commit and non-zero otherwise; it may import repository modules by absolute path from the working directory>","checks":"<one line>"}. You do not run probes; Bridge runs them after you finish. Keys that state no behaviour (wording, scope, docs) get no probe.';
 const BRIEF_JSON_EXAMPLE = '{"summary":"one paragraph: what the change does and whether it meets the criteria","findings":["grounded fact with file/symbol"],"verification":["command — result"],"limitations":["what you could not settle"],"criteria":[{"criterion":"c1","assessment":"supported|unsupported|unclear","reason":"what you saw"}],"command_failures":["command that exited non-zero — the decisive output line"],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}';
 const BRIEF_JSON_EXAMPLE_WITH_PROBES = '{"summary":"one paragraph: what the change does and whether it meets the criteria","findings":["grounded fact with file/symbol"],"verification":["command — result"],"limitations":["what you could not settle"],"criteria":[{"criterion":"c1","assessment":"supported|unsupported|unclear","reason":"what you saw"}],"command_failures":["command that exited non-zero — the decisive output line"],"probes":[],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}';
+/** Named in both prompts so the lane knows each list's maximum before it writes. */
+export const BRIEF_LIMITS_SENTENCE = "Limits: findings at most 12, verification at most 8, limitations at most 8, criteria at most 40, command_failures at most 10, commands_run at most 10, probes at most 20. Keep the most decisive entries.";
 export function isDeliveryVerification(assignment) {
     return assignment.question.trimStart().startsWith(DELIVERY_VERIFICATION_HEADER);
 }
@@ -121,6 +123,7 @@ export function buildInvestigationPrompt(assignment, commit, context) {
         "",
         "Return only one fenced ```json object with exactly this shape:",
         '{"summary":"direct answer to the question","findings":["grounded fact with file/symbol"],"verification":["command you actually ran"],"limitations":["what you could not settle"],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}',
+        BRIEF_LIMITS_SENTENCE,
         "summary is a string; the other list fields are arrays of strings. Close the fence and add no prose after it.",
     ].join("\n");
 }
@@ -164,6 +167,7 @@ export function buildDeliveryVerificationPrompt(assignment, commit, context) {
         "",
         "Return only one fenced ```json object with exactly this shape:",
         keys.length ? BRIEF_JSON_EXAMPLE_WITH_PROBES : BRIEF_JSON_EXAMPLE,
+        BRIEF_LIMITS_SENTENCE,
         keys.length
             ? "criteria has one entry per ACCEPTANCE key. probes has at most 20 entries, one per BRIEF KEY that states behaviour. Close the fence and add no prose after it."
             : "criteria has one entry per ACCEPTANCE key. Close the fence and add no prose after it.",
@@ -208,6 +212,83 @@ function settleCommandsRun(gates, reported) {
 export const UNUSABLE_BRIEF = "Investigation returned no usable brief";
 /** T130: how much of an unusable reply travels with the failure, so the next run can be diagnosed. */
 const UNUSABLE_BRIEF_TAIL_CHARS = 800;
+const BRIEF_SUMMARY_MAX = 4_000;
+const BRIEF_ITEM_MAX = 1_000;
+const BRIEF_FILES_READ_MAX = 24;
+const BRIEF_BYTES_READ_MAX = 512 * 1024;
+const BRIEF_COMMAND_RUN_MAX = 200;
+const BRIEF_LIST_MAX = {
+    findings: 12,
+    verification: 8,
+    limitations: 8,
+    criteria: 40,
+    command_failures: 10,
+    commands_run: 10,
+    probes: 20,
+};
+function clipBriefText(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}
+function clipBriefStringField(record, key, max) {
+    const value = record[key];
+    if (typeof value === "string")
+        record[key] = clipBriefText(value, max);
+}
+function fitBriefStrings(items, max) {
+    return items.map((item) => typeof item === "string" ? clipBriefText(item, max) : item);
+}
+function fitCriteriaItems(items) {
+    return items.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return item;
+        const row = { ...item };
+        clipBriefStringField(row, "criterion", BRIEF_ITEM_MAX);
+        clipBriefStringField(row, "reason", BRIEF_ITEM_MAX);
+        return row;
+    });
+}
+/**
+ * Cut an over-full brief to the contract before schema parse. Only size is fitted; a wrong type,
+ * a missing summary, or an unknown assessment still fails as today. Probe entries are kept as
+ * written — clipping them would change what Bridge later executes.
+ */
+export function fitBriefToContract(candidate) {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+        return { fitted: candidate, cuts: [] };
+    }
+    const brief = { ...candidate };
+    const cuts = [];
+    const fitNamedList = (key, fitItems) => {
+        const value = brief[key];
+        if (!Array.isArray(value))
+            return;
+        const max = BRIEF_LIST_MAX[key];
+        if (value.length > max)
+            cuts.push({ list: key, kept: max, total: value.length });
+        brief[key] = fitItems(value.slice(0, max));
+    };
+    fitNamedList("findings", (items) => fitBriefStrings(items, BRIEF_ITEM_MAX));
+    fitNamedList("verification", (items) => fitBriefStrings(items, BRIEF_ITEM_MAX));
+    fitNamedList("limitations", (items) => fitBriefStrings(items, BRIEF_ITEM_MAX));
+    fitNamedList("criteria", fitCriteriaItems);
+    fitNamedList("command_failures", (items) => fitBriefStrings(items, BRIEF_ITEM_MAX));
+    fitNamedList("commands_run", (items) => fitBriefStrings(items, BRIEF_COMMAND_RUN_MAX));
+    fitNamedList("probes", (items) => items);
+    clipBriefStringField(brief, "summary", BRIEF_SUMMARY_MAX);
+    if (typeof brief.files_read === "number" && brief.files_read > BRIEF_FILES_READ_MAX) {
+        brief.files_read = BRIEF_FILES_READ_MAX;
+    }
+    if (typeof brief.bytes_read === "number" && brief.bytes_read > BRIEF_BYTES_READ_MAX) {
+        brief.bytes_read = BRIEF_BYTES_READ_MAX;
+    }
+    if (cuts.length) {
+        const notes = cuts.map((cut) => clipBriefText(`Bridge kept the first ${cut.kept} of ${cut.total} ${cut.list}`, BRIEF_ITEM_MAX));
+        const existing = Array.isArray(brief.limitations) ? [...brief.limitations] : [];
+        const room = Math.max(0, BRIEF_LIST_MAX.limitations - notes.length);
+        brief.limitations = [...existing.slice(0, room), ...notes];
+    }
+    return { fitted: brief, cuts };
+}
 /**
  * T130: an unusable brief used to fail with five words. The first production verification retry
  * (2026-09-09, acme-sim / forge R20) returned "no usable brief" twice and nobody could say whether the
@@ -222,7 +303,7 @@ export function parseInvestigationBrief(text) {
     catch {
         throw new Error(`${UNUSABLE_BRIEF}: no JSON object in the reply. Reply tail: ${redactSecrets(boundedTail(text, UNUSABLE_BRIEF_TAIL_CHARS))}`);
     }
-    const parsed = investigationBriefSchema.safeParse(candidate);
+    const parsed = investigationBriefSchema.safeParse(fitBriefToContract(candidate).fitted);
     if (!parsed.success) {
         const issues = parsed.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
         throw new Error(`${UNUSABLE_BRIEF}: the JSON does not match the brief contract (${issues}). Reply tail: ${redactSecrets(boundedTail(text, UNUSABLE_BRIEF_TAIL_CHARS))}`);
@@ -274,6 +355,47 @@ 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) {
@@ -364,6 +486,7 @@ function witnessRecord(input) {
         tail: probeTail(input.stderr, input.stdout),
         checks: clipWitnessField(input.checks, PROBE_CHECKS_MAX),
         verdict: input.verdict,
+        instrument: "running",
     };
 }
 /**
@@ -438,6 +561,109 @@ export async function runDeliveryVerificationProbes(input) {
     }
     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, reason) {
+    const tail = boundedTail(`${DELIVERED_PROBE_SELF_CHECK_TAIL}: ${reason}`, PROBE_TAIL_CHARS);
+    return stampInstrument(witnesses.map((witness) => ({
+        ...witness,
+        verdict: "broken",
+        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));
+    let selfCheckDetail = null;
+    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");
+        }
+        selfCheckDetail = `gave ${check.map((witness) => witness.verdict).join(", ")}`;
+    }
+    catch (error) {
+        selfCheckDetail = redactSecrets(error instanceof Error ? error.message : String(error));
+    }
+    return markSelfCheckBroken(await runRunning(), selfCheckDetail ?? "");
+}
 async function settle(client, investigationId, body) {
     await client.request(`/runner/v1/investigations/${investigationId}/settle`, {
         method: "POST",
@@ -533,6 +759,19 @@ export async function executeNextInvestigation(client, config, workspace, brief,
         }).catch((error) => console.error(`Investigation ${assignment.id} lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
     }, options.renewIntervalMs ?? INVESTIGATION_RENEW_INTERVAL_MS);
     renewTimer.unref?.();
+    let heartbeatRunning = false;
+    const heartbeat = options.heartbeat;
+    const heartbeatTimer = heartbeat
+        ? setInterval(() => {
+            if (heartbeatRunning)
+                return;
+            heartbeatRunning = true;
+            void heartbeat()
+                .catch((error) => console.error(`Heartbeat failed during investigation: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`))
+                .finally(() => { heartbeatRunning = false; });
+        }, options.heartbeatIntervalMs ?? 15_000)
+        : null;
+    heartbeatTimer?.unref?.();
     try {
         attemptWorkspace = await createAttemptWorktree({
             sourceWorkspace: workspace,
@@ -602,10 +841,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)
@@ -651,6 +892,8 @@ export async function executeNextInvestigation(client, config, workspace, brief,
     }
     finally {
         clearInterval(renewTimer);
+        if (heartbeatTimer)
+            clearInterval(heartbeatTimer);
         if (attemptWorkspace) {
             await removeAttemptWorktree(workspace, attemptWorkspace)
                 .catch((error) => console.error(`Investigation worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));

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.112",
+  "version": "0.16.114",
   "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": {