@miraland-labs/conduit-bridge 0.16.159 → 0.16.161

package/dist/driver.js

@@ -1884,14 +1884,14 @@ const MAX_AGENT_OUTPUT = 8 * 1024 * 1024;
  */
 export const STDIO_DRAIN_MS = 2_000;
 /** How long a stopped child may take to die before the run reports what it already has. */
-const CHILD_STOP_GRACE_MS = 20_000;
+export const CHILD_STOP_GRACE_MS = 20_000;
 /**
  * An agent runs as the leader of its own process group, so what it starts in the background (a dev
  * server, a test watcher, a database) is stopped with it. Before, only the agent itself was
  * stopped: its background processes outlived the run and held files and ports on the computer
  * (acme-sim SV1b, 2026-10-10). Windows has no process groups; there only the agent is stopped.
  */
-const OWN_PROCESS_GROUP = process.platform !== "win32";
+export const OWN_PROCESS_GROUP = process.platform !== "win32";
 /** Process groups of the agents running now, stopped when the runner itself is stopped. */
 const runningGroups = new Set();
 let shutdownHookInstalled = false;
@@ -1903,6 +1903,17 @@ export function signalGroup(pid, signal) {
         // ESRCH: every process of the group is already gone.
     }
 }
+export function trackProcessGroup(pid) {
+    installShutdownHook();
+    runningGroups.add(pid);
+}
+export function untrackProcessGroup(pid) {
+    runningGroups.delete(pid);
+}
+export function stopTrackedProcessGroups() {
+    for (const pid of runningGroups)
+        signalGroup(pid, "SIGKILL");
+}
 /**
  * systemd stops a whole cgroup, but launchd stops only the runner's own process group, which an
  * agent no longer shares. Stop the agents' groups first, then let the signal end the runner as it
@@ -1914,8 +1925,7 @@ function installShutdownHook() {
     shutdownHookInstalled = true;
     for (const signal of ["SIGTERM", "SIGINT"]) {
         process.once(signal, () => {
-            for (const pid of runningGroups)
-                signalGroup(pid, "SIGKILL");
+            stopTrackedProcessGroups();
             process.kill(process.pid, signal);
         });
     }
@@ -1931,10 +1941,8 @@ env) {
             detached: OWN_PROCESS_GROUP,
         });
         const group = OWN_PROCESS_GROUP ? child.pid : undefined;
-        if (group !== undefined) {
-            installShutdownHook();
-            runningGroups.add(group);
-        }
+        if (group !== undefined)
+            trackProcessGroup(group);
         const stop = (signal) => {
             if (group !== undefined)
                 signalGroup(group, signal);
@@ -1966,7 +1974,7 @@ env) {
             child.stderr?.destroy();
             // The agent has answered; whatever it left running in its group stops now.
             if (group !== undefined) {
-                runningGroups.delete(group);
+                untrackProcessGroup(group);
                 signalGroup(group, "SIGTERM");
                 setTimeout(() => signalGroup(group, "SIGKILL"), 5_000).unref?.();
             }
@@ -2012,7 +2020,7 @@ env) {
                 return;
             settled = true;
             if (group !== undefined)
-                runningGroups.delete(group);
+                untrackProcessGroup(group);
             clearTimeout(timer);
             signal?.removeEventListener("abort", stopChild);
             reject(error);

package/dist/ensure-land-commit.js

@@ -37,22 +37,22 @@ export async function ensureLandCommit(input) {
         return { kind: "skipped" };
     const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
     const readHead = input.readHeadCommit ?? readHeadCommit;
-    const listPending = input.listUncommittedPaths ?? ((workspace) => uncommittedPaths(workspace, { untracked: "all" }));
+    const listPending = input.listUncommittedPaths ?? ((workspace) => uncommittedPaths(workspace));
     const commitPaths = input.commitPaths ?? commitScopedPaths;
     const ahead = await countAhead(input.workspace, base);
-    if (ahead !== null && ahead > 0) {
-        return { kind: "already_landed", headCommit: await readHead(input.workspace) };
-    }
     const pending = filterPathsInScope(await listPending(input.workspace), input.spec.change_scope ?? []);
-    if (!pending.length) {
-        throw new AgentNoLandCommitError(base);
+    if (pending.length) {
+        await commitPaths(input.workspace, pending);
+        const afterAhead = await countAhead(input.workspace, base);
+        if (afterAhead === 0) {
+            throw new AgentNoLandCommitError(base);
+        }
+        return { kind: "committed", headCommit: await readHead(input.workspace), paths: pending };
     }
-    await commitPaths(input.workspace, pending);
-    const afterAhead = await countAhead(input.workspace, base);
-    if (afterAhead === 0) {
-        throw new AgentNoLandCommitError(base);
+    if (ahead !== null && ahead > 0) {
+        return { kind: "already_landed", headCommit: await readHead(input.workspace) };
     }
-    return { kind: "committed", headCommit: await readHead(input.workspace), paths: pending };
+    throw new AgentNoLandCommitError(base);
 }
 async function currentBranch(workspace) {
     const { stdout } = await execFileAsync("git", ["-C", workspace, "branch", "--show-current"], {
@@ -69,7 +69,7 @@ async function currentBranch(workspace) {
 export async function checkpointWorkInProgress(input) {
     if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
         return null;
-    const pending = filterPathsInScope(await uncommittedPaths(input.workspace, { untracked: "all" }), input.spec.change_scope ?? []);
+    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");
     }

package/dist/ensure-test-evidence.js

@@ -4,7 +4,7 @@
  * it never substitutes for it.
  */
 import { spawn } from "node:child_process";
-import { boundedEnvironment, criterionKey, resolveCriterionReference, signalGroup, STDIO_DRAIN_MS } from "./driver.js";
+import { boundedEnvironment, 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";
 const TEST_EVIDENCE_DETAILS_MIN = 32;
 /** Cold `cargo test` in an attempt worktree routinely exceeds two minutes of compile. */
@@ -193,14 +193,10 @@ export async function captureVerificationFailure(input) {
     const run = input.runCommand ?? runBoundedVerificationCommand;
     // Try each bounded command until one fails. First non-zero wins (typecheck before test when both exist).
     for (const command of commands) {
-        let result;
-        try {
-            result = await run(command, input.workspace);
-        }
-        catch {
-            // Diagnosis is best-effort: try the next command rather than failing the attempt again.
+        // Diagnosis is best-effort: try the next command rather than failing the attempt again.
+        const result = await run(command, input.workspace).catch(() => null);
+        if (!result)
             continue;
-        }
         if (result.timedOut) {
             return { command, detail: boundedTail(outputLines(result).join("\n"), DIAGNOSIS_DETAIL_MAX_CHARS),
                 timedOut: true, stdout: result.stdout, stderr: result.stderr };
@@ -429,12 +425,14 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
     };
     const output = () => [lines.text().replace(/\n$/, ""), partial.stdout.text(), partial.stderr.text()].filter(Boolean).join("\n");
     return new Promise((resolve, reject) => {
-        const ownGroup = process.platform !== "win32";
         const child = spawn(bin, argv.slice(1), { cwd: workspace, env: boundedEnvironment(),
-            stdio: ["ignore", "pipe", "pipe"], detached: ownGroup });
+            stdio: ["ignore", "pipe", "pipe"], detached: OWN_PROCESS_GROUP });
+        const group = OWN_PROCESS_GROUP ? child.pid : undefined;
+        if (group !== undefined)
+            trackProcessGroup(group);
         const stop = (signal) => {
-            if (ownGroup && child.pid !== undefined)
-                signalGroup(child.pid, signal);
+            if (group !== undefined)
+                signalGroup(group, signal);
             else
                 child.kill(signal);
         };
@@ -442,10 +440,11 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         const stderr = boundedOutput(VERIFICATION_MAX_BUFFER_BYTES);
         let timedOut = false;
         let settled = false;
-        let exited = false;
         let drainTimer = null;
         let graceTimer = null;
         const cleanup = () => {
+            if (group !== undefined)
+                untrackProcessGroup(group);
             clearTimeout(timer);
             if (drainTimer)
                 clearTimeout(drainTimer);
@@ -467,12 +466,10 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
                 : { stdout: stdout.text(), stderr: stderr.text(), output: output(), code: code ?? 1 });
         };
         const timer = setTimeout(() => {
-            if (exited)
-                return;
             timedOut = true;
             stop("SIGTERM");
             setTimeout(() => stop("SIGKILL"), 10_000).unref?.();
-            graceTimer = setTimeout(() => settle(null), 20_000);
+            graceTimer = setTimeout(() => settle(null), CHILD_STOP_GRACE_MS);
         }, timeoutMs);
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
@@ -494,7 +491,6 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
         });
         child.on("close", (code) => settle(code));
         child.on("exit", (code) => {
-            exited = true;
             clearTimeout(timer);
             drainTimer = setTimeout(() => settle(code), STDIO_DRAIN_MS);
         });

package/dist/execution.js

@@ -1090,6 +1090,17 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
     // A diagnostic terminal defaults to retention. If its lease disappears, deleting the only copy
     // of the failed code would make the durable retry mechanically impossible.
     let retainAttemptWorktree = diagnosis;
+    const reportVerificationGateTimeout = async (input) => {
+        const response = await queueTerminal(client, taskId, { action: "fail", body: {
+                error: input.detail,
+                retryable: false,
+                signal: verificationGateTimeoutSignal({ command: input.command, stderr: input.stderr, stdout: input.stdout }),
+                ...(input.pullRequestUrl ? { pull_request_url: input.pullRequestUrl } : {}),
+                idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
+            } });
+        retainAttemptWorktree = response.retain_worktree === true;
+        console.error(`Assignment ${taskId} verification gate did not finish: ${redactSecrets(input.detail)}`);
+    };
     if (diagnosis) {
         if (!sourceAttemptId) {
             await queueTerminal(client, taskId, {
@@ -1804,15 +1815,8 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                 : null;
             if (capturedVerification?.timedOut) {
                 retainAttemptWorktree = true;
-                const response = await queueTerminal(client, taskId, { action: "fail", body: {
-                        error: capturedVerification.detail,
-                        retryable: false,
-                        signal: verificationGateTimeoutSignal({ command: capturedVerification.command,
-                            stderr: capturedVerification.stderr ?? "", stdout: capturedVerification.stdout ?? "" }),
-                        idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
-                    } });
-                retainAttemptWorktree = response.retain_worktree === true;
-                console.error(`Assignment ${taskId} verification gate did not finish: ${redactSecrets(capturedVerification.detail)}`);
+                await reportVerificationGateTimeout({ command: capturedVerification.command, detail: capturedVerification.detail,
+                    stderr: capturedVerification.stderr ?? "", stdout: capturedVerification.stdout ?? "" });
                 return;
             }
             const verificationDetail = capturedVerification?.detail ?? null;
@@ -2274,18 +2278,8 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             // timeout signal the dry run emits, held on the computer operator — never a diagnosis or a
             // repair brief. Task ce673ef1 (2026-10-10) ran two diagnoses on a CPU-starved `npm run test`.
             if (error instanceof VerificationGateTimedOutError) {
-                const response = await queueTerminal(client, taskId, {
-                    action: "fail",
-                    body: {
-                        error: error.message,
-                        retryable: false,
-                        signal: verificationGateTimeoutSignal({ command: error.command, stderr: error.stderr, stdout: error.stdout }),
-                        ...(report.pull_request_url ? { pull_request_url: report.pull_request_url } : {}),
-                        idempotency_key: `bridge:verification-gate-timeout:${active.attemptId}`,
-                    },
-                });
-                retainAttemptWorktree = response.retain_worktree === true;
-                console.error(`Assignment ${taskId} verification gate did not finish: ${redactSecrets(error.message)}`);
+                await reportVerificationGateTimeout({ command: error.command, detail: error.message,
+                    stderr: error.stderr, stdout: error.stdout, pullRequestUrl: report.pull_request_url });
                 return;
             }
             // A gate that ran no tests is a misconfigured gate, not a failed verification: the delivery
@@ -2924,10 +2918,10 @@ export function verificationScopeConflictDetail(paths, changeScope) {
     return `Verification writes outside the approved scope: ${paths.join(", ")}\napproved change scope: ${changeScope.join(", ")}`;
 }
 /**
- * Run the project's verification commands once in the fresh attempt worktree, then answer three
+ * Run the project's verification commands once in the fresh attempt worktree, then answer four
  * questions before the first model call: did a gate start but test nothing, did a gate already fail
- * on the untouched base commit, and which paths did a gate write that the approved change scope
- * does not contain?
+ * on the untouched base commit, which paths did a gate write that the approved change scope
+ * does not contain, and did a gate fail to finish?
  *
  * R5 (2026-09-03) and R10 (2026-09-05) failed the same way: the gates write files under the
  * repository root, the change scope did not contain them, and `validateChangeScope` rejected the

package/dist/git-witness.js

@@ -46,7 +46,7 @@ export async function changedPathsSince(worktree, startCommit) {
  */
 export async function worktreeWrittenPaths(worktree) {
     try {
-        return [...new Set(await uncommittedPaths(worktree, { untracked: "all" }))];
+        return [...new Set(await uncommittedPaths(worktree))];
     }
     catch {
         return null;

package/dist/git.js

@@ -12,8 +12,8 @@ const execFileAsync = promisify(execFile);
  * and escape (`中文.txt` as `"\344\270\255\346\226\207.txt"`) comes back verbatim and can be
  * handed back to git (review 2026-10-03, finding 3).
  */
-export async function uncommittedPaths(workspace, options = {}) {
-    const { stdout } = await execFileAsync("git", ["-C", workspace, "status", "--porcelain=v1", "-z", `--untracked-files=${options.untracked ?? "normal"}`], { timeout: 30_000, maxBuffer: 8_000_000 });
+export async function uncommittedPaths(workspace) {
+    const { stdout } = await execFileAsync("git", ["-C", workspace, "status", "--porcelain=v1", "-z", "--untracked-files=all"], { timeout: 30_000, maxBuffer: 8_000_000 });
     return porcelainPaths(stdout);
 }
 /** Porcelain v1 with `-z`: `XY path`, and a rename or copy adds its source as the next field. */

package/dist/investigation.js

@@ -11,6 +11,7 @@ import { boundedTail, runBoundedVerificationCommand } from "./ensure-test-eviden
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { headCommitOrNull } from "./git.js";
+import { ConduitRequestError } from "./client.js";
 import { learnDriverFuel, resolveAssignmentModel, changedPathsSince, runDeliveryVerificationGates, discardWorktreeWrites } from "./execution.js";
 import { DRIVERS, execute, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
@@ -773,13 +774,24 @@ export async function executeNextInvestigation(client, config, workspace, brief,
     const fingerprintBefore = await workspaceFingerprint(workspace);
     let attemptWorkspace = null;
     const runId = investigationRunId(assignment.id);
-    // Renew inside the lease for as long as the driver runs; a renewal the control plane refuses
-    // means the run is already over for it, and the settle below reports that honestly.
+    // Renew inside the lease for as long as the driver runs. A terminal refusal (`invalid_lease`)
+    // means the control plane already took the run back — abort the driver and do not settle.
+    const runAbort = new AbortController();
+    let leaseTakenBack = false;
     const renewTimer = setInterval(() => {
         void client.request(`/runner/v1/investigations/${assignment.id}/renew`, {
             method: "POST",
             body: JSON.stringify({ lease_token: leaseToken }),
-        }).catch((error) => console.error(`Investigation ${assignment.id} lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+        }).catch((error) => {
+            if (error instanceof ConduitRequestError && error.code === "invalid_lease") {
+                leaseTakenBack = true;
+                clearInterval(renewTimer);
+                runAbort.abort();
+                console.error(`Investigation ${assignment.id} stopped: lease is no longer valid`);
+                return;
+            }
+            console.error(`Investigation ${assignment.id} lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        });
     }, options.renewIntervalMs ?? INVESTIGATION_RENEW_INTERVAL_MS);
     renewTimer.unref?.();
     let heartbeatRunning = false;
@@ -853,7 +865,10 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             fuel,
             timeoutMs: Math.min(timeoutMs ?? assignment.budget.max_duration_ms, assignment.budget.max_duration_ms),
             maxTurns: config.maxTurns,
+            signal: runAbort.signal,
         });
+        if (leaseTakenBack || runAbort.signal.aborted)
+            return true;
         await learnDriverFuel(config, driver.name, investigationFuel, result);
         if (result.status === "failed") {
             const message = result.error ?? "Investigation run failed";
@@ -927,6 +942,9 @@ export async function executeNextInvestigation(client, config, workspace, brief,
         console.log(`Investigation ${assignment.id} settled with a bounded brief.`);
     }
     catch (error) {
+        if (leaseTakenBack || runAbort.signal.aborted) {
+            return true;
+        }
         const message = error instanceof Error ? error.message : "investigation_failed";
         await settle(client, assignment.id, {
             lease_token: leaseToken,

package/dist/land-git-reality.js

@@ -18,7 +18,7 @@ export async function isLandTreeEmpty(input) {
     const ahead = await countAhead(input.workspace, base);
     if (ahead !== null && ahead > 0)
         return false;
-    const pending = filterPathsInScope(await (input.listUncommittedPaths ?? ((workspace) => listUncommittedPaths(workspace, { untracked: "all" })))(input.workspace), input.spec.change_scope ?? []);
+    const pending = filterPathsInScope(await (input.listUncommittedPaths ?? ((workspace) => listUncommittedPaths(workspace)))(input.workspace), input.spec.change_scope ?? []);
     return pending.length === 0;
 }
 function deliveryObjectClaimsWork(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.159",
+  "version": "0.16.161",
   "description": "Conduit Bridge CLI \u2014 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": {