agent-yes 1.75.0 → 1.75.2

package/README.md

@@ -130,6 +130,25 @@ claude-yes --exit-on-idle=60s "run all tests and commit current changes"
 claude-code-execute claude-yes "your task here"
 ```
 
+### Inspect and message running agents (`cy ls / read / send`)
+
+From any terminal you can list and interact with agents that are already
+running on the machine — both TS- and Rust-spawned ones:
+
+```bash
+cy ls                                  # list all running agents
+cy ls codex                            # filter (matches pid, cwd, cli, or prompt)
+cy tail <keyword>                      # render last 96 lines via @xterm/headless
+cy read <keyword>                      # full rendered log
+cy send <keyword> "next: run tests"    # append a prompt to that agent's stdin
+cy send <keyword> "" --code=ctrl-c     # send a Ctrl+C
+```
+
+`cy` (and `ay` / `agent-yes`) writes to a shared registry at
+`~/.agent-yes/pids.jsonl` and a per-pid FIFO at `~/.agent-yes/fifo/<pid>.stdin`,
+so subcommands work whether the target agent is the TS or Rust runtime.
+Detailed reference (Japanese): [`docs/cy-subcommands.md`](./docs/cy-subcommands.md).
+
 ### Docker Usage
 
 You can run `agent-yes` in a Docker container with all AI CLI tools pre-installed.

package/dist/SUPPORTED_CLIS-C2w9JqbM.js

@@ -0,0 +1,11 @@
+import { t as CLIS_CONFIG } from "./ts-Cuys5-PF.js";
+import "./logger-B9h0djqx.js";
+import "./pidStore-C1JXxoPi.js";
+import "./globalPidIndex-Cr-g75QF.js";
+
+//#region ts/SUPPORTED_CLIS.ts
+const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
+
+//#endregion
+export { SUPPORTED_CLIS };
+//# sourceMappingURL=SUPPORTED_CLIS-C2w9JqbM.js.map

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { n as version, t as name } from "./package-CE0J-uFT.js";
+import { n as version, t as name } from "./package-8zpT1iww.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -635,7 +635,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	}
 }
 {
-	const { isSubcommand, runSubcommand } = await import("./subcommands-DpOqSs-b.js");
+	const { isSubcommand, runSubcommand } = await import("./subcommands-DSm9WL-6.js");
 	if (isSubcommand(process.argv[2])) {
 		const code = await runSubcommand(process.argv);
 		process.exit(code ?? 0);
@@ -664,7 +664,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-Dzf60ENT.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C2w9JqbM.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
@@ -694,7 +694,7 @@ if (config.showVersion) {
 	process.exit(0);
 }
 if (config.appendPrompt) {
-	const { PidStore } = await import("./pidStore-DR1yPY3t.js");
+	const { PidStore } = await import("./pidStore-BCsY5BW3.js");
 	const ipcPath = await PidStore.findActiveFifo(process.cwd());
 	if (!ipcPath) {
 		console.error("No active agent with IPC found in current directory.");

package/dist/globalPidIndex-Cr-g75QF.js

@@ -0,0 +1,144 @@
+import { n as logger } from "./logger-B9h0djqx.js";
+import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { lock } from "proper-lockfile";
+
+//#region ts/globalPidIndex.ts
+/**
+* Resolved at call time (not module load time) so tests and other callers
+* can override via $AGENT_YES_HOME without juggling module-cache resets.
+* Falls back to `~/.agent-yes` for normal user runs.
+*/
+function resolveGlobalDir() {
+	return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}
+function resolveGlobalFile() {
+	return path.join(resolveGlobalDir(), "pids.jsonl");
+}
+async function ensureDir() {
+	await mkdir(resolveGlobalDir(), { recursive: true });
+}
+async function withLock(fn) {
+	await ensureDir();
+	const file = resolveGlobalFile();
+	const dir = resolveGlobalDir();
+	let release;
+	try {
+		release = await lock(dir, {
+			lockfilePath: file + ".lock",
+			retries: {
+				retries: 5,
+				minTimeout: 50,
+				maxTimeout: 500
+			}
+		});
+		return await fn();
+	} finally {
+		await release?.();
+	}
+}
+/** Append one full record line. Caller must provide all required fields. */
+async function appendGlobalPid(record) {
+	try {
+		await withLock(async () => {
+			await appendFile(resolveGlobalFile(), JSON.stringify(record) + "\n");
+		});
+	} catch (error) {
+		logger.debug("[globalPidIndex] append failed:", error);
+	}
+}
+/** Append a partial status update by pid (status, exit_code, exit_reason). */
+async function updateGlobalPidStatus(pid, patch) {
+	try {
+		await withLock(async () => {
+			const existing = (await readGlobalPidsRaw()).find((r) => r.pid === pid);
+			if (!existing) return;
+			const merged = {
+				...existing,
+				...patch
+			};
+			await appendFile(resolveGlobalFile(), JSON.stringify(merged) + "\n");
+		});
+	} catch (error) {
+		logger.debug("[globalPidIndex] updateStatus failed:", error);
+	}
+}
+/**
+* Read the file once without merge logic — internal helper for status updates.
+*/
+async function readGlobalPidsRaw() {
+	let raw;
+	try {
+		raw = await readFile(resolveGlobalFile(), "utf-8");
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const merged = /* @__PURE__ */ new Map();
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const doc = JSON.parse(trimmed);
+			if (typeof doc.pid !== "number") continue;
+			const prev = merged.get(doc.pid);
+			merged.set(doc.pid, prev ? {
+				...prev,
+				...doc
+			} : doc);
+		} catch {}
+	}
+	return Array.from(merged.values());
+}
+/**
+* Read all records, last-line-per-pid wins (events get merged).
+* Optionally filter to live processes only.
+*/
+async function readGlobalPids(opts = {}) {
+	const records = await readGlobalPidsRaw();
+	if (!opts.liveOnly) return records;
+	return records.filter((r) => r.status !== "exited" && isProcessAlive(r.pid));
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const COMPACT_THRESHOLD_LINES = 500;
+/**
+* Best-effort compaction: rewrite the JSONL file with one line per known pid,
+* dropping records whose pid is dead AND status is exited (those won't be
+* referenced by `cy ls` anyway). Triggered opportunistically when the raw
+* file grows past `COMPACT_THRESHOLD_LINES`. Safe to call unconditionally;
+* it no-ops when the file is already small enough.
+*/
+async function maybeCompactGlobalPids() {
+	let raw;
+	try {
+		raw = await readFile(resolveGlobalFile(), "utf-8");
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		return;
+	}
+	const lineCount = raw.split("\n").filter((l) => l.trim()).length;
+	if (lineCount < COMPACT_THRESHOLD_LINES) return;
+	try {
+		await withLock(async () => {
+			const keep = (await readGlobalPidsRaw()).filter((r) => r.status !== "exited" || isProcessAlive(r.pid));
+			const tmpFile = resolveGlobalFile() + ".compact";
+			await writeFile(tmpFile, keep.map((r) => JSON.stringify(r)).join("\n") + (keep.length ? "\n" : ""));
+			await rename(tmpFile, resolveGlobalFile());
+			logger.debug(`[globalPidIndex] compacted ${lineCount} → ${keep.length} lines`);
+		});
+	} catch (error) {
+		logger.debug("[globalPidIndex] compact failed:", error);
+	}
+}
+
+//#endregion
+export { updateGlobalPidStatus as i, maybeCompactGlobalPids as n, readGlobalPids as r, appendGlobalPid as t };
+//# sourceMappingURL=globalPidIndex-Cr-g75QF.js.map

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-D_iRstH9.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-Cuys5-PF.js";
 import "./logger-B9h0djqx.js";
-import "./pidStore-CHLHMBEM.js";
-import "./globalPidIndex-DNEh8a_O.js";
+import "./pidStore-C1JXxoPi.js";
+import "./globalPidIndex-Cr-g75QF.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/{package-CE0J-uFT.js → package-8zpT1iww.js}

@@ -1,7 +1,7 @@
 //#region package.json
 var name = "agent-yes";
-var version = "1.74.0";
+var version = "1.75.1";
 
 //#endregion
 export { version as n, name as t };
-//# sourceMappingURL=package-CE0J-uFT.js.map
+//# sourceMappingURL=package-8zpT1iww.js.map

package/dist/pidStore-BCsY5BW3.js

@@ -0,0 +1,5 @@
+import "./logger-B9h0djqx.js";
+import { t as PidStore } from "./pidStore-C1JXxoPi.js";
+import "./globalPidIndex-Cr-g75QF.js";
+
+export { PidStore };

package/dist/{pidStore-CHLHMBEM.js → pidStore-C1JXxoPi.js}

@@ -1,5 +1,5 @@
 import { n as logger } from "./logger-B9h0djqx.js";
-import { r as updateGlobalPidStatus, t as appendGlobalPid } from "./globalPidIndex-DNEh8a_O.js";
+import { i as updateGlobalPidStatus, n as maybeCompactGlobalPids, t as appendGlobalPid } from "./globalPidIndex-Cr-g75QF.js";
 import { closeSync, existsSync, fsyncSync, openSync } from "fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
 import path from "path";
@@ -239,7 +239,7 @@ var PidStore = class PidStore {
 			exit_code: null,
 			exit_reason: null,
 			started_at: now
-		}).catch(() => null);
+		}).then(() => maybeCompactGlobalPids()).catch(() => null);
 		return result;
 	}
 	async updateStatus(pid, status, extra) {
@@ -337,4 +337,4 @@ pid-db/
 
 //#endregion
 export { PidStore as t };
-//# sourceMappingURL=pidStore-CHLHMBEM.js.map
+//# sourceMappingURL=pidStore-C1JXxoPi.js.map

package/dist/{subcommands-DpOqSs-b.js → subcommands-DSm9WL-6.js}

@@ -1,5 +1,5 @@
 import "./logger-B9h0djqx.js";
-import { n as readGlobalPids } from "./globalPidIndex-DNEh8a_O.js";
+import { r as readGlobalPids } from "./globalPidIndex-Cr-g75QF.js";
 import { readFile, stat } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -388,4 +388,4 @@ async function writeToIpc(ipcPath, payload) {
 
 //#endregion
 export { isSubcommand, runSubcommand };
-//# sourceMappingURL=subcommands-DpOqSs-b.js.map
+//# sourceMappingURL=subcommands-DSm9WL-6.js.map

package/dist/{ts-D_iRstH9.js → ts-Cuys5-PF.js}

@@ -1,7 +1,7 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { n as version } from "./package-CE0J-uFT.js";
+import { n as version } from "./package-8zpT1iww.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-DQWJSptq.js";
-import { t as PidStore } from "./pidStore-CHLHMBEM.js";
+import { t as PidStore } from "./pidStore-C1JXxoPi.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -1679,4 +1679,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-D_iRstH9.js.map
+//# sourceMappingURL=ts-Cuys5-PF.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.75.0",
+  "version": "1.75.2",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/globalPidIndex.spec.ts

@@ -142,6 +142,69 @@ describe("globalPidIndex", () => {
     expect(records).toEqual([]);
   });
 
+  it("maybeCompactGlobalPids no-ops when below threshold", async () => {
+    const mod = await loadModule();
+    await mod.appendGlobalPid({
+      pid: 1234,
+      cli: "claude",
+      prompt: null,
+      cwd: "/a",
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1,
+    });
+    const before = (await import("fs/promises")).readFile;
+    const beforeContent = await before(mod.getGlobalPidIndexPath(), "utf-8");
+    await mod.maybeCompactGlobalPids();
+    const afterContent = await before(mod.getGlobalPidIndexPath(), "utf-8");
+    expect(afterContent).toBe(beforeContent);
+  });
+
+  it("maybeCompactGlobalPids collapses event spam to one line per pid", async () => {
+    const mod = await loadModule();
+    // Emit > 500 status events across two pids (one alive, one will be exited+dead)
+    for (let i = 0; i < 260; i++) {
+      await mod.appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: null,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: 1,
+      });
+      await mod.appendGlobalPid({
+        pid: 999999, // dead
+        cli: "codex",
+        prompt: null,
+        cwd: "/b",
+        log_file: null,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: "done",
+        started_at: 1,
+      });
+    }
+    const fs = await import("fs/promises");
+    const before = (await fs.readFile(mod.getGlobalPidIndexPath(), "utf-8")).split("\n").length;
+    await mod.maybeCompactGlobalPids();
+    const after = (await fs.readFile(mod.getGlobalPidIndexPath(), "utf-8")).split("\n").length;
+    // Compaction must have shrunk the file dramatically and dropped the
+    // dead-and-exited pid 999999 entirely.
+    expect(after).toBeLessThan(before / 10);
+    const records = await mod.readGlobalPids();
+    expect(records.map((r) => r.pid)).toEqual([process.pid]);
+  });
+
+  it("maybeCompactGlobalPids on missing file is a noop", async () => {
+    const mod = await loadModule();
+    await mod.maybeCompactGlobalPids(); // no throw, no error
+  });
+
   it("skips corrupt lines without throwing", async () => {
     const mod = await loadModule();
     await mod.appendGlobalPid({

package/ts/globalPidIndex.ts

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, readFile } from "fs/promises";
+import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -38,23 +38,35 @@ export interface GlobalPidRecord {
   started_at: number;
 }
 
-const GLOBAL_DIR = path.join(homedir(), ".agent-yes");
-const GLOBAL_FILE = path.join(GLOBAL_DIR, "pids.jsonl");
+/**
+ * Resolved at call time (not module load time) so tests and other callers
+ * can override via $AGENT_YES_HOME without juggling module-cache resets.
+ * Falls back to `~/.agent-yes` for normal user runs.
+ */
+function resolveGlobalDir(): string {
+  return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}
+
+function resolveGlobalFile(): string {
+  return path.join(resolveGlobalDir(), "pids.jsonl");
+}
 
 export function getGlobalPidIndexPath(): string {
-  return GLOBAL_FILE;
+  return resolveGlobalFile();
 }
 
 async function ensureDir() {
-  await mkdir(GLOBAL_DIR, { recursive: true });
+  await mkdir(resolveGlobalDir(), { recursive: true });
 }
 
 async function withLock<R>(fn: () => Promise<R>): Promise<R> {
   await ensureDir();
+  const file = resolveGlobalFile();
+  const dir = resolveGlobalDir();
   let release: (() => Promise<void>) | undefined;
   try {
-    release = await lock(GLOBAL_DIR, {
-      lockfilePath: GLOBAL_FILE + ".lock",
+    release = await lock(dir, {
+      lockfilePath: file + ".lock",
       retries: { retries: 5, minTimeout: 50, maxTimeout: 500 },
     });
     return await fn();
@@ -67,7 +79,7 @@ async function withLock<R>(fn: () => Promise<R>): Promise<R> {
 export async function appendGlobalPid(record: GlobalPidRecord): Promise<void> {
   try {
     await withLock(async () => {
-      await appendFile(GLOBAL_FILE, JSON.stringify(record) + "\n");
+      await appendFile(resolveGlobalFile(), JSON.stringify(record) + "\n");
     });
   } catch (error) {
     logger.debug("[globalPidIndex] append failed:", error);
@@ -85,7 +97,7 @@ export async function updateGlobalPidStatus(
       const existing = current.find((r) => r.pid === pid);
       if (!existing) return; // unknown pid — nothing to update
       const merged: GlobalPidRecord = { ...existing, ...patch };
-      await appendFile(GLOBAL_FILE, JSON.stringify(merged) + "\n");
+      await appendFile(resolveGlobalFile(), JSON.stringify(merged) + "\n");
     });
   } catch (error) {
     logger.debug("[globalPidIndex] updateStatus failed:", error);
@@ -98,7 +110,7 @@ export async function updateGlobalPidStatus(
 async function readGlobalPidsRaw(): Promise<GlobalPidRecord[]> {
   let raw: string;
   try {
-    raw = await readFile(GLOBAL_FILE, "utf-8");
+    raw = await readFile(resolveGlobalFile(), "utf-8");
   } catch (err: any) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -141,3 +153,40 @@ function isProcessAlive(pid: number): boolean {
     return false;
   }
 }
+
+const COMPACT_THRESHOLD_LINES = 500; // raw events; one merged record per pid
+
+/**
+ * Best-effort compaction: rewrite the JSONL file with one line per known pid,
+ * dropping records whose pid is dead AND status is exited (those won't be
+ * referenced by `cy ls` anyway). Triggered opportunistically when the raw
+ * file grows past `COMPACT_THRESHOLD_LINES`. Safe to call unconditionally;
+ * it no-ops when the file is already small enough.
+ */
+export async function maybeCompactGlobalPids(): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readFile(resolveGlobalFile(), "utf-8");
+  } catch (err: any) {
+    if (err.code === "ENOENT") return;
+    return;
+  }
+  const lineCount = raw.split("\n").filter((l) => l.trim()).length;
+  if (lineCount < COMPACT_THRESHOLD_LINES) return;
+
+  try {
+    await withLock(async () => {
+      const merged = await readGlobalPidsRaw();
+      // Drop dead-and-exited entries; keep dead-but-not-yet-exited so a later
+      // status-update from elsewhere can still be matched against them.
+      const keep = merged.filter((r) => r.status !== "exited" || isProcessAlive(r.pid));
+      const tmpFile = resolveGlobalFile() + ".compact";
+      const content = keep.map((r) => JSON.stringify(r)).join("\n") + (keep.length ? "\n" : "");
+      await writeFile(tmpFile, content);
+      await rename(tmpFile, resolveGlobalFile());
+      logger.debug(`[globalPidIndex] compacted ${lineCount} → ${keep.length} lines`);
+    });
+  } catch (error) {
+    logger.debug("[globalPidIndex] compact failed:", error);
+  }
+}

package/ts/pidStore.spec.ts

@@ -10,6 +10,11 @@ const TEST_DIR = isWindows
 
 describe("PidStore", () => {
   let store: PidStore;
+  // Isolate the cross-runtime global pid index too — without this, the
+  // synthetic pid=12345 records leak into the user's real
+  // ~/.agent-yes/pids.jsonl via the mirror writer wired into PidStore.
+  const GLOBAL_TEST_DIR = path.join(TEST_DIR, "global");
+  let originalAgentYesHome: string | undefined;
 
   beforeEach(async () => {
     try {
@@ -17,12 +22,19 @@ describe("PidStore", () => {
     } catch {
       // ignore cleanup failures (e.g. Windows lock files from previous test)
     }
+    originalAgentYesHome = process.env.AGENT_YES_HOME;
+    process.env.AGENT_YES_HOME = GLOBAL_TEST_DIR;
     store = new PidStore(TEST_DIR);
     await store.init();
   });
 
   afterEach(async () => {
     await store.close();
+    if (originalAgentYesHome === undefined) {
+      delete process.env.AGENT_YES_HOME;
+    } else {
+      process.env.AGENT_YES_HOME = originalAgentYesHome;
+    }
     try {
       await rm(TEST_DIR, { recursive: true, force: true });
     } catch {

package/ts/pidStore.ts

@@ -2,7 +2,11 @@ import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { logger } from "./logger.ts";
 import { JsonlStore } from "./JsonlStore.ts";
-import { appendGlobalPid, updateGlobalPidStatus } from "./globalPidIndex.ts";
+import {
+  appendGlobalPid,
+  maybeCompactGlobalPids,
+  updateGlobalPidStatus,
+} from "./globalPidIndex.ts";
 
 export interface PidRecord {
   _id?: string;
@@ -100,7 +104,9 @@ export class PidStore {
       exit_code: null,
       exit_reason: null,
       started_at: now,
-    }).catch(() => null);
+    })
+      .then(() => maybeCompactGlobalPids())
+      .catch(() => null);
 
     return result;
   }

package/dist/SUPPORTED_CLIS-Dzf60ENT.js

@@ -1,11 +0,0 @@
-import { t as CLIS_CONFIG } from "./ts-D_iRstH9.js";
-import "./logger-B9h0djqx.js";
-import "./pidStore-CHLHMBEM.js";
-import "./globalPidIndex-DNEh8a_O.js";
-
-//#region ts/SUPPORTED_CLIS.ts
-const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
-
-//#endregion
-export { SUPPORTED_CLIS };
-//# sourceMappingURL=SUPPORTED_CLIS-Dzf60ENT.js.map

package/dist/globalPidIndex-DNEh8a_O.js

@@ -1,103 +0,0 @@
-import { n as logger } from "./logger-B9h0djqx.js";
-import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir } from "os";
-import path from "path";
-import { lock } from "proper-lockfile";
-
-//#region ts/globalPidIndex.ts
-const GLOBAL_DIR = path.join(homedir(), ".agent-yes");
-const GLOBAL_FILE = path.join(GLOBAL_DIR, "pids.jsonl");
-async function ensureDir() {
-	await mkdir(GLOBAL_DIR, { recursive: true });
-}
-async function withLock(fn) {
-	await ensureDir();
-	let release;
-	try {
-		release = await lock(GLOBAL_DIR, {
-			lockfilePath: GLOBAL_FILE + ".lock",
-			retries: {
-				retries: 5,
-				minTimeout: 50,
-				maxTimeout: 500
-			}
-		});
-		return await fn();
-	} finally {
-		await release?.();
-	}
-}
-/** Append one full record line. Caller must provide all required fields. */
-async function appendGlobalPid(record) {
-	try {
-		await withLock(async () => {
-			await appendFile(GLOBAL_FILE, JSON.stringify(record) + "\n");
-		});
-	} catch (error) {
-		logger.debug("[globalPidIndex] append failed:", error);
-	}
-}
-/** Append a partial status update by pid (status, exit_code, exit_reason). */
-async function updateGlobalPidStatus(pid, patch) {
-	try {
-		await withLock(async () => {
-			const existing = (await readGlobalPidsRaw()).find((r) => r.pid === pid);
-			if (!existing) return;
-			const merged = {
-				...existing,
-				...patch
-			};
-			await appendFile(GLOBAL_FILE, JSON.stringify(merged) + "\n");
-		});
-	} catch (error) {
-		logger.debug("[globalPidIndex] updateStatus failed:", error);
-	}
-}
-/**
-* Read the file once without merge logic — internal helper for status updates.
-*/
-async function readGlobalPidsRaw() {
-	let raw;
-	try {
-		raw = await readFile(GLOBAL_FILE, "utf-8");
-	} catch (err) {
-		if (err.code === "ENOENT") return [];
-		throw err;
-	}
-	const merged = /* @__PURE__ */ new Map();
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const doc = JSON.parse(trimmed);
-			if (typeof doc.pid !== "number") continue;
-			const prev = merged.get(doc.pid);
-			merged.set(doc.pid, prev ? {
-				...prev,
-				...doc
-			} : doc);
-		} catch {}
-	}
-	return Array.from(merged.values());
-}
-/**
-* Read all records, last-line-per-pid wins (events get merged).
-* Optionally filter to live processes only.
-*/
-async function readGlobalPids(opts = {}) {
-	const records = await readGlobalPidsRaw();
-	if (!opts.liveOnly) return records;
-	return records.filter((r) => r.status !== "exited" && isProcessAlive(r.pid));
-}
-function isProcessAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-export { readGlobalPids as n, updateGlobalPidStatus as r, appendGlobalPid as t };
-//# sourceMappingURL=globalPidIndex-DNEh8a_O.js.map

package/dist/pidStore-DR1yPY3t.js

@@ -1,5 +0,0 @@
-import "./logger-B9h0djqx.js";
-import { t as PidStore } from "./pidStore-CHLHMBEM.js";
-import "./globalPidIndex-DNEh8a_O.js";
-
-export { PidStore };