@miraland-labs/conduit-bridge 0.14.8 → 0.15.0

package/dist/cli.js

@@ -20,6 +20,7 @@ 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 { executeNextInvestigation } from "./investigation.js";
 import { bridgeVersion } from "./version.js";
 const [command] = process.argv.slice(2);
 /** Install-free form shown in help/output so clean laptops never need `conduit` on PATH. */
@@ -495,6 +496,11 @@ async function runner() {
                 process.exit(0);
             }
             await renewLeases(client, config);
+            if (workspace && onlineDriverIds(config).length) {
+                // Observation runs before authoring: an owner waiting on an answer should not queue behind
+                // a long delivery, and the control plane already counted this slot as busy.
+                progressed = await executeNextInvestigation(client, config, workspace, brief, timeoutMs) || progressed;
+            }
             if (workspace && onlineDriverIds(config).length) {
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: async () => {

package/dist/execution.js

@@ -7,8 +7,11 @@ import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, ext
 import { assertClassFloor } from "./execution-class.js";
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
+const execFileAsync = promisify(execFile);
 import { captureVerificationFailure, ensureTestEvidence } from "./ensure-test-evidence.js";
 /** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
 export function startIdleSleepGuard(options = {}) {
@@ -969,7 +972,12 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 grants,
                 verificationCommands: attemptBrief?.verification ?? [],
             });
-            validateDeliveryReport(report, spec, grants);
+            // Ask git what changed before trusting what the report says changed.
+            const startCommit = executionContract.requested_base_commit && executionContract.claimed_head
+                ? await resolveAttemptStartCommit(workspace, executionContract.requested_base_commit, executionContract.claimed_head)
+                : null;
+            const actualPaths = startCommit ? await changedPathsSince(attemptWorkspace, startCommit) : null;
+            validateDeliveryReport(report, spec, grants, actualPaths ?? undefined);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Agent delivery report was invalid";
@@ -1198,13 +1206,13 @@ async function prepareDelivery(client, attemptId, taskId, report) {
         },
     };
 }
-export function validateDeliveryReport(report, spec, grants = []) {
+export function validateDeliveryReport(report, spec, grants = [], actualPaths) {
     // Research findings live in the report. Do not demand a published pack URL for work_role=research
     // even when a planner mis-labeled the package as deliverable=artifact.
     const artifactDelivery = spec.deliverable === "artifact" && spec.work_role !== "research";
     // Artifact packs are not git landings — do not demand head_commit when the planner put
     // `.conduit/artifacts/**` in change_scope as a write hint (path-4 canary incident).
-    validateChangeScope(report, spec.change_scope ?? [], { requireHeadCommit: !artifactDelivery });
+    validateChangeScope(report, spec.change_scope ?? [], { requireHeadCommit: !artifactDelivery, actualPaths });
     if (artifactDelivery) {
         const published = report.evidence.some((item) => {
             if (!["preview", "research", "documentation"].includes(item.kind))
@@ -1271,6 +1279,45 @@ function referenceKind(kind) {
         return "document";
     return "other";
 }
+/**
+ * What this attempt actually changed, according to git rather than to the agent's prose.
+ *
+ * The scope check used to compare approved paths against strings the agent wrote about itself, so a
+ * run that edited an approved file and named it "tools.ts" failed the contract and spent an attempt
+ * on a path format. Git knows the truth, and Bridge holds the worktree: this is both stricter (a
+ * change cannot be omitted from the report to escape the check) and more forgiving (how the agent
+ * phrases a path stops mattering).
+ *
+ * Null when git cannot answer — an unknown must not fail a delivery, so the caller falls back to the
+ * report exactly as before.
+ */
+export async function changedPathsSince(worktree, startCommit) {
+    const run = async (args) => {
+        try {
+            const { stdout } = await execFileAsync("git", ["-C", worktree, ...args], { timeout: 30_000, maxBuffer: 8_000_000 });
+            return stdout;
+        }
+        catch {
+            return null;
+        }
+    };
+    const committed = await run(["diff", "--name-only", `${startCommit}..HEAD`]);
+    if (committed === null)
+        return null;
+    const paths = new Set(committed.split("\n").map((line) => line.trim()).filter(Boolean));
+    // Work the agent left uncommitted still lands in the delivery for lands=false packages.
+    const pending = await run(["status", "--porcelain"]);
+    for (const line of (pending ?? "").split("\n")) {
+        const entry = line.slice(3).trim();
+        if (!entry)
+            continue;
+        // A rename reports "old -> new"; the new path is the one that exists.
+        const path = entry.includes(" -> ") ? entry.slice(entry.lastIndexOf(" -> ") + 4).trim() : entry;
+        if (path)
+            paths.add(path.replace(/^"|"$/g, ""));
+    }
+    return [...paths];
+}
 export function validateChangeScope(report, changeScope, options = {}) {
     if (!changeScope.length)
         return;
@@ -1278,9 +1325,11 @@ export function validateChangeScope(report, changeScope, options = {}) {
     if (requireHeadCommit && !report.head_commit) {
         throw new Error("Repository changes require a delivered head commit");
     }
-    if (!report.changes.length)
+    // Git's answer when we have it; the agent's description only when we do not.
+    const paths = options.actualPaths
+        ?? report.changes.map((change) => change.split(/\s+[—-]\s+/, 1)[0].trim().replaceAll("\\", "/"));
+    if (!paths.length)
         return;
-    const paths = report.changes.map((change) => change.split(/\s+[—-]\s+/, 1)[0].trim().replaceAll("\\", "/"));
     const outside = paths.filter((path) => {
         if (!path || path.startsWith("/") || path.split("/").includes(".."))
             return true;

package/dist/investigation.js

@@ -0,0 +1,194 @@
+/** Read-only investigation lane on Bridge (Slice 5).
+ *
+ * An investigation answers one question against one pinned commit and returns a bounded brief. It
+ * is not an assignment: no delivery, no pull request, no evidence packet, no task state. The run is
+ * held to repo_read + test_run by the same driver projection that enforces read-only diagnosis, and
+ * the worktree it reads is deleted whichever way the run ends.
+ */
+import { z } from "zod";
+import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
+import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
+import { redactSecrets } from "./config.js";
+import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
+import { pickDriverForClaim, supportsReadOnlyDiagnosis } from "./drivers.js";
+const budgetSchema = z.object({
+    max_files: z.number().int().min(1).max(24).optional().default(8),
+    max_duration_ms: z.number().int().min(10_000).max(15 * 60_000).optional().default(5 * 60_000),
+}).passthrough();
+export const investigationAssignmentSchema = z.object({
+    id: z.string().uuid(),
+    kind: z.literal("repository"),
+    question: z.string().min(1).max(4_000),
+    grants: z.array(z.string()).default([]),
+    budget: budgetSchema.optional().default({}),
+    repository_fingerprint: z.string().nullable().optional().default(null),
+    commit: z.string().nullable().optional().default(null),
+    source_attempt_id: z.string().uuid().nullable().optional().default(null),
+});
+/** Mirrors the control plane's bounded result contract; anything else is refused before settlement. */
+const investigationBriefSchema = z.object({
+    summary: z.string().trim().min(1).max(4_000),
+    findings: z.array(z.string().trim().min(1).max(1_000)).max(12).default([]),
+    verification: z.array(z.string().trim().min(1).max(1_000)).max(8).default([]),
+    limitations: z.array(z.string().trim().min(1).max(1_000)).max(8).default([]),
+    files_read: z.number().int().min(0).max(24).default(0),
+    bytes_read: z.number().int().min(0).max(512 * 1024).default(0),
+    commands_run: z.array(z.string().trim().min(1).max(200)).max(10).default([]),
+});
+export function buildInvestigationPrompt(assignment, commit) {
+    return [
+        "You are Conductor's read-only investigation lane. Answer exactly one question about this repository at one pinned commit.",
+        "You have repo_read and test_run only. Do not edit, create, delete, format, commit, branch, push, install, or change any file.",
+        "Read the actual code and run only bounded verification commands that already exist in the project. Never start a server, deploy, or call a production system.",
+        "Ground every finding in files and symbols you actually read. If the answer cannot be settled at this commit, say so in limitations rather than guessing.",
+        "Do not quote secrets, credentials, tokens, or file bodies. Name paths and symbols instead.",
+        "",
+        `PINNED COMMIT ${commit}`,
+        `QUESTION\n${assignment.question}`,
+        `BUDGET\nAt most ${assignment.budget.max_files} files.`,
+        "",
+        "Return only one fenced ```json object with exactly this shape:",
+        '{"summary":"direct answer to the question","findings":["grounded fact with file/symbol"],"verification":["command you actually ran"],"limitations":["what you could not settle"],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}',
+        "summary is a string; the other list fields are arrays of strings. Close the fence and add no prose after it.",
+    ].join("\n");
+}
+/** One message for every unusable answer, so the retry decision reads it rather than guessing. */
+export const UNUSABLE_BRIEF = "Investigation returned no usable brief";
+export function parseInvestigationBrief(text) {
+    let candidate;
+    // A missing fence and a malformed body are the same outcome to the owner: no answer.
+    try {
+        candidate = parseJsonObjectCandidate(extractAgentReportJsonText(text));
+    }
+    catch {
+        throw new Error(UNUSABLE_BRIEF);
+    }
+    const parsed = investigationBriefSchema.safeParse(candidate);
+    if (!parsed.success)
+        throw new Error(UNUSABLE_BRIEF);
+    return parsed.data;
+}
+async function settle(client, investigationId, body) {
+    await client.request(`/runner/v1/investigations/${investigationId}/settle`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * Poll, claim and run one investigation. Returns true when one was executed, so the caller's cycle
+ * knows it made progress.
+ */
+export async function executeNextInvestigation(client, config, workspace, brief, timeoutMs) {
+    const data = await client.request("/runner/v1/investigations");
+    const assignments = z.array(investigationAssignmentSchema).parse(data.investigations ?? []);
+    const assignment = assignments[0];
+    if (!assignment)
+        return false;
+    const driverId = pickDriverForClaim(config, null, supportsReadOnlyDiagnosis);
+    const driver = driverId ? DRIVERS[driverId] : null;
+    if (!driver) {
+        // Nothing local can hold the run read-only. Leave it claimable by a capable machine instead of
+        // taking the lease and failing under it.
+        console.error(`Investigation ${assignment.id} skipped: no online lane can enforce read-only access.`);
+        return false;
+    }
+    const liveBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
+    const liveRepository = liveBrief?.repository ? normalizeRepositoryUrl(liveBrief.repository) : null;
+    const commit = assignment.commit;
+    const leaseToken = `${crypto.randomUUID()}${crypto.randomUUID()}`;
+    if (!commit) {
+        await claimThenSettle(client, assignment.id, leaseToken, {
+            lease_token: leaseToken, status: "failed", error: "investigation_commit_missing", retryable: false,
+        });
+        return true;
+    }
+    if (assignment.repository_fingerprint && liveRepository !== assignment.repository_fingerprint) {
+        await claimThenSettle(client, assignment.id, leaseToken, {
+            lease_token: leaseToken, status: "failed", error: "workspace_repository_mismatch", retryable: true,
+        });
+        return true;
+    }
+    if (!(await ensureCommitAvailable(workspace, commit).catch(() => false))) {
+        await claimThenSettle(client, assignment.id, leaseToken, {
+            lease_token: leaseToken, status: "failed", error: "commit_not_available", retryable: true,
+        });
+        return true;
+    }
+    await client.request(`/runner/v1/investigations/${assignment.id}/claim`, {
+        method: "POST",
+        body: JSON.stringify({ lease_token: leaseToken }),
+    });
+    console.log(`Claiming investigation ${assignment.id} at ${commit}`);
+    let attemptWorkspace = null;
+    try {
+        attemptWorkspace = await createAttemptWorktree({
+            sourceWorkspace: workspace,
+            attemptId: assignment.id,
+            startCommit: commit,
+        });
+        const result = await driver.run({
+            prompt: buildInvestigationPrompt(assignment, commit),
+            workspace: attemptWorkspace,
+            grants: assignment.grants,
+            verificationCommands: liveBrief?.verification ?? [],
+            deliverable: "repository",
+            // The same signal the read-only diagnosis lane uses; it is what denies edits in the driver.
+            workRole: "diagnose",
+            executionClass: "verify",
+            timeoutMs: Math.min(timeoutMs ?? assignment.budget.max_duration_ms, assignment.budget.max_duration_ms),
+        });
+        if (result.status === "failed") {
+            const message = result.error ?? "Investigation run failed";
+            await settle(client, assignment.id, { lease_token: leaseToken, status: "failed", error: redactSecrets(message).slice(0, 2_000), retryable: true });
+            console.error(`Investigation ${assignment.id} failed: ${redactSecrets(message)}`);
+            return true;
+        }
+        const observed = parseInvestigationBrief(result.resultText ?? "");
+        await settle(client, assignment.id, {
+            lease_token: leaseToken,
+            status: "completed",
+            result: {
+                summary: observed.summary,
+                findings: observed.findings,
+                verification: observed.verification,
+                limitations: observed.limitations,
+                witness: {
+                    repository_fingerprint: assignment.repository_fingerprint ?? liveRepository ?? "unknown",
+                    commit,
+                    observed_at: new Date().toISOString(),
+                    files_read: observed.files_read,
+                    bytes_read: observed.bytes_read,
+                    commands_run: observed.commands_run,
+                },
+            },
+        });
+        console.log(`Investigation ${assignment.id} settled with a bounded brief.`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "investigation_failed";
+        await settle(client, assignment.id, {
+            lease_token: leaseToken,
+            status: "failed",
+            error: redactSecrets(message).slice(0, 2_000),
+            // A malformed brief is worth one more try; a broken worktree is not fixed by repeating it.
+            retryable: message === UNUSABLE_BRIEF,
+        }).catch((settleError) => console.error(`Investigation settle failed: ${redactSecrets(settleError instanceof Error ? settleError.message : "unknown")}`));
+        console.error(`Investigation ${assignment.id} failed: ${redactSecrets(message)}`);
+    }
+    finally {
+        if (attemptWorkspace) {
+            await removeAttemptWorktree(workspace, attemptWorkspace)
+                .catch((error) => console.error(`Investigation worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+        }
+    }
+    return true;
+}
+/** Claim only to report why the run cannot start; the control plane needs the reason, not silence. */
+async function claimThenSettle(client, investigationId, leaseToken, body) {
+    await client.request(`/runner/v1/investigations/${investigationId}/claim`, {
+        method: "POST",
+        body: JSON.stringify({ lease_token: leaseToken }),
+    });
+    await settle(client, investigationId, body);
+    console.error(`Investigation ${investigationId} could not start: ${body.error}`);
+}

package/dist/preflight.js

@@ -18,7 +18,7 @@ function modelsFingerprint(config) {
 }
 // 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;
+export const BRIDGE_PROTOCOL_VERSION = 6;
 const execFileAsync = promisify(execFile);
 async function defaultCommandRunner(command, args, cwd) {
     try {

package/package.json

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