@miraland-labs/conduit-bridge 0.14.4 → 0.14.6

package/dist/cli.js

@@ -4,7 +4,7 @@ import { resolve, dirname, join as pathJoin } from "node:path";
 import { hostname, homedir, platform, userInfo } from "node:os";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { ConduitClient, ConduitRequestError } from "./client.js";
@@ -20,17 +20,8 @@ import { loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
 import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
 import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, unavailableWorkspacePreflight } from "./preflight.js";
+import { bridgeVersion } from "./version.js";
 const [command] = process.argv.slice(2);
-/** Read our own package version so every runner start logs exactly which build is live. */
-function bridgeVersion() {
-    try {
-        const packagePath = pathJoin(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-        return JSON.parse(readFileSync(packagePath, "utf8")).version ?? "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
 /** Install-free form shown in help/output so clean laptops never need `conduit` on PATH. */
 const BRIDGE_NPX = "npx @miraland-labs/conduit-bridge";
 function bridgeUsage(...args) {
@@ -305,7 +296,7 @@ async function installService() {
         agentTimeoutMinutes: values["agent-timeout-minutes"],
         ensureCheckout: values["ensure-checkout"],
     });
-    console.log(`Installed Conduit runner service (${result.platform}): ${result.path}`);
+    console.log(`Installed Conduit Bridge v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION}) runner service (${result.platform}): ${result.path}`);
     console.log(`Online lanes: ${onlineDriverIds(config).join(", ")}. Toggle with \`${bridgeUsage("drivers", "online|offline", "…")}\`.`);
     console.log("The runner keeps executing after this terminal closes. Laptop sleep still pauses work.");
 }
@@ -475,6 +466,11 @@ async function runner() {
                 ? await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined })
                 : unavailableWorkspacePreflight({ config });
             const hb = await heartbeat(client, config, currentBrief, preflight);
+            if (hb.staleBridge) {
+                console.error(`Bridge update required: running protocol ${BRIDGE_PROTOCOL_VERSION}; control plane requires protocol ${hb.requiredProtocol ?? "unknown"} (minimum Bridge ${hb.minimumVersion ?? "unknown"}). Reinstall the latest Bridge, then restart this runner.`);
+                await new Promise((resolveSleep) => setTimeout(resolveSleep, Math.max(intervalMs, 60_000)));
+                continue;
+            }
             const applied = await maybeApplyOnShiftIntent({
                 client,
                 currentWorkspace: workspace,
@@ -535,10 +531,18 @@ async function heartbeat(client, config, brief, preflight) {
             preflight,
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
+    const compatibility = response.bridge_compatibility && typeof response.bridge_compatibility === "object"
+        ? response.bridge_compatibility
+        : null;
     const onShift = response.on_shift && typeof response.on_shift === "object"
         ? response.on_shift
         : null;
-    return { on_shift: onShift };
+    return {
+        on_shift: onShift,
+        staleBridge: response.stale_bridge === true,
+        ...(typeof compatibility?.minimum_version === "string" ? { minimumVersion: compatibility.minimum_version } : {}),
+        ...(typeof compatibility?.required_protocol === "number" ? { requiredProtocol: compatibility.required_protocol } : {}),
+    };
 }
 async function disconnect() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: { yes: { type: "boolean", short: "y" } } });

package/dist/driver.js

@@ -227,7 +227,18 @@ export function parseAgentReport(text, acceptance) {
     if (new Set(reported).size !== reported.length || acceptance.some((criterion) => !reported.includes(criterion))) {
         throw new Error("Agent report must include every acceptance criterion exactly once");
     }
-    return { ...parsed.data, acceptance_results: parsed.data.acceptance_results.map((item) => ({ ...item, evidence_artifact_ids: [] })) };
+    // Missing evidence mappings cannot support a "met" claim. Preserve the evidence itself, but
+    // downgrade only the unsupported result to unknown so the existing quality loop can assess the
+    // completed work instead of throwing the whole implementation away.
+    const mappedCriteria = new Set(parsed.data.evidence.flatMap((item) => item.acceptance_criteria));
+    return {
+        ...parsed.data,
+        acceptance_results: parsed.data.acceptance_results.map((item) => ({
+            ...item,
+            status: item.status === "met" && !mappedCriteria.has(item.criterion) ? "unknown" : item.status,
+            evidence_artifact_ids: [],
+        })),
+    };
 }
 /**
  * Artifact publication receipts require `sha256:<64 hex>`. Agents often paste bare `shasum` output;
@@ -266,7 +277,11 @@ function sanitizeReportShape(raw) {
             const evidence = item;
             if ("details" in evidence)
                 evidence.details = cleanList(evidence.details);
-            if ("acceptance_criteria" in evidence)
+            // Experimental lanes have repeatedly omitted this list on otherwise-useful test evidence.
+            // An empty mapping asserts nothing; later logic downgrades any now-unsupported "met" result.
+            if (!("acceptance_criteria" in evidence) || evidence.acceptance_criteria == null)
+                evidence.acceptance_criteria = [];
+            else
                 evidence.acceptance_criteria = cleanList(evidence.acceptance_criteria);
             // Agents emit null/"" for optional fields they have no value for — treat as absent.
             if ("digest" in evidence && (typeof evidence.digest !== "string" || evidence.digest.trim() === ""))

package/dist/execution.js

@@ -912,7 +912,29 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 catch (repairError) {
                     parseError = repairError instanceof Error ? repairError.message : "Repaired delivery report was invalid";
                     if (repairTurn >= maxRepairs) {
-                        await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair exhausted: ${parseError}`, retryable: false, idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}` } });
+                        const detail = `Delivery report repair exhausted: ${parseError}`;
+                        // Implementation finished; only its response envelope is invalid. Preserve the exact
+                        // tree and identify this narrow condition so the control plane can prepare repair
+                        // guidance instead of discarding the work and asking the owner to debug JSON.
+                        retainAttemptWorktree = true;
+                        const response = await queueTerminal(client, taskId, {
+                            action: "fail",
+                            body: {
+                                error: detail,
+                                retryable: false,
+                                failure: {
+                                    code: "delivery_report_invalid",
+                                    class: "contract",
+                                    disposition: "rework",
+                                    responsible_party: "conduit",
+                                    message: "Conduit could not prepare a valid delivery report from the completed agent run.",
+                                    next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
+                                    diagnostic_detail: detail,
+                                },
+                                idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}`,
+                            },
+                        });
+                        retainAttemptWorktree = retainDiagnosticWorktree(response);
                         console.error(`Assignment ${taskId} exhausted its report-only repair: ${redactSecrets(parseError)}`);
                         const replyTail = previousReply.slice(-8_000);
                         console.error(`Assignment ${taskId} repaired reply tail (${previousReply.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);

package/dist/ops.js

@@ -11,11 +11,27 @@ import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
 import { detectInstalledClients } from "./detect.js";
 import { driverIdsFromDetectedLabels } from "./drivers.js";
-import { describePreflightIssue, runBridgePreflight } from "./preflight.js";
+import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
+import { bridgeVersion } from "./version.js";
 export const OPS_VERBS = [
     "connect", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
 ];
 const LOCAL_FUEL_DRIVERS = new Set(["cursor", "pi", "kiro", "antigravity"]);
+function bridgeVersionAtLeast(value, minimum) {
+    const parse = (input) => {
+        const match = /^(\d+)\.(\d+)\.(\d+)/.exec(input);
+        return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+    };
+    const actual = parse(value);
+    const required = parse(minimum);
+    if (!actual || !required)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+}
 export function defaultOpsEnvPath(home = homedir()) {
     return join(home, ".config", "conduit", "ops.env");
 }
@@ -177,6 +193,27 @@ export async function runOps(verb, argv = [], deps = {}) {
         return;
     }
     if (verb === "status") {
+        const packageVersion = bridgeVersion();
+        console.log(`Bridge: v${packageVersion} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
+        try {
+            const config = await (deps.loadBridgeConfig ?? loadConfig)();
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5_000);
+            let compatibility;
+            try {
+                compatibility = await new ConduitClient(config).request("/runner/v1/compatibility", { signal: controller.signal });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            const minimumVersion = typeof compatibility.minimum_version === "string" ? compatibility.minimum_version : "unknown";
+            const requiredProtocol = typeof compatibility.required_protocol === "number" ? compatibility.required_protocol : "unknown";
+            const compatible = minimumVersion === "unknown" || (bridgeVersionAtLeast(packageVersion, minimumVersion) && (requiredProtocol === "unknown" || BRIDGE_PROTOCOL_VERSION >= requiredProtocol));
+            console.log(`Control plane: requires Bridge ${minimumVersion} (protocol ${requiredProtocol})${compatible ? "" : " — UPDATE REQUIRED"}`);
+        }
+        catch {
+            console.log("Control plane: compatibility check unavailable (showing local Bridge only)");
+        }
         if (env.loadedFrom) {
             console.log(`Env: ${env.loadedFrom}`);
             console.log(`URL: ${env.CONDUIT_URL || "(unset)"}`);
@@ -368,6 +405,7 @@ export async function runOps(verb, argv = [], deps = {}) {
             const runnerArgs = ["runner", "--workspace", workspace];
             if (installEnv.CONDUIT_REPO)
                 runnerArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
+            console.log(`Bridge: v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
             console.log("Windows: background install-service is not available.");
             console.log("Keep a terminal open and run:");
             console.log(`  npx @miraland-labs/conduit-bridge@latest ${shellQuoteArgs(runnerArgs)}`);
@@ -377,6 +415,7 @@ export async function runOps(verb, argv = [], deps = {}) {
         const installArgs = ["install-service", "--workspace", workspace];
         if (installEnv.CONDUIT_REPO)
             installArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
+        console.log(`Bridge: v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
         console.log(`Installing runner for ${workspace} (drivers: ${drivers.join(", ")})`);
         runBridge(installArgs);
         console.log("Done. Check with: npx @miraland-labs/conduit-bridge@latest ops status");

package/dist/preflight.js

@@ -16,7 +16,9 @@ function modelsFingerprint(config) {
     }).join(";");
     return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
 }
-export const BRIDGE_PROTOCOL_VERSION = 4;
+// Protocol 5 makes the lease-token claim contract explicit. Older Bridges may report a green
+// preflight but cannot claim against the current control plane, so they must be admitted as stale.
+export const BRIDGE_PROTOCOL_VERSION = 5;
 const execFileAsync = promisify(execFile);
 async function defaultCommandRunner(command, args, cwd) {
     try {

package/dist/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Read the version of the Bridge package that is actually running. */
+export function bridgeVersion() {
+    try {
+        const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return JSON.parse(readFileSync(packagePath, "utf8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/package.json

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