@miraland-labs/conduit-bridge 0.11.7 → 0.11.10

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. */
@@ -334,7 +335,7 @@ async function initOps() {
     console.log(`Config file (separate): ${envPath}`);
     console.log("");
     console.log("Works the same on macOS, Linux, and Windows via:");
-    console.log(`  ${bridgeUsage("ops", "<connect|install|online|offline|status|disconnect|uninstall>")}`);
+    console.log(`  ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|disconnect|uninstall>")}`);
     console.log("");
     console.log("1. Edit env once:");
     console.log(`   Create folder: ${configDir}`);
@@ -358,7 +359,7 @@ async function initOps() {
 async function opsCommand() {
     const verb = process.argv[3];
     if (!verb || !OPS_VERBS.includes(verb)) {
-        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")}`);
+        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")}`);
     }
     await runOps(verb, process.argv.slice(4));
 }
@@ -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/ensure-pull-request.js

@@ -5,6 +5,7 @@
  */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { normalizeRepositoryUrl } from "./brief.js";
 const execFileAsync = promisify(execFile);
 /** Mirror execution.ts FORGE_TRANSPORT_PATTERN — keep local to avoid import cycles. */
 const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
@@ -30,20 +31,54 @@ export function commitsMatch(reported, actual) {
         return false;
     return left === right || left.startsWith(right) || right.startsWith(left);
 }
+/** Forge owner/repo identity from a PR / merge-request URL (host/path form used as fingerprint). */
+export function fingerprintFromChangeRequestUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const github = parsed.pathname.match(/^\/([^/]+)\/([^/]+)\/pull\/\d+\/?$/i);
+        if (github)
+            return normalizeRepositoryUrl(`${parsed.host}/${github[1]}/${github[2]}`);
+        const gitlab = parsed.pathname.match(/^\/(.+)\/-\/merge_requests\/\d+\/?$/i);
+        if (gitlab)
+            return normalizeRepositoryUrl(`${parsed.host}/${gitlab[1]}`);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function pullRequestMatchesRepositoryFingerprint(url, repositoryFingerprint) {
+    if (!repositoryFingerprint)
+        return false;
+    const fromUrl = fingerprintFromChangeRequestUrl(url);
+    if (!fromUrl)
+        return false;
+    return fromUrl === normalizeRepositoryUrl(repositoryFingerprint);
+}
 /**
  * Agents often put the PR URL only on evidence.uri and omit pull_request_url.
- * Adopt it so finalize does not re-push and die on a forge blip after the PR already exists.
+ * Adopt it so finalize does not re-push and die on a forge blip after the PR already exists —
+ * but only when the URI is this work package's repository (Invariant 11).
  */
-export function adoptPullRequestUrlFromEvidence(report) {
-    if (report.pull_request_url && isAbsoluteHttpsUrl(report.pull_request_url))
+export function adoptPullRequestUrlFromEvidence(report, repositoryFingerprint) {
+    if (report.pull_request_url && isAbsoluteHttpsUrl(report.pull_request_url)) {
+        if (repositoryFingerprint
+            && !pullRequestMatchesRepositoryFingerprint(report.pull_request_url, repositoryFingerprint)) {
+            throw new Error("pull_request_url does not match the work package repository");
+        }
+        return report;
+    }
+    if (!repositoryFingerprint)
         return report;
     for (const item of report.evidence) {
         const uri = item.uri?.trim();
         if (!uri || !isAbsoluteHttpsUrl(uri))
             continue;
-        if (/\/(?:pull|merge_requests)\/\d+/i.test(uri)) {
-            return { ...report, pull_request_url: uri };
-        }
+        if (!/\/(?:pull|merge_requests)\/\d+/i.test(uri))
+            continue;
+        if (!pullRequestMatchesRepositoryFingerprint(uri, repositoryFingerprint))
+            continue;
+        return { ...report, pull_request_url: uri };
     }
     return report;
 }
@@ -122,7 +157,7 @@ export async function pushOriginHead(workspace, options = {}) {
 export async function ensureDeliveryPullRequest(input) {
     const readHead = input.readHeadCommit ?? workspaceHeadCommit;
     const push = input.pushOriginHead ?? pushOriginHead;
-    let report = adoptPullRequestUrlFromEvidence(input.report);
+    let report = adoptPullRequestUrlFromEvidence(input.report, input.repositoryFingerprint);
     if (report.head_commit && (input.spec.change_scope?.length ?? 0) > 0) {
         const head = await readHead(input.workspace);
         if (!commitsMatch(report.head_commit, head)) {

package/dist/ensure-test-evidence.js

@@ -52,11 +52,22 @@ async function defaultRunCommand(command, workspace) {
         };
     }
 }
-function criteriaForTestEvidence(report, spec) {
-    const fromSpec = (spec.acceptance ?? []).filter(Boolean);
-    if (fromSpec.length > 0)
-        return fromSpec;
-    return report.acceptance_results.map((item) => item.criterion);
+/**
+ * Bridge may attach genuine command output; it must not invent which criteria that output proves.
+ * Reuse only criteria the agent already mapped onto a test-kind evidence entry (including thin ones
+ * we are replacing). Empty mapping lets validateDeliveryReport reject met-without-evidence.
+ */
+export function criteriaForTestEvidence(report) {
+    const mapped = new Set();
+    for (const item of report.evidence) {
+        if (item.kind !== "test")
+            continue;
+        for (const criterion of item.acceptance_criteria ?? []) {
+            if (criterion)
+                mapped.add(criterion);
+        }
+    }
+    return [...mapped];
 }
 /**
  * If test evidence is required and missing/thin, run one bounded verification command
@@ -85,10 +96,11 @@ export async function ensureTestEvidence(input) {
         `exit ${result.code}`,
     ].map((line) => line.slice(0, 4_000)).slice(0, 100);
     if (result.code !== 0) {
-        throw new Error(`Verification failed (${command}): ${details.join("\n").slice(0, 2_000)}`);
+        // 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(`Verification produced insufficient output for test evidence (${command})`);
+        throw new Error(`Agent report: Verification produced insufficient output for test evidence (${command})`);
     }
     const withoutThinTest = input.report.evidence.filter((item) => {
         if (item.kind !== "test")
@@ -106,7 +118,7 @@ export async function ensureTestEvidence(input) {
                 kind: "test",
                 name: command,
                 details,
-                acceptance_criteria: criteriaForTestEvidence(input.report, input.spec),
+                acceptance_criteria: criteriaForTestEvidence(input.report),
             },
         ],
     };

package/dist/execution.js

@@ -544,6 +544,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 spec,
                 grants,
                 title: task.objective,
+                repositoryFingerprint: executionContract.repository_fingerprint,
             });
             // Mechanical test path: agent often forgets verbatim make test / npm test output.
             report = await ensureTestEvidence({

package/dist/on-shift-apply.js

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+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 } : {}),
+        });
+    }
+    // Ack before restart so a rebound service does not re-apply forever.
+    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

@@ -3,13 +3,15 @@
  * Invoked as: npx @miraland-labs/conduit-bridge ops <connect|install|…>
  */
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
 import { describePreflightIssue, runBridgePreflight } from "./preflight.js";
 export const OPS_VERBS = [
-    "connect", "install", "online", "offline", "status", "doctor", "disconnect", "uninstall",
+    "connect", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
 ];
 const LOCAL_FUEL_DRIVERS = new Set(["cursor", "pi", "kiro", "antigravity"]);
 export function defaultOpsEnvPath(home = homedir()) {
@@ -88,6 +90,36 @@ export function requireOpsEnv(env) {
 export function splitOpsList(value) {
     return value.split(/[,\s]+/).map((item) => item.trim()).filter(Boolean);
 }
+/** Update keys in an existing ops.env (or create from current values). Preserves comments/unknown keys when possible. */
+export function writeOpsEnvFile(path, patch, existingText) {
+    mkdirSync(dirname(path), { recursive: true });
+    const keys = ["CONDUIT_URL", "CONDUIT_ORG", "CONDUIT_WORKSPACE", "CONDUIT_REPO", "CONDUIT_DRIVERS", "CONDUIT_ROLES"];
+    const current = existingText ?? (existsSync(path) ? readFileSync(path, "utf8") : "");
+    const lines = current ? current.split(/\r?\n/) : [];
+    const seen = new Set();
+    const next = lines.map((raw) => {
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            return raw;
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            return raw;
+        const key = trimmed.slice(0, eq).trim();
+        if (!keys.includes(key))
+            return raw;
+        seen.add(key);
+        const value = patch[key];
+        if (value === undefined)
+            return raw;
+        return `${key}=${value}`;
+    });
+    for (const key of keys) {
+        if (seen.has(key) || patch[key] === undefined)
+            continue;
+        next.push(`${key}=${patch[key]}`);
+    }
+    writeFileSync(path, `${next.filter((line, index) => !(index === next.length - 1 && line === "")).join("\n").replace(/\n*$/, "\n")}`, { mode: 0o600 });
+}
 export function resolveDrivers(env, argv) {
     const fromArgs = argv.map((item) => item.trim()).filter(Boolean);
     const drivers = fromArgs.length ? fromArgs : splitOpsList(env.CONDUIT_DRIVERS);
@@ -175,6 +207,63 @@ export async function runOps(verb, argv = [], deps = {}) {
         return;
     }
     requireOpsEnv(env);
+    if (verb === "switch") {
+        const { values } = parseArgs({
+            args: argv,
+            options: {
+                project: { type: "string" },
+                workspace: { type: "string" },
+                repo: { type: "string" },
+            },
+            allowPositionals: true,
+        });
+        const projectId = values.project?.trim();
+        if (!projectId) {
+            throw new Error("Usage: ops switch --project <project-id> [--workspace <path>] [--repo <url>]");
+        }
+        const workspaceRaw = values.workspace?.trim() || env.CONDUIT_WORKSPACE;
+        if (!workspaceRaw)
+            throw new Error(`Set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()} or pass --workspace`);
+        const workspace = resolve(expandOpsValue(workspaceRaw));
+        const repo = (values.repo?.trim() || env.CONDUIT_REPO || "").trim();
+        const envPath = env.loadedFrom ?? defaultOpsEnvPath();
+        // Control plane first — do not rewrite ops.env if affinity replace fails.
+        const config = await (deps.loadBridgeConfig ?? loadConfig)();
+        const client = new ConduitClient(config);
+        const result = await client.request("/runner/v1/machine/switch-project", {
+            method: "POST",
+            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, {
+            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.
+        const switched = loadOpsEnv();
+        await runOps("install", [], {
+            ...deps,
+            env: {
+                ...switched,
+                CONDUIT_WORKSPACE: workspace,
+                CONDUIT_REPO: repo || switched.CONDUIT_REPO,
+            },
+        });
+        return;
+    }
     if (verb === "connect") {
         if (!env.CONDUIT_URL)
             throw new Error(`Set CONDUIT_URL in ${defaultOpsEnvPath()}`);

package/package.json

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