@miraland-labs/conduit-bridge 0.11.10 → 0.11.12

package/dist/brief.js

@@ -8,7 +8,8 @@ const MANIFESTS = [
     "Cargo.toml", "pyproject.toml", "pytest.ini", "setup.cfg", "go.mod",
     "Makefile", "build.gradle", "build.gradle.kts", "gradlew",
 ];
-const VERIFICATION_SCRIPTS = ["verify", "typecheck", "lint", "test", "build"];
+/** Prefer test before typecheck/lint so discovery order matches what pickVerificationCommand wants. */
+const VERIFICATION_SCRIPTS = ["test", "verify", "typecheck", "lint", "build"];
 const EXCLUDED_DIRECTORIES = new Set(["node_modules", "dist", "build", "target", "coverage", ".venv", "venv"]);
 export async function buildWorkspaceBrief(workspace) {
     const entries = await readdir(workspace, { withFileTypes: true });
@@ -208,7 +209,7 @@ export async function discoverVerificationCommands(workspace, files) {
     if (files.has("Makefile")) {
         try {
             const makefile = await readFile(join(workspace, "Makefile"), "utf8");
-            for (const target of ["check", "test"])
+            for (const target of ["test", "check"])
                 if (new RegExp(`^${target}\\s*:`, "m").test(makefile))
                     commands.push(`make ${target}`);
         }

package/dist/driver.js

@@ -225,6 +225,9 @@ function sanitizeReportShape(raw) {
             // Drop non-URL / empty uris so an optional bad uri doesn't fail the whole report.
             if ("uri" in evidence && (typeof evidence.uri !== "string" || !z.string().url().max(4_000).safeParse(evidence.uri).success))
                 delete evidence.uri;
+            // Witness is Bridge-authored provenance. An agent claiming it must not survive parse.
+            if ("witness" in evidence)
+                delete evidence.witness;
         }
     }
     // Same rule for optional top-level scalars: null/"" means absent, not invalid.

package/dist/ensure-test-evidence.js

@@ -1,30 +1,31 @@
 /**
- * When the contract requires test evidence and the agent forgot to paste command output,
- * Bridge runs one bounded verification command and attaches the verbatim result — same
- * mechanical-land pattern as ensureDeliveryPullRequest.
+ * When the contract requires test evidence, Bridge runs one bounded verification
+ * command and attaches the verbatim result. Agent prose may supplement that run;
+ * it never substitutes for it.
  */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isBoundedVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const TEST_EVIDENCE_DETAILS_MIN = 32;
-export function needsTestEvidence(report, spec, grants) {
+/** Contract requires test + test_run — Bridge always runs; agent paste is not a substitute. */
+export function needsTestEvidence(_report, spec, grants) {
     if (!grants.includes("test_run"))
         return false;
-    if (!(spec.required_evidence ?? []).includes("test"))
-        return false;
-    const existing = report.evidence.filter((item) => item.kind === "test");
-    if (existing.length === 0)
-        return true;
-    return existing.every((item) => item.details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN);
+    return (spec.required_evidence ?? []).includes("test");
+}
+/**
+ * Prefer real test runners over typecheck/lint/build/verify so `required_evidence: ["test"]`
+ * is not satisfied by a silent `npm run typecheck`.
+ */
+export function isPreferentialTestCommand(command) {
+    return /^(npm run test|pnpm test|yarn test|cargo test|go test(?: \.\/\.\.\.)?|make test|python -m pytest|pytest(?: [\w./=-]+)?|\.\/gradlew test)$/.test(command.trim());
 }
 export function pickVerificationCommand(commands) {
-    for (const command of commands) {
-        const trimmed = command.trim();
-        if (trimmed && isBoundedVerificationCommand(trimmed))
-            return trimmed;
-    }
-    return null;
+    const bounded = commands
+        .map((command) => command.trim())
+        .filter((command) => command && isBoundedVerificationCommand(command));
+    return bounded.find(isPreferentialTestCommand) ?? bounded[0] ?? null;
 }
 function argvForBoundedCommand(command) {
     return command.trim().split(/\s+/);
@@ -70,8 +71,8 @@ export function criteriaForTestEvidence(report) {
     return [...mapped];
 }
 /**
- * If test evidence is required and missing/thin, run one bounded verification command
- * in the attempt workspace and attach verbatim stdout/stderr.
+ * If test evidence is required, run one bounded verification command in the attempt workspace
+ * and attach verbatim stdout/stderr with a Bridge witness marker.
  */
 export async function ensureTestEvidence(input) {
     if (!needsTestEvidence(input.report, input.spec, input.grants))
@@ -82,26 +83,32 @@ export async function ensureTestEvidence(input) {
     }
     const run = input.runCommand ?? defaultRunCommand;
     const result = await run(command, input.workspace);
-    // Silent success is valid for bounded targets like `make test` (`@test -f …` prints nothing).
-    // Still record an explicit no-output line so control-plane verbatim-detail checks pass.
     const stdoutLines = result.stdout.trim() ? result.stdout.trim().split("\n") : [];
     const stderrLines = result.stderr.trim() ? result.stderr.trim().split("\n") : [];
+    if (result.code !== 0) {
+        // Prefix must match FINALIZE_CONTRACT_PATTERN ("Agent report") — not Bridge-fault laundering.
+        const failedDetails = [
+            `$ ${command}`,
+            ...stdoutLines,
+            ...stderrLines,
+            `exit ${result.code}`,
+        ].map((line) => line.slice(0, 4_000)).slice(0, 100);
+        throw new Error(`Agent report: Verification failed (${command}): ${failedDetails.join("\n").slice(0, 2_000)}`);
+    }
+    // Empty exit-0 is not proof — a no-op recipe (`@true`) must not clear required_evidence: test.
+    if (stdoutLines.length === 0 && stderrLines.length === 0) {
+        throw new Error(`Agent report: Verification produced no output for test evidence (${command}). A bounded test command must print observable stdout or stderr.`);
+    }
     const details = [
         `$ ${command}`,
         ...stdoutLines,
         ...stderrLines,
-        ...(stdoutLines.length === 0 && stderrLines.length === 0
-            ? ["(no stdout/stderr — command exited with the status below)"]
-            : []),
         `exit ${result.code}`,
     ].map((line) => line.slice(0, 4_000)).slice(0, 100);
-    if (result.code !== 0) {
-        // Prefix must match FINALIZE_CONTRACT_PATTERN ("Agent report") — not Bridge-fault laundering.
-        throw new Error(`Agent report: Verification failed (${command}): ${details.join("\n").slice(0, 2_000)}`);
-    }
     if (details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN) {
         throw new Error(`Agent report: Verification produced insufficient output for test evidence (${command})`);
     }
+    // Keep agent test prose as supplement; Bridge witness is the authoritative entry.
     const withoutThinTest = input.report.evidence.filter((item) => {
         if (item.kind !== "test")
             return true;
@@ -119,6 +126,7 @@ export async function ensureTestEvidence(input) {
                 name: command,
                 details,
                 acceptance_criteria: criteriaForTestEvidence(input.report),
+                witness: "bridge",
             },
         ],
     };

package/dist/execution.js

@@ -558,8 +558,8 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            // classifyFinalizeFailure: contract/environment → non-retryable; forge transport → retryable;
-            // unknown faults stay retryable as "Bridge finalize interrupted" (not laundered as contract).
+            // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail closed
+            // (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
             const classified = classifyFinalizeFailure(message);
             await queueTerminal(client, taskId, {
                 action: "fail",
@@ -729,7 +729,11 @@ async function prepareDelivery(client, attemptId, taskId, report) {
             .digest("hex")}`);
         const response = await client.attemptRequest(taskId, "artifacts", {
             kind: item.kind, name: item.name, uri, digest,
-            metadata: { details: item.details, acceptance_criteria: item.acceptance_criteria },
+            metadata: {
+                details: item.details,
+                acceptance_criteria: item.acceptance_criteria,
+                ...(item.witness === "bridge" ? { witness: "bridge" } : {}),
+            },
             idempotency_key: `bridge:artifact:${attemptId}:${index + 1}`,
         });
         const artifactId = z.string().uuid().parse(response.artifact_id);

package/dist/mcp.js

@@ -42,7 +42,13 @@ export function createBridgeMcpServer(client) {
     server.registerTool("claim_assignment", { description: "Claim an assignment and store its lease", inputSchema: { task_id: z.string().uuid(), attempt_id: z.string().uuid() } }, async ({ task_id, attempt_id }) => result(await client.claim(task_id, attempt_id)));
     server.registerTool("report_progress", { description: "Report the current execution phase and concise observable progress", inputSchema: { task_id: z.string().uuid(), phase: executionPhaseSchema, message: z.string().min(1), idempotency_key: z.string().min(1) } }, async (input) => result(await client.attemptRequest(input.task_id, "progress", { phase: input.phase, message: input.message, idempotency_key: input.idempotency_key })));
     server.registerTool("raise_question", { description: "Raise a structured blocker for human judgment", inputSchema: { task_id: z.string().uuid(), question: z.string().min(1), impact: z.string().min(1), options: z.array(z.string()).default([]), recommendation: z.string().optional(), idempotency_key: z.string().min(1) } }, async (input) => result(await client.attemptRequest(input.task_id, "blockers", input)));
-    server.registerTool("add_artifact", { description: "Attach external delivery evidence metadata", inputSchema: { task_id: z.string().uuid(), kind: z.string().min(1), name: z.string().min(1), uri: z.string().url(), digest: z.string().optional(), metadata: z.record(z.unknown()).optional(), idempotency_key: z.string().min(1) } }, async (input) => result(await client.attemptRequest(input.task_id, "artifacts", input)));
+    server.registerTool("add_artifact", { description: "Attach external delivery evidence metadata", inputSchema: { task_id: z.string().uuid(), kind: z.string().min(1), name: z.string().min(1), uri: z.string().url(), digest: z.string().optional(), metadata: z.record(z.unknown()).optional(), idempotency_key: z.string().min(1) } }, async (input) => {
+        // Witness is Bridge-authored after a real command run — never accept an agent-claimed stamp.
+        const metadata = input.metadata && typeof input.metadata === "object"
+            ? Object.fromEntries(Object.entries(input.metadata).filter(([key]) => key !== "witness"))
+            : input.metadata;
+        return result(await client.attemptRequest(input.task_id, "artifacts", { ...input, metadata }));
+    });
     server.registerTool("submit_delivery", { description: "Submit a structured Delivery Packet for human acceptance", inputSchema: { task_id: z.string().uuid(), packet: deliveryPacketSchema, evidence: z.array(z.object({ artifact_id: z.string().uuid(), kind: z.string() })).default([]), idempotency_key: z.string().min(1) } }, async (input) => result(await client.attemptRequest(input.task_id, "complete", { delivery_packet: input.packet, evidence: input.evidence, idempotency_key: input.idempotency_key })));
     server.registerTool("fail_assignment", { description: "Report a terminal failed attempt", inputSchema: { task_id: z.string().uuid(), error: z.string().min(1), idempotency_key: z.string().min(1) } }, async (input) => result(await client.attemptRequest(input.task_id, "fail", input)));
     return server;

package/dist/on-shift-apply.js

@@ -1,6 +1,8 @@
 /**
  * Phase 2: when Connect queued a workspace intent, Bridge applies it once
- * (ops.env + install/restart) then acks so the next LaunchAgent start uses the new path.
+ * (ops.env + install/restart) then acks. Ack runs only after install succeeds so a
+ * failed apply leaves the intent queued for the next heartbeat (manual ops switch remains fallback).
+ * After a successful restart, currentWorkspace matches the target so we do not re-apply.
  */
 import { resolve } from "node:path";
 import { homedir } from "node:os";
@@ -41,12 +43,13 @@ export async function maybeApplyOnShiftIntent(input) {
             ...(repo ? { CONDUIT_REPO: repo } : {}),
         });
     }
-    // Ack before restart so a rebound service does not re-apply forever.
+    console.log(`Applying on-shift workspace intent: ${target}${repo ? ` (${repo})` : ""}`);
+    await input.runInstall(target, repo);
+    // Ack only after install succeeds. A rebound service that already matches the target
+    // short-circuits above and will not re-apply; Bound clears any leftover intent.
     await input.client.request("/runner/v1/machine/ack-on-shift-intent", {
         method: "POST",
         body: "{}",
     });
-    console.log(`Applying on-shift workspace intent: ${target}${repo ? ` (${repo})` : ""}`);
-    await input.runInstall(target, repo);
     return true;
 }

package/dist/ops.js

@@ -243,13 +243,6 @@ export async function runOps(verb, argv = [], deps = {}) {
             CONDUIT_WORKSPACE: workspace,
             ...(repo ? { CONDUIT_REPO: repo } : {}),
         });
-        // Local apply owns the checkout; clear queued intent so heartbeat does not re-apply.
-        try {
-            await client.request("/runner/v1/machine/ack-on-shift-intent", { method: "POST", body: "{}" });
-        }
-        catch {
-            // Older control planes omit ack — local ops.env still wins.
-        }
         console.log(`Updated ${envPath}`);
         console.log(`On-shift workspace: ${workspace}${repo ? ` (${repo})` : ""}`);
         // Same install path as ops install — restart runner against the new checkout.
@@ -262,6 +255,13 @@ export async function runOps(verb, argv = [], deps = {}) {
                 CONDUIT_REPO: repo || switched.CONDUIT_REPO,
             },
         });
+        // Clear queued intent only after install succeeds so a failed apply can retry via heartbeat.
+        try {
+            await client.request("/runner/v1/machine/ack-on-shift-intent", { method: "POST", body: "{}" });
+        }
+        catch {
+            // Older control planes omit ack — local ops.env still wins.
+        }
         return;
     }
     if (verb === "connect") {

package/dist/service.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { realpathSync } from "node:fs";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 export const SERVICE_LABEL = "io.miraland.conduit-runner";
 function configDir() {
     return join(homedir(), ".config", "conduit");
@@ -118,6 +118,22 @@ function run(command, args) {
         throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
     }
 }
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+ * `launchctl bootout` of a loaded service kills that service's whole process group — including
+ * this process when install-service runs from inside the runner it replaces (Connect on-shift
+ * auto-apply). Observed in the field (2026-08-05): the runner died at bootout, the bootstrap on
+ * the next line never ran, and the machine stayed Binding incomplete with the service unloaded.
+ * The swap therefore runs in a detached helper that survives the bootout; failures append to the
+ * runner log.
+ */
+export function launchdSwapCommand(domain, plistPath, log) {
+    const plist = shellQuote(plistPath);
+    const logQ = shellQuote(log);
+    return `sleep 1; launchctl bootout ${domain}/${SERVICE_LABEL} 2>>${logQ}; launchctl bootstrap ${domain} ${plist} 2>>${logQ} || launchctl load -w ${plist} 2>>${logQ}`;
+}
 export async function installRunnerService(options = {}) {
     const host = platform();
     if (host !== "darwin" && host !== "linux") {
@@ -129,12 +145,19 @@ export async function installRunnerService(options = {}) {
         await mkdir(dirname(plistPath), { recursive: true });
         await mkdir(dirname(logPath()), { recursive: true });
         await writeFile(plistPath, launchdPlist(programArguments, logPath()), { mode: 0o644 });
-        // Prefer modern bootout/bootstrap; fall back to load for older macOS.
-        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${SERVICE_LABEL}`], { encoding: "utf8" });
-        const boot = spawnSync("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, plistPath], { encoding: "utf8" });
-        if (boot.status !== 0) {
-            run("launchctl", ["load", "-w", plistPath]);
+        // Detached helper (bootout → bootstrap → load fallback): see launchdSwapCommand for why the
+        // swap must survive this process dying at bootout.
+        const domain = `gui/${process.getuid?.() ?? 501}`;
+        spawn("/bin/sh", ["-c", launchdSwapCommand(domain, plistPath, logPath())], { detached: true, stdio: "ignore" }).unref();
+        // Confirm the reloaded service when this process survives to see it (an interactive install).
+        // A self-replacing runner dies at the helper's bootout and the helper still finishes the swap.
+        let loaded = false;
+        for (let attempt = 0; attempt < 16 && !loaded; attempt++) {
+            await new Promise((resolveSleep) => setTimeout(resolveSleep, attempt === 0 ? 2000 : 500));
+            loaded = spawnSync("launchctl", ["print", `${domain}/${SERVICE_LABEL}`], { encoding: "utf8" }).status === 0;
         }
+        if (!loaded)
+            throw new Error(`launchd did not load ${SERVICE_LABEL}; see ${logPath()}`);
         await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "darwin", programArguments, options, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
         return { path: plistPath, platform: "darwin" };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.11.10",
+  "version": "0.11.12",
   "description": "Conduit Bridge CLI — join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity agents for a Conduit organization",
   "type": "module",
   "bin": {