@miraland-labs/conduit-bridge 0.11.12 → 0.12.1

package/README.md

@@ -51,7 +51,7 @@ Optional local shortcuts after `init-ops` (same verbs):
 
 **Windows note:** `ops install` brings lanes online and prints a `runner --workspace …` command to keep open (no LaunchAgent). macOS/Linux install a background service.
 
-`ops.env` keys: `CONDUIT_URL`, `CONDUIT_ORG` (optional), `CONDUIT_WORKSPACE`, `CONDUIT_REPO` (optional), `CONDUIT_DRIVERS` (default `cursor`), `CONDUIT_ROLES` (default `implement research review`). Values expand `$HOME`, `%USERPROFILE%`, and `~`.
+`ops.env` keys: `CONDUIT_URL`, `CONDUIT_ORG` (optional), `CONDUIT_WORKSPACE`, `CONDUIT_REPO` (optional), `CONDUIT_DRIVERS` (default: auto-detect installed agents), `CONDUIT_ROLES` (default `implement research review`). Values expand `$HOME`, `%USERPROFILE%`, and `~`.
 
 ## Advanced CLI
 

package/dist/cli.js

@@ -359,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|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")}`);
+        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")} (install also takes --workspace <path> [--repo <url>])`);
     }
     await runOps(verb, process.argv.slice(4));
 }

package/dist/driver.js

@@ -139,17 +139,68 @@ export function buildAssignmentPrompt(context) {
     "- EVERY criterion you mark \"met\" must appear in the acceptance_criteria list of at least one evidence entry. A met criterion with no evidence mapped to it fails the whole delivery — mark it unknown instead, or add the evidence that supports it.", "", "When the work is finished, end your reply with exactly one fenced ```json block:", agentReportTemplate);
     return lines.join("\n");
 }
+/**
+ * Extract report JSON text from an agent reply. Prefers the last closed ```json fence,
+ * then an unclosed ```json fence (truncated replies), then a balanced top-level object.
+ */
+export function extractAgentReportJsonText(text) {
+    const closed = [...text.matchAll(/```json\s*([\s\S]*?)```/gi)];
+    const fromFence = closed.at(-1)?.[1]?.trim();
+    if (fromFence)
+        return fromFence;
+    const unclosed = /```json\s*([\s\S]*)$/i.exec(text);
+    const fromUnclosed = unclosed?.[1]?.trim();
+    if (fromUnclosed)
+        return fromUnclosed;
+    const start = text.lastIndexOf("{");
+    if (start < 0)
+        throw new Error("Agent did not emit the required structured report");
+    return text.slice(start).trim();
+}
+/** Parse JSON, or the first balanced `{...}` object when the candidate is truncated prose. */
+export function parseJsonObjectCandidate(candidate) {
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        const start = candidate.indexOf("{");
+        if (start < 0)
+            throw new Error("Agent emitted malformed report JSON");
+        let depth = 0;
+        let inString = false;
+        for (let i = start; i < candidate.length; i++) {
+            const ch = candidate[i];
+            if (inString) {
+                if (ch === "\\")
+                    i++;
+                else if (ch === '"')
+                    inString = false;
+            }
+            else if (ch === '"')
+                inString = true;
+            else if (ch === "{")
+                depth++;
+            else if (ch === "}" && --depth === 0) {
+                try {
+                    return JSON.parse(candidate.slice(start, i + 1));
+                }
+                catch {
+                    throw new Error("Agent emitted malformed report JSON");
+                }
+            }
+        }
+        throw new Error("Agent emitted malformed report JSON");
+    }
+}
 /** Parse the agent's final fenced JSON block into a bounded report. */
 export function parseAgentReport(text, acceptance) {
-    const blocks = [...text.matchAll(/```json\s*([\s\S]*?)```/g)];
-    const last = blocks.at(-1)?.[1];
-    if (!last)
-        throw new Error("Agent did not emit the required structured report");
     let raw;
     try {
-        raw = JSON.parse(last);
+        raw = parseJsonObjectCandidate(extractAgentReportJsonText(text));
     }
-    catch {
+    catch (error) {
+        if (error instanceof Error && /structured report|malformed report JSON/.test(error.message))
+            throw error;
         throw new Error("Agent emitted malformed report JSON");
     }
     const stringList = z.array(z.string().trim().min(1).max(4_000)).max(100);

package/dist/ensure-pull-request.js

@@ -151,17 +151,20 @@ export async function pushOriginHead(workspace, options = {}) {
     throw new Error(lastMessage);
 }
 /**
- * Bind reported head_commit to the checkout HEAD, then open a PR when still needed.
+ * Bind head_commit to the checkout HEAD, then open a PR when still needed.
+ * Workspace HEAD is authoritative for scoped repository deliveries: agents (especially
+ * Experimental local-fuel lanes) often invent or paste a wrong SHA. Prefer the worktree
+ * over failing a delivery that already committed correctly.
  * Agent-supplied PR URLs skip creation but still require HEAD identity.
  */
 export async function ensureDeliveryPullRequest(input) {
     const readHead = input.readHeadCommit ?? workspaceHeadCommit;
     const push = input.pushOriginHead ?? pushOriginHead;
     let report = adoptPullRequestUrlFromEvidence(input.report, input.repositoryFingerprint);
-    if (report.head_commit && (input.spec.change_scope?.length ?? 0) > 0) {
+    if ((input.spec.change_scope?.length ?? 0) > 0) {
         const head = await readHead(input.workspace);
-        if (!commitsMatch(report.head_commit, head)) {
-            throw new Error(`Delivered head_commit ${report.head_commit} does not match workspace HEAD ${head}`);
+        if (report.head_commit && !commitsMatch(report.head_commit, head)) {
+            console.error(`Agent head_commit ${report.head_commit} does not match workspace HEAD ${head}; using workspace HEAD`);
         }
         report = { ...report, head_commit: head };
     }

package/dist/execution.js

@@ -479,59 +479,76 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             report = parseAgentReport(reportText, spec.acceptance ?? []);
         }
         catch (error) {
-            const parseError = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            const originalReply = reportText;
-            const replyDigest = createHash("sha256").update(originalReply).digest("hex");
-            await client.attemptRequest(taskId, "progress", {
-                phase: "preparing_delivery",
-                message: `Delivery envelope invalid (${redactSecrets(parseError)}); starting the single report-only repair turn without rerunning implementation. Original reply: ${originalReply.length} characters, sha256:${replyDigest}.`,
-                idempotency_key: `bridge:progress:${active.attemptId}:delivery-repair`,
-            });
-            let repaired;
-            try {
-                repaired = await driver.run({
-                    prompt: buildDeliveryRepairPrompt(parseError, originalReply, spec.acceptance ?? []),
-                    workspace: attemptWorkspace,
-                    // Preserve only existing read authority. No write, test, branch, or push
-                    // capability is available while the agent repairs the response envelope.
-                    grants: grants.filter((grant) => grant === "repo_read"),
-                    capabilities: [],
-                    verificationCommands: [],
-                    // Envelope repair is read-only observe authority regardless of the original class.
-                    executionClass: "observe",
-                    resumeSessionId: result.sessionId ?? undefined,
-                    timeoutMs,
-                    model: selection.model,
-                    fuel,
-                    fuelSource,
+            // Pump fuel keeps one repair turn. Local-fuel Experimental lanes (Pi et al.) get a second
+            // read-only repair — truncated JSON fences are common there and re-implementing is wasteful.
+            const maxRepairs = fuelSource === "local" ? 2 : 1;
+            let parseError = error instanceof Error ? error.message : "Agent delivery report was invalid";
+            let previousReply = reportText;
+            let resumeSessionId = result.sessionId ?? undefined;
+            let repaired = null;
+            let parsed = null;
+            for (let repairTurn = 1; repairTurn <= maxRepairs; repairTurn++) {
+                const replyDigest = createHash("sha256").update(previousReply).digest("hex");
+                await client.attemptRequest(taskId, "progress", {
+                    phase: "preparing_delivery",
+                    message: `Delivery envelope invalid (${redactSecrets(parseError)}); starting report-only repair turn ${repairTurn}/${maxRepairs} without rerunning implementation. Original reply: ${previousReply.length} characters, sha256:${replyDigest}.`,
+                    idempotency_key: `bridge:progress:${active.attemptId}:delivery-repair:${repairTurn}`,
                 });
+                try {
+                    repaired = await driver.run({
+                        prompt: buildDeliveryRepairPrompt(parseError, previousReply, spec.acceptance ?? []),
+                        workspace: attemptWorkspace,
+                        // Preserve only existing read authority. No write, test, branch, or push
+                        // capability is available while the agent repairs the response envelope.
+                        grants: grants.filter((grant) => grant === "repo_read"),
+                        capabilities: [],
+                        verificationCommands: [],
+                        // Envelope repair is read-only observe authority regardless of the original class.
+                        executionClass: "observe",
+                        resumeSessionId,
+                        timeoutMs,
+                        model: selection.model,
+                        fuel,
+                        fuelSource,
+                    });
+                }
+                catch (repairError) {
+                    const message = repairError instanceof Error ? repairError.message : "Delivery report repair failed";
+                    await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair failed: ${message}`, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                    console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
+                    return;
+                }
+                if (repaired.sessionId) {
+                    config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
+                    resumeSessionId = repaired.sessionId;
+                }
+                if (repaired.status === "failed") {
+                    const message = repaired.error ?? "Delivery report repair failed";
+                    await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                    console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
+                    return;
+                }
+                previousReply = repaired.resultText ?? "";
+                try {
+                    parsed = parseAgentReport(previousReply, spec.acceptance ?? []);
+                    break;
+                }
+                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}` } });
+                        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>"}`);
+                        return;
+                    }
+                    console.error(`Assignment ${taskId} report-only repair turn ${repairTurn} still invalid: ${redactSecrets(parseError)}; retrying`);
+                }
             }
-            catch (repairError) {
-                const message = repairError instanceof Error ? repairError.message : "Delivery report repair failed";
-                await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair failed: ${message}`, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
-                console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
+            if (!parsed)
                 return;
-            }
-            if (repaired.sessionId)
-                config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
-            if (repaired.status === "failed") {
-                const message = repaired.error ?? "Delivery report repair failed";
-                await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
-                console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
-                return;
-            }
-            try {
-                reportText = repaired.resultText ?? "";
-                report = parseAgentReport(reportText, spec.acceptance ?? []);
-            }
-            catch (repairError) {
-                const message = repairError instanceof Error ? repairError.message : "Repaired delivery report was invalid";
-                await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair exhausted: ${message}`, retryable: false, idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}` } });
-                console.error(`Assignment ${taskId} exhausted its report-only repair: ${redactSecrets(message)}`);
-                const replyTail = (repaired.resultText ?? "").slice(-8_000);
-                console.error(`Assignment ${taskId} repaired reply tail (${(repaired.resultText ?? "").length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
-                return;
-            }
+            reportText = previousReply;
+            report = parsed;
         }
         try {
             // Mechanical land path: agent may forget gh; Bridge pushes and the control plane opens the PR.
@@ -604,9 +621,10 @@ function buildDeliveryRepairPrompt(parseError, previousReply, acceptance) {
     return [
         "The implementation turn is complete. Perform exactly one report-only repair.",
         "Do not inspect or modify files. Do not run commands or tools. Do not redo implementation.",
-        "Return only one corrected fenced ```json Delivery object and no other prose.",
+        "Return only one corrected fenced ```json Delivery object and no other prose. Close the fence.",
         "Preserve the previous reply's substantive outcome, changes, verification, acceptance statuses, evidence, assumptions, risks, and limitations.",
         "Use only claims and evidence already present in the previous reply. Do not invent evidence, broaden scope, change reported work, or claim a criterion is met without existing supporting evidence.",
+        "Omit head_commit if uncertain — Bridge binds workspace HEAD. Keep pull_request_url only when the previous reply already had a real PR URL.",
         "",
         "REQUIRED DELIVERY SHAPE",
         agentReportTemplate,

package/dist/ops.js

@@ -9,6 +9,8 @@ import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 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";
 export const OPS_VERBS = [
     "connect", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
@@ -73,7 +75,7 @@ export function loadOpsEnv(home = homedir(), cwd = process.cwd()) {
         CONDUIT_ORG: pick("CONDUIT_ORG", ""),
         CONDUIT_WORKSPACE: pick("CONDUIT_WORKSPACE", ""),
         CONDUIT_REPO: pick("CONDUIT_REPO", ""),
-        CONDUIT_DRIVERS: pick("CONDUIT_DRIVERS", "cursor"),
+        CONDUIT_DRIVERS: pick("CONDUIT_DRIVERS", ""),
         CONDUIT_ROLES: pick("CONDUIT_ROLES", "implement research review"),
         loadedFrom,
     };
@@ -120,12 +122,21 @@ export function writeOpsEnvFile(path, patch, existingText) {
     }
     writeFileSync(path, `${next.filter((line, index) => !(index === next.length - 1 && line === "")).join("\n").replace(/\n*$/, "\n")}`, { mode: 0o600 });
 }
-export function resolveDrivers(env, argv) {
+/** Explicit ids win; otherwise CONDUIT_DRIVERS; otherwise agents detected on PATH (fail when none). */
+export async function resolveDrivers(env, argv, detect = detectInstalledClients) {
     const fromArgs = argv.map((item) => item.trim()).filter(Boolean);
-    const drivers = fromArgs.length ? fromArgs : splitOpsList(env.CONDUIT_DRIVERS);
-    if (!drivers.length)
-        throw new Error("No drivers. Set CONDUIT_DRIVERS or pass ids.");
-    return drivers;
+    if (fromArgs.length)
+        return fromArgs;
+    const fromEnv = splitOpsList(env.CONDUIT_DRIVERS);
+    if (fromEnv.length)
+        return fromEnv;
+    const detected = driverIdsFromDetectedLabels(await detect());
+    if (detected.length) {
+        console.log(`CONDUIT_DRIVERS not set — using detected agents: ${detected.join(", ")}`);
+        return detected;
+    }
+    throw new Error("No coding agent found on this computer. Install one (Claude Code, Codex, Cursor, OpenCode, Pi, Kiro, Antigravity), " +
+        "then retry — or set CONDUIT_DRIVERS / pass driver ids explicitly.");
 }
 /** Quote args for a copy-pasteable shell/cmd line (paths with spaces). */
 export function shellQuoteArgs(args) {
@@ -171,7 +182,7 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log(`URL: ${env.CONDUIT_URL || "(unset)"}`);
             console.log(`Workspace: ${env.CONDUIT_WORKSPACE || "(unset)"}`);
             console.log(`Repo: ${env.CONDUIT_REPO || "(none)"}`);
-            console.log(`Drivers: ${env.CONDUIT_DRIVERS}`);
+            console.log(`Drivers: ${env.CONDUIT_DRIVERS || "(auto-detect installed agents)"}`);
             console.log(`Roles: ${env.CONDUIT_ROLES}`);
             console.log("");
         }
@@ -202,11 +213,45 @@ export async function runOps(verb, argv = [], deps = {}) {
     }
     // Lane toggles only need Bridge config + optional driver ids — not a full ops.env.
     if (verb === "online" || verb === "offline") {
-        const drivers = resolveDrivers(env, argv);
+        const drivers = await resolveDrivers(env, argv);
         runBridge(["drivers", verb, ...drivers]);
         return;
     }
-    requireOpsEnv(env);
+    // `ops install --workspace <path> [--repo <url>]` persists declared intent into ops.env so the
+    // Connect UI path works without hand-editing a config file first.
+    let installEnv = env;
+    let installArgv = argv;
+    if (verb === "install") {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            options: {
+                workspace: { type: "string" },
+                repo: { type: "string" },
+            },
+            allowPositionals: true,
+        });
+        installArgv = positionals;
+        const declaredWorkspace = values.workspace?.trim();
+        const declaredRepo = values.repo?.trim();
+        if (declaredWorkspace || declaredRepo) {
+            const envPath = env.loadedFrom ?? defaultOpsEnvPath();
+            writeOpsEnvFile(envPath, {
+                ...(declaredWorkspace ? { CONDUIT_WORKSPACE: declaredWorkspace } : {}),
+                ...(declaredRepo ? { CONDUIT_REPO: declaredRepo } : {}),
+            });
+            console.log(`Saved ${[
+                declaredWorkspace ? `workspace ${declaredWorkspace}` : "",
+                declaredRepo ? `repo ${declaredRepo}` : "",
+            ].filter(Boolean).join(" and ")} to ${envPath}`);
+            installEnv = {
+                ...env,
+                ...(declaredWorkspace ? { CONDUIT_WORKSPACE: declaredWorkspace } : {}),
+                ...(declaredRepo ? { CONDUIT_REPO: declaredRepo } : {}),
+                loadedFrom: env.loadedFrom ?? envPath,
+            };
+        }
+    }
+    requireOpsEnv(verb === "install" ? installEnv : env);
     if (verb === "switch") {
         const { values } = parseArgs({
             args: argv,
@@ -278,10 +323,11 @@ export async function runOps(verb, argv = [], deps = {}) {
         return;
     }
     if (verb === "install") {
-        if (!env.CONDUIT_WORKSPACE)
-            throw new Error(`Set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
-        const workspace = resolve(expandOpsValue(env.CONDUIT_WORKSPACE));
-        const drivers = resolveDrivers(env, argv);
+        if (!installEnv.CONDUIT_WORKSPACE) {
+            throw new Error(`No workspace declared. Rerun with --workspace /path/to/repo, or set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
+        }
+        const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
+        const drivers = await resolveDrivers(installEnv, installArgv);
         for (const id of drivers) {
             if (LOCAL_FUEL_DRIVERS.has(id))
                 runBridge(["drivers", "fuel", id, "local"]);
@@ -291,8 +337,8 @@ export async function runOps(verb, argv = [], deps = {}) {
         runBridge(["ops", "doctor"]);
         if (host === "win32") {
             const runnerArgs = ["runner", "--workspace", workspace];
-            if (env.CONDUIT_REPO)
-                runnerArgs.push("--ensure-checkout", env.CONDUIT_REPO);
+            if (installEnv.CONDUIT_REPO)
+                runnerArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
             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)}`);
@@ -300,8 +346,8 @@ export async function runOps(verb, argv = [], deps = {}) {
             return;
         }
         const installArgs = ["install-service", "--workspace", workspace];
-        if (env.CONDUIT_REPO)
-            installArgs.push("--ensure-checkout", env.CONDUIT_REPO);
+        if (installEnv.CONDUIT_REPO)
+            installArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
         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/ops/env.example

@@ -11,6 +11,8 @@ CONDUIT_URL=https://api.conduit.miraland.io
 # CONDUIT_ORG=your-org-slug
 CONDUIT_WORKSPACE=$HOME/path/to/your-repo
 # CONDUIT_REPO=https://github.com/your-org/your-repo.git
-CONDUIT_DRIVERS=cursor
+# Leave CONDUIT_DRIVERS unset to auto-detect the coding agents installed on this computer.
+# Pin explicitly only when you want a subset, e.g.:
+# CONDUIT_DRIVERS=claude-code codex
 # Product-standard roles — leave all three so Start/retry plans can match without reconnect.
 CONDUIT_ROLES=implement research review

package/package.json

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