@miraland-labs/conduit-bridge 0.16.184 → 0.16.186

package/dist/cli.js

@@ -676,7 +676,9 @@ async function runner() {
             if (workspace && onlineDriverIds(config).length && !gateRehearsalRunning) {
                 // Read the workspace again, then publish it. The last brief stands if the read fails.
                 const publishWorkspaceState = async (options = {}) => {
-                    const refresh = await reportedRefresh(workspace, options);
+                    // Not while an investigation runs: its observation-only check compares the source checkout
+                    // before and after, and the runner's own fast-forward must not fail that check (CR18).
+                    const refresh = investigationRunning ? lastRefresh?.result ?? null : await reportedRefresh(workspace, options);
                     const currentBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
                     const preflight = await cachedBridgePreflight({ config, workspace, managedRoot, brief: currentBrief ?? undefined, refresh, agentTimeoutMs: timeoutMs }, options);
                     const hb = await heartbeat(client, config, workspace, currentBrief, preflight, undefined, bootstrapResult);
@@ -687,11 +689,17 @@ async function runner() {
                 };
                 // 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, {
-                    managedRoot: hb.on_shift?.managed_workspace_root ?? null,
-                    heartbeat: publishHeartbeat,
-                    heartbeatIntervalMs: intervalMs,
-                }) || progressed;
+                investigationRunning = true;
+                try {
+                    progressed = await executeNextInvestigation(client, config, workspace, brief, timeoutMs, {
+                        managedRoot: hb.on_shift?.managed_workspace_root ?? null,
+                        heartbeat: publishHeartbeat,
+                        heartbeatIntervalMs: intervalMs,
+                    }) || progressed;
+                }
+                finally {
+                    investigationRunning = false;
+                }
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
                     heartbeat: publishHeartbeat,
                     beforeClaim: async (driverId) => {
@@ -723,6 +731,8 @@ async function runner() {
 }
 /** True while the gate rehearsal runs in the background; the loop keeps beating but claims nothing. */
 let gateRehearsalRunning = false;
+/** An observation fingerprints the source checkout; a fast-forward under it reads as the observer writing. */
+let investigationRunning = false;
 /** The rehearsals the heartbeat reports, one per on-shift repository; empty reports no field. */
 let reportedGateRehearsals = [];
 /** The last on-shift snapshot, so the next cycle knows every repository this computer serves. */

package/dist/ensure-test-evidence.js

@@ -4,11 +4,13 @@
  * it never substitutes for it.
  */
 import { spawn } from "node:child_process";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, realpath, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { untrustedCodeTempRoot, untrustedCodeSpawn, untrustedCodeEnvironment, criterionKey, resolveCriterionReference, signalGroup, STDIO_DRAIN_MS, CHILD_STOP_GRACE_MS, OWN_PROCESS_GROUP, trackProcessGroup, untrackProcessGroup } from "./driver.js";
 import { isBoundedVerificationCommand, isRunnableVerificationCommand } from "./execution-class.js";
 import { workspaceDependenciesMissingFailure } from "./failure-signal.js";
+import { redactSecrets } from "./secret-redaction.js";
 /** A typed spawn refusal, distinct from a command that ran and failed. */
 export class VerificationCommandUnavailableError extends Error {
     failure;
@@ -381,6 +383,40 @@ export function boundedFailureDetail(command, lines, code, maxChars = FAILURE_DE
     const middle = dropped > 0 ? [...head, marker(dropped), ...tail] : [...head, ...tail];
     return [first, ...middle, last].join("\n");
 }
+const FETCH_STDERR_TAIL_BYTES = 64 * 1024;
+/** Workspace realpath + Cargo.lock sha256 already fetched by this process. */
+const fetchedLocks = new Set();
+/** The runner's own environment: network, the real CARGO_HOME and the PATH that finds cargo. */
+const runFetchOutsideSandbox = (command, argv, cwd) => new Promise((resolve) => {
+    const child = spawn(command, argv, { cwd, env: process.env, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), VERIFICATION_TIMEOUT_MS);
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => { stderr = `${stderr}${chunk}`.slice(-FETCH_STDERR_TAIL_BYTES); });
+    child.on("error", (error) => { clearTimeout(timer); resolve({ code: 127, stderr: error.message }); });
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stderr }); });
+});
+/**
+ * CR19 (2026-10-22): the gate runs without network, so every crate the Cargo.lock pins must already
+ * be in CARGO_HOME. `cargo fetch --locked` fills it outside the sandbox; it writes only to CARGO_HOME
+ * and refuses to change the lock. Once per lock file per process: an agent that adds a dependency
+ * changes the lock, and the next gate fetches again. A failed fetch does not stop the gate: its own
+ * output names the cause.
+ */
+export async function fetchLockedDependencies(workspace, options = {}) {
+    const lock = await readFile(join(workspace, "Cargo.lock")).catch(() => null);
+    if (!lock)
+        return { ran: false };
+    const key = `${await realpath(workspace)}\0${createHash("sha256").update(lock).digest("hex")}`;
+    if (fetchedLocks.has(key))
+        return { ran: false };
+    const result = await (options.run ?? runFetchOutsideSandbox)("cargo", ["fetch", "--locked"], workspace);
+    if (result.code === 0)
+        fetchedLocks.add(key);
+    else
+        console.error(redactSecrets(`[bridge] cargo fetch --locked exited ${result.code} in ${workspace}: ${result.stderr.trim().split("\n").slice(-10).join("\n")}`));
+    return { ran: true, code: result.code };
+}
 /**
  * The bounded runner every Bridge-run verification uses: the declared command, in the given
  * workspace, with the verification timeout and buffer. A non-zero exit is a result, not a throw.
@@ -449,6 +485,7 @@ 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);
     const tempRoot = untrustedCodeTempRoot(workspace);
     await mkdir(tempRoot, { recursive: true });
     const scratchHome = await mkdtemp(join(tempRoot, "gate-home-"));

package/dist/failure-signal.js

@@ -374,6 +374,8 @@ export const VERIFICATION_FAILS_ON_BASE = "verification fails on the base commit
 export const WORKSPACE_DEPENDENCIES_MISSING_PATTERN = /(?:^|\n)\s*(?:\/(?:usr\/)?bin\/)?(?:ba|z|da)?sh:\s*(?:(?:\d+:\s*)?[^:\n]{1,120}:\s*(?:command\s+)?not found|command not found:\s*[^\n]+)\s*(?=\n|$)|(?:^|\n)\s*'[^'\n]+' is not recognized as an internal or external command/im;
 /** A write the toolchain needs that the computer refused before any test ran: the sandbox or disk, not the base commit. */
 export const WORKSPACE_WRITE_REFUSED_PATTERN = /\b(?:EROFS|ENOSPC)\b|read-only file system|no space left on device/i;
+/** CR19 (2026-10-22): cargo inside the no-network sandbox tried to download a crate the shared cache lacks; the gate never tested the base. */
+export const WORKSPACE_FETCH_REFUSED_PATTERN = /Could not resolve host|failed to download from|Temporary failure in name resolution|Network is unreachable|unable to get packages from source/i;
 /** CR17e (2026-10-22): vitest could not write its config bundle under the sandboxed install; Bridge held the owner for its own mount. */
 export function workspaceWriteRefusedFailure(detail) {
     return {
@@ -613,7 +615,7 @@ export function classifyFailureSignal(signal) {
         // base commit. It is the computer's checkout that lacks a tool — an environment Hold that
         // clears when the workspace is bootstrapped, not a contract Hold on the author that never
         // clears. runner-2's first claim (2026-09-15) sat on the author for a missing `node_modules`.
-        if (signal.exit_code === 127 || WORKSPACE_DEPENDENCIES_MISSING_PATTERN.test(output)) {
+        if (signal.exit_code === 127 || WORKSPACE_DEPENDENCIES_MISSING_PATTERN.test(output) || WORKSPACE_FETCH_REFUSED_PATTERN.test(output)) {
             return workspaceDependenciesMissingFailure([`$ ${command}`, `exit ${signal.exit_code ?? "unknown"}`, output].filter(Boolean).join("\n"));
         }
         if (WORKSPACE_WRITE_REFUSED_PATTERN.test(output)) {

package/package.json

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