antechamber 1.0.34 → 1.0.36

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.36] - 2026-11-03
+
+### Added
+
+- Clean up after the agent on macOS. Disposal now records the agent's process group and re-identifies each member
+  before signalling it, so child processes that outlive the agent are stopped instead of being left behind. Linux
+  keeps reading `/proc`; macOS reads `/bin/ps`, because Node has neither `/proc` nor pidfd there. A process that has
+  already exited (zombie) never counts as a survivor.
+
+## [1.0.35] - 2026-11-03
+
+- test: resolve fixture paths with fileURLToPath (#86)
+
 ## [1.0.34] - 2026-11-02
 
 ### Fixed

package/dist/pi-rpc.d.ts

@@ -9,6 +9,8 @@
  */
 import { EventEmitter } from "node:events";
 import { type LifecycleClock } from "./lifecycle.js";
+import { type ProcessTable } from "./proc-table.js";
+export type { ProcessIdentity, ProcessTable } from "./proc-table.js";
 export interface PiRpcCommand {
     id?: string;
     type: string;
@@ -30,17 +32,6 @@ export declare class UpstreamProtocolError extends Error {
  * earlyoom take a workload before the adapter, whose death stops every session at once.
  */
 export declare const AGENT_OOM_SCORE_ADJ_MARGIN = 300;
-/** A process's group and kernel start time: with the PID, the identity that survives PID reuse checks. */
-interface ProcessIdentity {
-    readonly pid: number;
-    readonly group: number;
-    readonly start: string;
-}
-/** Reads process identities so disposal can tell owned survivors from a reused PID. */
-export interface ProcessTable {
-    identity(pid: number): ProcessIdentity | undefined;
-    groupMembers(group: number): ProcessIdentity[];
-}
 /** Why the agent stopped without antechamber disposing it on purpose (eviction, delete, shutdown). */
 export type PiStopReason = {
     readonly kind: "timeout";
@@ -143,4 +134,3 @@ export declare class PiRpcClient extends EventEmitter {
     notify(cmd: Omit<PiRpcCommand, "id">): void;
     dispose(): Promise<void>;
 }
-export {};

package/dist/pi-rpc.js

@@ -11,10 +11,11 @@ import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
-import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { constants as osConstants } from "node:os";
 import { systemClock } from "./lifecycle.js";
 import { agentBinary, envSetting } from "./config.js";
+import { createProcessTable } from "./proc-table.js";
 export const RPC_COMMAND_TIMEOUT_MS = 60_000;
 /**
  * `compact` answers only when the summary is written. OmO bounds one compaction by
@@ -50,34 +51,7 @@ function rankAboveAdapterForOom(pid) {
         console.error(`[pi-rpc] could not raise the agent's OOM score: ${error instanceof Error ? error.message : error}`);
     }
 }
-// Linux /proc. Any read failure (gone, no permission, no /proc) means the identity cannot be
-// verified, and an unverifiable process is never signalled: fail closed.
-const procTable = {
-    identity(pid) {
-        let stat;
-        try {
-            stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-        }
-        catch {
-            return undefined;
-        }
-        const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
-        return { pid, group: Number(fields[2]), start: fields[19] ?? "" };
-    },
-    groupMembers(group) {
-        let names;
-        try {
-            names = readdirSync("/proc");
-        }
-        catch {
-            return [];
-        }
-        return names
-            .filter((name) => /^\d+$/.test(name))
-            .flatMap((name) => procTable.identity(Number(name)) ?? [])
-            .filter((member) => member.group === group);
-    },
-};
+const procTable = createProcessTable();
 function duration(ms) {
     if (ms % 60_000 === 0)
         return `${ms / 60_000} min`;

package/dist/proc-table-darwin.d.ts

@@ -0,0 +1,16 @@
+import type { ProcessTable } from "./proc-table.js";
+/**
+ * macOS process table, backed by `/bin/ps`. Used by disposal to identify owned survivors, so it must
+ * report the same three facts Linux reads from `/proc/<pid>/stat`: PID, process group, and a start
+ * time that survives PID reuse checks. `ps` exposes the latter as `lstart` (second granularity).
+ */
+/** Runs `/bin/ps` with the given arguments and returns stdout. Injected so tests never spawn. */
+export type PsRunner = (args: readonly string[]) => string;
+/**
+ * `execFileSync` with an absolute binary: no shell, and no PATH lookup that a user-controlled
+ * directory could shadow. `-ww` disables width truncation; the column set is fixed so every line
+ * has the same shape. LC_ALL is pinned because `lstart` is rendered in the current locale: two
+ * calls must agree with each other even if the user changes the system language mid-session.
+ */
+export declare function runPs(args: readonly string[]): string;
+export declare function createDarwinProcTable(run?: PsRunner): ProcessTable;

package/dist/proc-table-darwin.js

@@ -0,0 +1,78 @@
+import { execFileSync } from "node:child_process";
+const PS_TIMEOUT_MS = 2_000;
+const PS_MAX_BUFFER = 8 * 1024 * 1024;
+const PS_COLUMNS = "pid=,pgid=,stat=,lstart=";
+/** `pid pgid stat lstart`, where lstart is "Sun Nov  1 15:55:48 2026" and may end in padding. */
+const PS_LINE = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/;
+/**
+ * `execFileSync` with an absolute binary: no shell, and no PATH lookup that a user-controlled
+ * directory could shadow. `-ww` disables width truncation; the column set is fixed so every line
+ * has the same shape. LC_ALL is pinned because `lstart` is rendered in the current locale: two
+ * calls must agree with each other even if the user changes the system language mid-session.
+ */
+export function runPs(args) {
+    return execFileSync("/bin/ps", args, {
+        encoding: "utf8",
+        timeout: PS_TIMEOUT_MS,
+        maxBuffer: PS_MAX_BUFFER,
+        env: { ...process.env, LC_ALL: "C", LANG: "C" },
+    });
+}
+function parseLine(line) {
+    const match = PS_LINE.exec(line);
+    if (match === null)
+        return undefined;
+    const pid = Number(match[1]);
+    const group = Number(match[2]);
+    const state = match[3];
+    const start = match[4];
+    if (!Number.isInteger(pid) || !Number.isInteger(group) || state === undefined || start === undefined)
+        return undefined;
+    if (start === "")
+        return undefined;
+    return { pid, group, start, state };
+}
+/**
+ * A zombie has already exited; only its parent is left to reap it. Counting it as a survivor would
+ * make disposal wait out the full grace window for a process that can no longer run, so `Z` entries
+ * are treated as gone in both methods, as `session-hosts` already does on Linux.
+ */
+function alive(entry) {
+    return !entry.state.startsWith("Z");
+}
+function toIdentity(entry) {
+    return { pid: entry.pid, group: entry.group, start: entry.start };
+}
+export function createDarwinProcTable(run = runPs) {
+    return {
+        identity(pid) {
+            if (!Number.isInteger(pid) || pid <= 0)
+                return undefined;
+            let output;
+            try {
+                output = run(["-ww", "-o", PS_COLUMNS, "-p", String(pid)]);
+            }
+            catch {
+                // The process is gone, or ps could not read it. An unverifiable identity fails closed.
+                return undefined;
+            }
+            const entry = parseLine(output.trim());
+            if (entry === undefined || entry.pid !== pid || !alive(entry))
+                return undefined;
+            return toIdentity(entry);
+        },
+        groupMembers(group) {
+            let output;
+            try {
+                output = run(["-ww", "-o", PS_COLUMNS, "-A"]);
+            }
+            catch {
+                return [];
+            }
+            return output.split("\n").flatMap((line) => {
+                const entry = parseLine(line);
+                return entry !== undefined && entry.group === group && alive(entry) ? [toIdentity(entry)] : [];
+            });
+        },
+    };
+}

package/dist/proc-table.d.ts

@@ -0,0 +1,17 @@
+/** A process's group and kernel start time: with the PID, the identity that survives PID reuse checks. */
+export interface ProcessIdentity {
+    readonly pid: number;
+    readonly group: number;
+    readonly start: string;
+}
+/** Reads process identities so disposal can tell owned survivors from a reused PID. */
+export interface ProcessTable {
+    identity(pid: number): ProcessIdentity | undefined;
+    groupMembers(group: number): ProcessIdentity[];
+}
+/**
+ * The process table for this platform. Linux reads `/proc`; macOS reads `/bin/ps`, because Node has no
+ * `/proc` and no pidfd there. Every other platform keeps the Linux table so a missing `/proc` fails
+ * closed (an identity is never reported that cannot be verified).
+ */
+export declare function createProcessTable(platform?: NodeJS.Platform): ProcessTable;

package/dist/proc-table.js

@@ -0,0 +1,38 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { createDarwinProcTable } from "./proc-table-darwin.js";
+// Linux /proc. Any read failure (gone, no permission, no /proc) means the identity cannot be
+// verified, and an unverifiable process is never signalled: fail closed.
+const linuxProcTable = {
+    identity(pid) {
+        let stat;
+        try {
+            stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        }
+        catch {
+            return undefined;
+        }
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+        return { pid, group: Number(fields[2]), start: fields[19] ?? "" };
+    },
+    groupMembers(group) {
+        let names;
+        try {
+            names = readdirSync("/proc");
+        }
+        catch {
+            return [];
+        }
+        return names
+            .filter((name) => /^\d+$/.test(name))
+            .flatMap((name) => linuxProcTable.identity(Number(name)) ?? [])
+            .filter((member) => member.group === group);
+    },
+};
+/**
+ * The process table for this platform. Linux reads `/proc`; macOS reads `/bin/ps`, because Node has no
+ * `/proc` and no pidfd there. Every other platform keeps the Linux table so a missing `/proc` fails
+ * closed (an identity is never reported that cannot be verified).
+ */
+export function createProcessTable(platform = process.platform) {
+    return platform === "darwin" ? createDarwinProcTable() : linuxProcTable;
+}

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",