@miraland-labs/conduit-bridge 0.9.8 → 0.9.10

package/README.md

@@ -2,7 +2,7 @@
 
 Local Bridge CLI for [Conduit](https://github.com/miralandlabs/conduit). Connects a computer to one organization, claims work, and drives a local agent.
 
-**Package version:** `0.9.8` — heartbeat protocol 2 requires a clean workspace plus a ready, versioned driver lane before dispatch. It also includes **ops** helpers for macOS / Linux / Windows, LaunchAgent/systemd **PATH** for `~/.local/bin`, disconnect/disengage, multi-driver lanes, shared slots **1–4**, worktrees, and optional `--ensure-checkout`. Protocol 1 heartbeats remain compatible for presence but cannot receive work.
+**Package version:** `0.9.10` — heartbeat protocol 2 requires a clean workspace plus a ready, versioned driver lane before dispatch. Cursor assignments with `external_network` allow-list `WebFetch(*)` so headless fetches are not auto-rejected. Attempt worktrees fetch/start from the initiative base when the source tip is behind or history was rewritten, without resetting the source checkout. Also includes **ops** helpers for macOS / Linux / Windows, LaunchAgent/systemd **PATH** for `~/.local/bin`, disconnect/disengage, multi-driver lanes, shared slots **1–4**, worktrees, and optional `--ensure-checkout`. Protocol 1 heartbeats remain compatible for presence but cannot receive work.
 
 ## Prerequisites
 

package/dist/brief.js

@@ -43,6 +43,26 @@ export async function isBaseCommitAncestor(workspace, baseCommit, headCommit) {
         throw error;
     }
 }
+async function fetchOrigin(workspace) {
+    await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "origin"], {
+        timeout: 120_000,
+        windowsHide: true,
+    });
+}
+/** Null when commits do not share history (e.g. orphan / force-pushed replacement tip). */
+async function gitMergeBase(workspace, left, right) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", workspace, "merge-base", left, right], {
+            timeout: 10_000,
+            windowsHide: true,
+        });
+        const sha = stdout.trim().toLowerCase();
+        return /^[0-9a-f]{40,64}$/.test(sha) ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** True when `sha` is a local commit object, optionally after fetching it from origin. */
 export async function ensureCommitAvailable(workspace, sha) {
     const present = async () => {
@@ -67,10 +87,7 @@ export async function ensureCommitAvailable(workspace, sha) {
     }
     catch {
         try {
-            await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "origin"], {
-                timeout: 120_000,
-                windowsHide: true,
-            });
+            await fetchOrigin(workspace);
         }
         catch {
             return false;
@@ -78,6 +95,47 @@ export async function ensureCommitAvailable(workspace, sha) {
     }
     return present();
 }
+/**
+ * Choose the commit an attempt worktree starts from for a required initiative base.
+ *
+ * Never rewrites the source checkout HEAD. Fetches missing objects when needed, prefers the claimed
+ * head when it already contains the base (rework), advances to the base when the workspace is merely
+ * behind, and falls back to the contract base when history was rewritten (force-push) so the owner
+ * does not have to manually reset before Recheck.
+ */
+export async function resolveAttemptStartCommit(workspace, requestedBase, claimedHead) {
+    if (!requestedBase)
+        return claimedHead;
+    const base = requestedBase.toLowerCase();
+    const claimed = claimedHead.toLowerCase();
+    if (await isBaseCommitAncestor(workspace, base, claimed).catch(() => false))
+        return claimed;
+    if (!(await ensureCommitAvailable(workspace, base).catch(() => false)))
+        return null;
+    await ensureCommitAvailable(workspace, claimed).catch(() => false);
+    if (await isBaseCommitAncestor(workspace, base, claimed).catch(() => false))
+        return claimed;
+    if (await isBaseCommitAncestor(workspace, claimed, base).catch(() => false))
+        return base;
+    // Shallow tip fetches can hide ancestry; deepen once before treating history as rewritten.
+    try {
+        await fetchOrigin(workspace);
+    }
+    catch {
+        /* offline / no origin — continue with objects already present */
+    }
+    if (await isBaseCommitAncestor(workspace, base, claimed).catch(() => false))
+        return claimed;
+    if (await isBaseCommitAncestor(workspace, claimed, base).catch(() => false))
+        return base;
+    // Unrelated histories (orphan / force-pushed default branch): honor the contract base for a fresh
+    // attempt worktree. Related-but-diverged tips can carry rework commits — refuse rather than drop them.
+    if (!(await ensureCommitAvailable(workspace, base).catch(() => false)))
+        return null;
+    if (await gitMergeBase(workspace, base, claimed) === null)
+        return base;
+    return null;
+}
 async function gitRemoteUrl(workspace) {
     try {
         const { common } = await gitDirectories(workspace);

package/dist/driver.js

@@ -142,6 +142,7 @@ export function buildAssignmentPrompt(context) {
         ...(context.grants.includes("branch_create") ? branchCreateCommands : []),
         ...(context.grants.includes("pr_create") ? prCreateCommands : []),
     ];
+    const hasExternalNetwork = (spec.required_capabilities ?? []).includes("external_network");
     const languageRule = deliveryLanguageRule(packageContext?.working_language ?? spec.working_language);
     lines.push("", "RULES", "- Stay within the change scope and boundaries.", ...(languageRule ? [languageRule] : []), 
     // Name the executable commands. The shell allow-list is exact, so an agent that guesses at
@@ -152,7 +153,12 @@ export function buildAssignmentPrompt(context) {
         ? [
             `- These are the ONLY shell commands you may run: ${runnableCommands.join("; ")}. Anything else is rejected — do not try variations, wrappers, or \`echo\`. Run the relevant ones and report their real output.`,
         ]
-        : ["- You have no shell authority for this assignment. Do not attempt shell commands; verify by reading files and report what you could not verify as unknown."]), ...(mustCommit
+        : ["- You have no shell authority for this assignment. Do not attempt shell commands; verify by reading files and report what you could not verify as unknown."]), 
+    // Mirror .cursor/cli.json WebFetch(*) — without naming it, agents fall back to WebSearch (not
+    // allow-listable) or invent status/title after "User Rejected" on unlisted fetches.
+    ...(hasExternalNetwork
+        ? ["- This assignment includes external_network: WebFetch is allow-listed. Use WebFetch for live HTTP status and page content; do not invent origin responses. Prefer WebFetch over WebSearch."]
+        : []), ...(mustCommit
         ? [
             "- Your working branch is already checked out. Commit your repository changes on the current branch (git add + git commit) — do not create a new branch — and report the resulting sha as head_commit. A delivery that changed files without a commit is rejected.",
             ...(mustOpenPr
@@ -430,11 +436,16 @@ export const codexDriver = {
     },
 };
 /**
- * Grants → Cursor CLI permissions (project .cursor/cli.json).
+ * Grants + capabilities → Cursor CLI permissions (project .cursor/cli.json).
  * Current Cursor Agent schema accepts only `permissions.{allow,deny}` (no
  * `version` / `approvalMode`). Outside the allow list is denied without --force.
+ *
+ * `external_network` maps to WebFetch(*) — without it, headless `-p` runs get
+ * "User Rejected" on every fetch (no interactive approval). Deliberately not
+ * `--force`/`--yolo`: that would also auto-allow unlisted Shell commands.
+ * Codex's parallel is sandbox_workspace_write.network_access=true.
  */
-export function cursorPermissionsForGrants(grants, verificationCommands = []) {
+export function cursorPermissionsForGrants(grants, verificationCommands = [], capabilities = []) {
     const allow = [];
     if (grants.includes("test_run")) {
         allow.push(...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Shell(${command})`));
@@ -443,6 +454,9 @@ export function cursorPermissionsForGrants(grants, verificationCommands = []) {
         allow.push(...branchCreateCommands.map((command) => `Shell(${command})`));
     if (grants.includes("pr_create"))
         allow.push(...prCreateCommands.map((command) => `Shell(${command})`));
+    // Cursor docs: WebFetch(domainOrPattern); WebFetch(*) auto-approves any domain.
+    if (capabilities.includes("external_network"))
+        allow.push("WebFetch(*)");
     return { allow, deny: deniedCommands.map((command) => `Shell(${command})`) };
 }
 /**
@@ -538,7 +552,7 @@ export const cursorDriver = {
         // local contract instead of making either version fail every attempt worktree.
         const help = await execute(executable, ["--help"], input.workspace, 15_000, undefined, "local");
         const trustWorkspace = help.code === 0 && cursorSupportsWorkspaceTrust(`${help.stdout}\n${help.stderr}`);
-        const configured = await withCursorPermissions(input.workspace, cursorPermissionsForGrants(input.grants, input.verificationCommands), () => execute(executable, cursorRunArgs({ ...input, trustWorkspace }), input.workspace, input.timeoutMs ?? 20 * 60_000, undefined, "local"));
+        const configured = await withCursorPermissions(input.workspace, cursorPermissionsForGrants(input.grants, input.verificationCommands, input.capabilities ?? []), () => execute(executable, cursorRunArgs({ ...input, trustWorkspace }), input.workspace, input.timeoutMs ?? 20 * 60_000, undefined, "local"));
         const { code, stdout, stderr } = configured;
         const parsed = parseCursorOutput(stdout);
         if (code !== 0 || parsed.isError) {

package/dist/execution.js

@@ -5,7 +5,7 @@ import { redactSecrets } from "./config.js";
 import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, fuelEndpoint, parseAgentReport, pickModelCandidate, tierForRisk } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
-import { buildWorkspaceBrief, ensureCommitAvailable, isBaseCommitAncestor, normalizeRepositoryUrl } from "./brief.js";
+import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
 /** Feedback text for changes_requested summaries (plain string or `{ feedback }`). */
 function changesRequestedFeedback(summary) {
@@ -230,7 +230,7 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
             rejection = "workspace_head_changed";
     }
     if (!rejection && assignment.requested_base_commit && assignment.claimed_head) {
-        const startHead = await resolveStartHead(workspace, assignment.requested_base_commit, assignment.claimed_head);
+        const startHead = await resolveAttemptStartCommit(workspace, assignment.requested_base_commit, assignment.claimed_head);
         if (!startHead)
             rejection = "base_not_ancestor";
     }
@@ -246,25 +246,6 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
     await client.claim(assignment.id, assignment.attempt_id, driverId ? { driverId } : undefined);
     return assignment.id;
 }
-/**
- * When a sibling merge advances task.base_commit past the machine checkout, the required base is a
- * descendant of claimed_head — not an ancestor. Fetch it and start from the advanced base instead of looping.
- */
-async function resolveStartHead(workspace, requestedBase, claimedHead) {
-    if (await isBaseCommitAncestor(workspace, requestedBase, claimedHead).catch(() => false))
-        return claimedHead;
-    await ensureCommitAvailable(workspace, requestedBase).catch(() => false);
-    if (await isBaseCommitAncestor(workspace, requestedBase, claimedHead).catch(() => false))
-        return claimedHead;
-    // Workspace is behind the required base (dependent package after merge).
-    if (await isBaseCommitAncestor(workspace, claimedHead, requestedBase).catch(() => false))
-        return requestedBase;
-    if (await ensureCommitAvailable(workspace, requestedBase).catch(() => false)
-        && await isBaseCommitAncestor(workspace, claimedHead, requestedBase).catch(() => false)) {
-        return requestedBase;
-    }
-    return null;
-}
 export async function executeNextAssignment(client, config, driver, workspace, brief, timeoutMs, supervision) {
     if (Object.keys(config.activeAttempts).length)
         return recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision);
@@ -304,7 +285,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     }
     let worktreeStart = startCommit;
     if (executionContract.requested_base_commit) {
-        const resolved = await resolveStartHead(workspace, executionContract.requested_base_commit, startCommit);
+        const resolved = await resolveAttemptStartCommit(workspace, executionContract.requested_base_commit, startCommit);
         if (!resolved) {
             await queueTerminal(client, taskId, { action: "fail", body: { error: "Required base commit is not available in this workspace", retryable: true, idempotency_key: `bridge:base-not-ancestor:${active.attemptId}` } });
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "Conduit Bridge CLI — join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Kiro / Antigravity agents for a Conduit organization",
   "type": "module",
   "bin": {