@miraland-labs/conduit-bridge 0.16.154 → 0.16.156

package/dist/driver.js

@@ -1885,6 +1885,41 @@ 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;
+/**
+ * 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";
+/** Process groups of the agents running now, stopped when the runner itself is stopped. */
+const runningGroups = new Set();
+let shutdownHookInstalled = false;
+function signalGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        // ESRCH: every process of the group is already gone.
+    }
+}
+/**
+ * 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
+ * did before. A runner killed with SIGKILL cannot do this.
+ */
+function installShutdownHook() {
+    if (shutdownHookInstalled)
+        return;
+    shutdownHookInstalled = true;
+    for (const signal of ["SIGTERM", "SIGINT"]) {
+        process.once(signal, () => {
+            for (const pid of runningGroups)
+                signalGroup(pid, "SIGKILL");
+            process.kill(process.pid, signal);
+        });
+    }
+}
 export function execute(executable, args, cwd, timeoutMs, fuel, fuelSource = "conduit", stdinText, signal, extraEnv, 
 /** The whole environment, for a run that must see less than an agent does (a probe instrument). */
 env) {
@@ -1893,7 +1928,19 @@ env) {
             cwd,
             stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
             env: env ?? boundedEnvironment(fuel, fuelSource, extraEnv),
+            detached: OWN_PROCESS_GROUP,
         });
+        const group = OWN_PROCESS_GROUP ? child.pid : undefined;
+        if (group !== undefined) {
+            installShutdownHook();
+            runningGroups.add(group);
+        }
+        const stop = (signal) => {
+            if (group !== undefined)
+                signalGroup(group, signal);
+            else
+                child.kill(signal);
+        };
         let stdout = "";
         let stderr = "";
         let timedOut = false;
@@ -1917,6 +1964,12 @@ env) {
             // behind can hold the other end, and a kept handle is one the runner never closes.
             child.stdout?.destroy();
             child.stderr?.destroy();
+            // The agent has answered; whatever it left running in its group stops now.
+            if (group !== undefined) {
+                runningGroups.delete(group);
+                signalGroup(group, "SIGTERM");
+                setTimeout(() => signalGroup(group, "SIGKILL"), 5_000).unref?.();
+            }
             resolve({
                 code,
                 stdout,
@@ -1928,8 +1981,8 @@ env) {
         // SIGTERM first, then SIGKILL after 10 s: a child that ignores the polite stop must not keep
         // the slot busy. The turn timer and the runner's abort use the same two steps.
         const stopChild = () => {
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 10_000).unref?.();
+            stop("SIGTERM");
+            setTimeout(() => stop("SIGKILL"), 10_000).unref?.();
             // A child that is already gone cannot close a pipe another process holds open.
             setTimeout(() => settle(null), CHILD_STOP_GRACE_MS).unref?.();
         };
@@ -1958,6 +2011,8 @@ env) {
             if (settled)
                 return;
             settled = true;
+            if (group !== undefined)
+                runningGroups.delete(group);
             clearTimeout(timer);
             signal?.removeEventListener("abort", stopChild);
             reject(error);

package/dist/ensure-test-evidence.js

@@ -5,7 +5,7 @@
  */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { criterionKey, resolveCriterionReference } from "./driver.js";
+import { boundedEnvironment, criterionKey, resolveCriterionReference } from "./driver.js";
 import { isBoundedVerificationCommand, isRunnableVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const TEST_EVIDENCE_DETAILS_MIN = 32;
@@ -388,7 +388,9 @@ export async function runBoundedVerificationCommand(command, workspace, timeoutM
             cwd: workspace,
             timeout: timeoutMs,
             maxBuffer: VERIFICATION_MAX_BUFFER_BYTES,
-            env: process.env,
+            // The agent's environment, not the runner's: a gate that passes only with a variable the
+            // agent never sees ties the project to this computer (acme-sim DATABASE_URL, 2026-10-10).
+            env: boundedEnvironment(),
         });
         pending.child.stdout?.on("data", collect("stdout"));
         pending.child.stderr?.on("data", collect("stderr"));

package/package.json

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