@miraland-labs/conduit-bridge 0.16.208 → 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/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/package.json

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