@miraland-labs/conduit-bridge 0.11.10 → 0.11.11

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/package.json

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