@miraland-labs/conduit-bridge 0.11.9 → 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/cli.js

@@ -15,9 +15,10 @@ import { DRIVERS } from "./driver.js";
 import { driversHeartbeatReport, driverLabel, heartbeatStatusForDrivers, isSupportedDriverId, listDriverLanes, onlineDriverIds, seedDriversFromDetection, seedDriverLanes, setDriverFuel, setDriversOnline, } from "./drivers.js";
 import { buildWorkspaceBrief } from "./brief.js";
 import { ensureCheckout } from "./checkout.js";
+import { maybeApplyOnShiftIntent } from "./on-shift-apply.js";
+import { loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
 import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
-import { OPS_VERBS, runOps } from "./ops.js";
 import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, unavailableWorkspacePreflight } from "./preflight.js";
 const [command] = process.argv.slice(2);
 /** Read our own package version so every runner start logs exactly which build is live. */
@@ -473,7 +474,30 @@ async function runner() {
             const preflight = workspace
                 ? await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined })
                 : unavailableWorkspacePreflight({ config });
-            await heartbeat(client, config, currentBrief, preflight);
+            const hb = await heartbeat(client, config, currentBrief, preflight);
+            const applied = await maybeApplyOnShiftIntent({
+                client,
+                currentWorkspace: workspace,
+                onShift: hb.on_shift,
+                runInstall: async (nextWorkspace, repo) => {
+                    let env;
+                    try {
+                        env = loadOpsEnv();
+                    }
+                    catch {
+                        env = undefined;
+                    }
+                    await runOps("install", [], {
+                        env: env
+                            ? { ...env, CONDUIT_WORKSPACE: nextWorkspace, CONDUIT_REPO: repo || env.CONDUIT_REPO }
+                            : undefined,
+                    });
+                },
+            });
+            if (applied) {
+                console.log("On-shift workspace applied; exiting so the background service restarts on the new checkout.");
+                process.exit(0);
+            }
             await renewLeases(client, config);
             if (workspace && onlineDriverIds(config).length) {
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
@@ -500,7 +524,7 @@ async function runner() {
 async function heartbeat(client, config, brief, preflight) {
     const online = onlineDriverIds(config);
     const status = heartbeatStatusForDrivers(online);
-    await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
+    const response = await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
             status,
             capabilities: config.capabilities,
             lease_capacity: config.leaseCapacity,
@@ -511,6 +535,10 @@ async function heartbeat(client, config, brief, preflight) {
             preflight,
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
+    const onShift = response.on_shift && typeof response.on_shift === "object"
+        ? response.on_shift
+        : null;
+    return { on_shift: onShift };
 }
 async function disconnect() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: { yes: { type: "boolean", short: "y" } } });

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

@@ -0,0 +1,55 @@
+/**
+ * Phase 2: when Connect queued a workspace intent, Bridge applies it once
+ * (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";
+import { defaultOpsEnvPath, expandOpsValue, loadOpsEnv, writeOpsEnvFile } from "./ops.js";
+function pathsEqual(left, right) {
+    return resolve(expandOpsValue(left)) === resolve(expandOpsValue(right));
+}
+/**
+ * If control-plane intent names a different workspace than this runner, apply and return true
+ * (caller should exit so install-service / LaunchAgent restarts).
+ */
+export async function maybeApplyOnShiftIntent(input) {
+    const intentPath = input.onShift?.on_shift_intent?.workspace_path?.trim();
+    if (!intentPath)
+        return false;
+    const target = resolve(expandOpsValue(intentPath));
+    const current = input.currentWorkspace ? resolve(expandOpsValue(input.currentWorkspace)) : null;
+    if (current && pathsEqual(current, target)) {
+        // Already on the declared path — leave intent for Bound clear on heartbeat.
+        return false;
+    }
+    const repo = (input.onShift?.on_shift_intent?.repository_url
+        ?? input.onShift?.expected_repository
+        ?? "").trim();
+    if (input.writeEnv) {
+        input.writeEnv(target, repo);
+    }
+    else {
+        let envPath = defaultOpsEnvPath(homedir());
+        try {
+            envPath = loadOpsEnv().loadedFrom ?? envPath;
+        }
+        catch {
+            // First apply may create ops.env at the default path.
+        }
+        writeOpsEnvFile(envPath, {
+            CONDUIT_WORKSPACE: target,
+            ...(repo ? { CONDUIT_REPO: repo } : {}),
+        });
+    }
+    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: "{}",
+    });
+    return true;
+}

package/dist/ops.js

@@ -232,7 +232,11 @@ export async function runOps(verb, argv = [], deps = {}) {
         const client = new ConduitClient(config);
         const result = await client.request("/runner/v1/machine/switch-project", {
             method: "POST",
-            body: JSON.stringify({ project_id: projectId }),
+            body: JSON.stringify({
+                project_id: projectId,
+                workspace_path: workspace,
+                ...(repo ? { repository_url: repo } : {}),
+            }),
         });
         console.log(`Control plane on-shift: ${String(result.project_id ?? projectId)} (${String(result.binding_status ?? "pending")})`);
         writeOpsEnvFile(envPath, {
@@ -251,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.9",
+  "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": {