@miraland-labs/conduit-bridge 0.16.207 → 0.16.210

package/dist/driver.js

@@ -244,6 +244,12 @@ export function buildAssignmentPrompt(context) {
     if (packageContext?.decisions?.length) {
         lines.push("", "PROJECT DECISIONS (explicit human decisions — treat as binding context)", ...packageContext.decisions.map((item) => `- Q: ${item.question}\n  A: ${item.decision}`));
     }
+    // The earlier work comes before the brief: the brief names a fix to that work.
+    if (context.resumeHead) {
+        lines.push("", context.repairMode === "briefed"
+            ? `${RESUME_PROMPT_HEADING} — an earlier run of this same package failed its verification before delivery.`
+            : `${RESUME_PROMPT_HEADING} — an earlier run of this same package ran out of time before it finished.`, `Its work is already on this branch at commit ${context.resumeHead}. Continue from that work: read what is there, keep what is correct, and finish the package. Do not start over.`);
+    }
     if (rework) {
         // T55 row 9: a briefed repair never delivered, so "an independent review returned this
         // delivery" is false for it — the brief's own first line already says the opposite. Head it by
@@ -253,9 +259,6 @@ export function buildAssignmentPrompt(context) {
             : "REWORK FEEDBACK — an independent review returned this delivery; address every point";
         lines.push("", `${heading}\n${rework}`);
     }
-    if (context.resumeHead) {
-        lines.push("", `${RESUME_PROMPT_HEADING} — an earlier run of this same package ran out of time before it finished.`, `Its work is already on this branch at commit ${context.resumeHead}. Continue from that work: read what is there, keep what is correct, and finish the package. Do not start over.`);
-    }
     const mustCommit = context.grants.includes("repo_write") && context.grants.includes("branch_create");
     const mustOpenPr = mustCommit && context.grants.includes("pr_create");
     const executionClass = context.executionClass
@@ -728,7 +731,7 @@ export function claudeCodeFuelEnv(fuelSource, model) {
         return undefined;
     return { ANTHROPIC_MODEL: model, ANTHROPIC_SMALL_FAST_MODEL: model, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1" };
 }
-export function codexSandboxFacts(projection) {
+export function codexSandboxFacts(projection, writableRoots = []) {
     return [
         "SANDBOX FACTS",
         `Sandbox mode: ${projection.sandbox}.`,
@@ -736,7 +739,9 @@ export function codexSandboxFacts(projection) {
             ? "Network is on."
             : "Network is off, including loopback listen.",
         projection.sandbox === "workspace-write"
-            ? "Writes are allowed only in the workspace and TMPDIR. HOME and the rest of the filesystem are read-only."
+            ? writableRoots.length
+                ? `Writes are allowed only in the workspace, TMPDIR and ${writableRoots.join(", ")}. HOME and the rest of the filesystem are read-only.`
+                : "Writes are allowed only in the workspace and TMPDIR. HOME and the rest of the filesystem are read-only."
             : "No writes are allowed. The filesystem is read-only.",
         "Child processes inherit these limits.",
         "A registered gate that fails only with EPERM, EROFS, or a refused listen does not test the change.",
@@ -765,11 +770,22 @@ export function codexExecArgs(input, sandbox) {
     if (sandbox === "workspace-write" && networkAccess) {
         args.push("-c", "sandbox_workspace_write.network_access=true");
     }
+    if (sandbox === "workspace-write" && input.writableRoots?.length) {
+        // `exec resume` takes no --add-dir, so both forms set the roots as a config override.
+        args.push("-c", `sandbox_workspace_write.writable_roots=${JSON.stringify(input.writableRoots)}`);
+    }
     if (input.resumeSessionId)
         args.push(input.resumeSessionId);
     args.push("-");
     return args;
 }
+/** The machine's Cargo cache and build directory that exist, for a Codex agent to write. */
+export function codexCargoRoots(env) {
+    return ["CARGO_HOME", "CARGO_TARGET_DIR"].flatMap((name) => {
+        const path = env[name];
+        return path && existsSync(path) ? [path] : [];
+    });
+}
 /**
  * Since the July 2026 desktop merge, macOS machines often carry the codex CLI
  * only inside the ChatGPT app bundle rather than on PATH.
@@ -866,8 +882,12 @@ export const codexDriver = {
             capabilities: input.capabilities,
             diagnosis: input.workRole === "diagnose",
         });
+        // The agent shares the gate's Cargo cache and build directory (boundedEnvironment). Codex
+        // workspace-write made them read-only, so no cargo command the agent started could run
+        // (acme-sim FH17a, 2026-11-04: EROFS on .cargo-lock); the gate sandbox already writes them.
+        const writableRoots = projected.sandbox === "workspace-write" ? codexCargoRoots(process.env) : [];
         // Prompt via stdin avoids ARG_MAX limits on large assignment contracts.
-        const { code, stdout, stderr } = await execute(driverExecutable(codexDriver.name, input.executable), codexExecArgs({ ...input, networkAccess: projected.networkAccess }, projected.sandbox), input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, `${input.prompt}\n\n${codexSandboxFacts(projected)}`, input.signal);
+        const { code, stdout, stderr } = await execute(driverExecutable(codexDriver.name, input.executable), codexExecArgs({ ...input, networkAccess: projected.networkAccess, writableRoots }, projected.sandbox), input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource, `${input.prompt}\n\n${codexSandboxFacts(projected, writableRoots)}`, input.signal);
         const parsed = parseCodexJsonl(stdout);
         const resultText = parsed.resultText ?? (stdout || null);
         if (code !== 0) {

package/dist/ensure-land-commit.js

@@ -63,16 +63,17 @@ async function currentBranch(workspace) {
     return stdout.trim();
 }
 /**
- * A run that spent Conduit's package budget keeps its work for the retry: commit the scoped files the
- * agent left uncommitted, push the attempt branch where the grants allow a push, and name the head.
- * Null when the attempt has nothing after base — the retry then starts fresh, as before.
+ * A run that spent Conduit's package budget or failed its gate keeps its work for the next attempt:
+ * commit the scoped files the agent left uncommitted, push the attempt branch where the grants allow
+ * a push, and name the head. Null when the attempt has nothing after base — the next attempt then
+ * starts fresh.
  */
 export async function checkpointWorkInProgress(input) {
     if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
         return null;
     const pending = filterPathsInScope(await uncommittedPaths(input.workspace), input.spec.change_scope ?? []);
     if (pending.length) {
-        await commitScopedPaths(input.workspace, pending, "Conduit: work in progress at the package budget");
+        await commitScopedPaths(input.workspace, pending, "Conduit: work in progress for the next attempt");
     }
     const ahead = await commitsAheadOfBase(input.workspace, input.baseCommit);
     if (!ahead)

package/dist/ensure-test-evidence.js

@@ -572,6 +572,11 @@ async function missingNpmLockReason(directory) {
         return "pnpm-lock.yaml is not an npm install";
     return "no package-lock.json or npm-shrinkwrap.json";
 }
+/** Lock-pinned crates and npm packages, fetched outside the sandbox before a gate runs inside it. */
+export async function prepareVerificationDependencies(workspace) {
+    await fetchLockedDependencies(workspace);
+    await installLockedPackages(workspace);
+}
 export async function installLockedPackages(workspace, options = {}) {
     const installed = [];
     const skipped = [];
@@ -612,7 +617,19 @@ export async function installLockedPackages(workspace, options = {}) {
  * `output` is stdout and stderr together, in the order the lines arrived: a failure detail reads its
  * tail from it.
  */
-export async function runBoundedVerificationCommand(command, workspace, timeoutMs = VERIFICATION_TIMEOUT_MS) {
+export function runBoundedVerificationCommand(command, workspace, timeoutMs = VERIFICATION_TIMEOUT_MS) {
+    return runVerificationCommand(command, workspace, timeoutMs, true);
+}
+/**
+ * The same run without the dependency preparation, for a caller that is itself inside the sandbox
+ * (the delivered probe instrument). It has no network, so its own install would fail and leave a
+ * partial `node_modules` that hides the complete one. Bridge prepares that workspace before it
+ * starts the caller (CR31).
+ */
+export function runPreparedVerificationCommand(command, workspace, timeoutMs = VERIFICATION_TIMEOUT_MS) {
+    return runVerificationCommand(command, workspace, timeoutMs, false);
+}
+async function runVerificationCommand(command, workspace, timeoutMs, prepare) {
     const argv = argvForBoundedCommand(command);
     const bin = argv[0];
     if (!bin)
@@ -670,8 +687,8 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         partial[stream].append(parts.at(-1));
     };
     const output = () => [lines.text().replace(/\n$/, ""), partial.stdout.text(), partial.stderr.text()].filter(Boolean).join("\n");
-    await fetchLockedDependencies(workspace);
-    await installLockedPackages(workspace);
+    if (prepare)
+        await prepareVerificationDependencies(workspace);
     const tempRoot = untrustedCodeTempRoot(workspace);
     await mkdir(tempRoot, { recursive: true });
     const scratchHome = await mkdtemp(join(tempRoot, "gate-home-"));

package/dist/execution.js

@@ -1734,16 +1734,17 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             clearInterval(heartbeatTimer);
     };
     attemptDisposers.set(taskId, disposeTimers);
-    // A run that spent Conduit's package budget keeps its work: the control plane retries it once, and
-    // the retry resumes from the head reported here instead of starting over at the base. The tree
-    // stays on this computer, where that head is always reachable.
+    // A run that spent Conduit's package budget or failed its gate keeps its work: the next attempt
+    // resumes from the head reported here instead of starting over at the base. The tree stays on this
+    // computer, where that head is always reachable.
+    const checkpointForNextAttempt = () => diagnosis ? Promise.resolve(null) : checkpointWorkInProgress({
+        workspace: attemptWorkspace, spec, grants, baseCommit: deliveryBaseCommit,
+    }).catch((error) => {
+        console.error(`Work in progress was not committed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        return null;
+    });
     const reportTurnTimeout = async (message) => {
-        const resume = diagnosis || machineBoundTimeout(agentTimeout) ? null : await checkpointWorkInProgress({
-            workspace: attemptWorkspace, spec, grants, baseCommit: deliveryBaseCommit,
-        }).catch((error) => {
-            console.error(`Work in progress was not committed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
-            return null;
-        });
+        const resume = machineBoundTimeout(agentTimeout) ? null : await checkpointForNextAttempt();
         retainAttemptWorktree = true;
         const response = await queueTerminal(client, taskId, {
             action: "fail",
@@ -1829,9 +1830,12 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                         ? { ...result.signal, phase: "verification", witness: "bridge", kind: "verification_failed", command: capturedVerification.command, stderr_tail: undefined, stdout_tail: undefined, ...(diffStat ? { diff_stat: diffStat } : {}) }
                         : result.signal
                     : undefined;
+        // A repair brief describes a fix to this work, so the briefed attempt must start from it.
+        const resume = verificationDetail ? await checkpointForNextAttempt() : null;
         retainAttemptWorktree = true;
         const response = await queueTerminal(client, taskId, { action: "fail", body: {
                 error: message,
+                ...(resume ? { resume } : {}),
                 retryable: bindingRequired ? false : retryableAgentFailure(agentMessage),
                 // Bridge's own readings of the vendor's words name the cause, in the order the control plane
                 // always applied: a computer fact (sign-in, incompatible or missing CLI), then a model abort,
@@ -2490,12 +2494,15 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                         // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail
                         // closed (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
                         : classifyFinalizeFailure(message);
+            // A repair brief describes a fix to this work, so the briefed attempt must start from it.
+            const resume = verificationFailed ? await checkpointForNextAttempt() : null;
             retainAttemptWorktree = true;
             const response = await queueTerminal(client, taskId, {
                 action: "fail",
                 body: {
                     error: classified.error,
                     retryable: classified.retryable,
+                    ...(resume ? { resume } : {}),
                     ...(!verificationFailed && classified.failure ? { failure: classified.failure } : {}),
                     ...(verificationFailed ? { signal: {
                             phase: "verification",

package/dist/investigation.js

@@ -7,7 +7,7 @@
  */
 import { redactSecrets, redactSecretsDeep } from "./secret-redaction.js";
 import { z } from "zod";
-import { boundedTail, runBoundedVerificationCommand, VERIFICATION_TIMEOUT_MS } from "./ensure-test-evidence.js";
+import { boundedTail, prepareVerificationDependencies, runBoundedVerificationCommand, VERIFICATION_TIMEOUT_MS } from "./ensure-test-evidence.js";
 import { markAttemptActive } from "./preflight.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
@@ -690,6 +690,10 @@ async function execDeliveredProbeRun(argv, stdin, workspace, timeoutMs) {
     }
 }
 export async function runDeliveredProbeInstrument(input) {
+    // The delivered instrument runs inside the sandbox and cannot install; its registered commands
+    // read what Bridge installs here, outside it (CR31).
+    if (input.probes.some((probe) => probe.test?.trim()))
+        await (input.prepare ?? prepareVerificationDependencies)(input.workspace);
     const entry = join(input.workspace, PROBE_RUN_ENTRY);
     const timeoutMs = deliveredProbeTimeoutMs(input.probes);
     const stdin = JSON.stringify({ probes: input.probes });

package/dist/probe-run.js

@@ -1,5 +1,6 @@
 /** Delivered probe instrument entry. `{ "probes": [...] }` on stdin, `{ witnesses }` on stdout. */
 import { z } from "zod";
+import { runPreparedVerificationCommand } from "./ensure-test-evidence.js";
 import { runDeliveryVerificationProbes } from "./investigation.js";
 const probeRunInputSchema = z.object({
     probes: z.array(z.object({
@@ -19,7 +20,12 @@ async function readStdin() {
 }
 try {
     const parsed = probeRunInputSchema.parse(JSON.parse(await readStdin()));
-    const witnesses = await runDeliveryVerificationProbes({ workspace: process.cwd(), probes: parsed.probes });
+    // This process is inside the sandbox; Bridge prepared the workspace's dependencies before it started.
+    const witnesses = await runDeliveryVerificationProbes({
+        workspace: process.cwd(),
+        probes: parsed.probes,
+        runCommand: (command, workspace) => runPreparedVerificationCommand(command, workspace),
+    });
     process.stdout.write(`${JSON.stringify({ witnesses })}\n`);
 }
 catch (error) {

package/package.json

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