agent-yes 1.75.1 → 1.75.3

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-C9qkWtPg.js

@@ -0,0 +1,12 @@
+import { t as CLIS_CONFIG } from "./ts-vc6cm9z6.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-IVJmMHfo.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-C9qkWtPg.js.map

package/dist/cli.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { n as version, t as name } from "./package-DRIilF5m.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-IVJmMHfo.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { existsSync, lstatSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
-import { chmod, copyFile, mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
+import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { chmod, copyFile } from "fs/promises";
 import path from "path";
 
 //#region ts/parseCliArgs.ts
@@ -237,176 +236,6 @@ function parseCliArgs(argv, supportedClis) {
 	};
 }
 
-//#endregion
-//#region ts/versionChecker.ts
-const CACHE_DIR = path.join(homedir(), ".cache", "agent-yes");
-const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
-const TTL_MS = 3600 * 1e3;
-async function readUpdateCache() {
-	try {
-		const raw = await readFile(CACHE_FILE, "utf8");
-		return JSON.parse(raw);
-	} catch {
-		return null;
-	}
-}
-async function writeUpdateCache(data) {
-	await mkdir(CACHE_DIR, { recursive: true });
-	await writeFile(CACHE_FILE, JSON.stringify(data));
-}
-function detectPackageManager() {
-	if (process.env.BUN_INSTALL || process.execPath?.includes("bun") || process.env.npm_execpath?.includes("bun")) return "bun";
-	return "npm";
-}
-/**
-* Check for updates, auto-install if newer version is available, and re-exec
-* so the current invocation always runs the latest code.
-*
-* Uses a 1-hour TTL cache to avoid hitting the registry on every run.
-* All errors are swallowed — network issues must never break the tool.
-* Set AGENT_YES_NO_UPDATE=1 to opt out.
-*
-* The AGENT_YES_UPDATED env var prevents infinite re-exec loops:
-* after updating we re-exec with AGENT_YES_UPDATED=<version> so the
-* new process skips the update check.
-*/
-async function checkAndAutoUpdate() {
-	if (process.env.AGENT_YES_NO_UPDATE) return;
-	if (process.env.AGENT_YES_UPDATED) return;
-	if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
-		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
-		const repoRoot = path.resolve(scriptDir, "..");
-		if (existsSync(path.join(repoRoot, ".git"))) return;
-	}
-	try {
-		let latestVersion;
-		const cache = await readUpdateCache();
-		if (cache && Date.now() - cache.checkedAt < TTL_MS) latestVersion = cache.latestVersion;
-		else {
-			const fetched = await fetchLatestVersion();
-			if (!fetched) return;
-			latestVersion = fetched;
-			await writeUpdateCache({
-				checkedAt: Date.now(),
-				latestVersion
-			});
-		}
-		if (compareVersions(version, latestVersion) < 0) {
-			if (await runInstall(latestVersion)) reExec(latestVersion);
-		}
-	} catch {}
-}
-async function runInstall(latestVersion) {
-	const installCmd = detectPackageManager() === "bun" ? `bun add -g agent-yes@${latestVersion}` : `npm install -g agent-yes@${latestVersion}`;
-	process.stderr.write(`\x1b[33m[agent-yes] Updating ${version} → ${latestVersion}…\x1b[0m\n`);
-	try {
-		const { execaCommand } = await import("execa");
-		await execaCommand(installCmd, { stdio: "inherit" });
-		process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
-		return true;
-	} catch {
-		process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installCmd}\x1b[0m\n`);
-		return false;
-	}
-}
-/**
-* Re-exec the current process so the newly installed version runs.
-* Sets AGENT_YES_UPDATED=<version> to prevent an infinite loop.
-*/
-function reExec(version) {
-	const [bin, ...args] = process.argv;
-	process.stderr.write(`\x1b[36m[agent-yes] Restarting with v${version}…\x1b[0m\n`);
-	try {
-		execFileSync(bin, args, {
-			stdio: "inherit",
-			env: {
-				...process.env,
-				AGENT_YES_UPDATED: version
-			}
-		});
-		process.exit(0);
-	} catch (err) {
-		process.exit(err.status ?? 1);
-	}
-}
-/**
-* Fetch the latest version of the package from npm registry
-*/
-async function fetchLatestVersion() {
-	try {
-		const response = await fetch(`https://registry.npmjs.org/${name}/latest`, { signal: AbortSignal.timeout(3e3) });
-		if (!response.ok) return null;
-		return (await response.json()).version;
-	} catch {
-		return null;
-	}
-}
-/**
-* Compare two semantic versions
-* Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
-*/
-function compareVersions(v1, v2) {
-	const parts1 = v1.split(".").map(Number);
-	const parts2 = v2.split(".").map(Number);
-	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-		const part1 = parts1[i] || 0;
-		const part2 = parts2[i] || 0;
-		if (part1 > part2) return 1;
-		if (part1 < part2) return -1;
-	}
-	return 0;
-}
-/**
-* Detect how agent-yes was installed.
-* Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
-*/
-function detectInstallMethod() {
-	try {
-		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
-		if (!scriptDir.includes("node_modules")) {
-			const repoRoot = path.resolve(scriptDir, "..");
-			if (existsSync(path.join(repoRoot, ".git"))) return "git";
-			return "source";
-		}
-		const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
-		try {
-			if (lstatSync(nodeModulesEntry).isSymbolicLink()) {
-				const target = readlinkSync(nodeModulesEntry);
-				const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
-				if (existsSync(path.join(resolvedTarget, ".git"))) return "bun link (git)";
-				return "bun link";
-			}
-		} catch {}
-		if (scriptDir.includes(".bun/")) return "bun";
-		if (scriptDir.includes(".npm/")) return "npx";
-		if (process.env.npm_execpath?.includes("bun")) return "bun";
-		if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
-		if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
-		return "npm";
-	} catch {
-		return "unknown";
-	}
-}
-/**
-* Format version string with install method
-*/
-function versionString() {
-	return `agent-yes v${version} (${detectInstallMethod()})`;
-}
-/**
-* Display version information with async latest version check
-*/
-async function displayVersion() {
-	console.log(versionString());
-	const latestVersion = await fetchLatestVersion();
-	if (latestVersion) {
-		const comparison = compareVersions(version, latestVersion);
-		if (comparison < 0) console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);
-		else if (comparison > 0) console.log(`${latestVersion} (latest published)`);
-		else console.log(`${latestVersion} (latest)`);
-	} else console.log("(unable to check for updates)");
-}
-
 //#endregion
 //#region ts/rustBinary.ts
 /**
@@ -564,14 +393,15 @@ function getRustBinaryVersion(binaryPath) {
 function autoRebuildIfOutdated(binaryPath, verbose) {
 	if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) return true;
 	const binaryVersion = getRustBinaryVersion(binaryPath);
-	if (verbose) console.log(`[rust] Binary version: ${binaryVersion}, package version: ${version}`);
-	if (binaryVersion === version) return true;
+	const pkgVersion = getInstalledPackage().version;
+	if (verbose) console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`);
+	if (binaryVersion === pkgVersion) return true;
 	const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
 	if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
 		if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
 		return true;
 	}
-	process.stderr.write(`\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${version}), rebuilding…\x1b[0m\n`);
+	process.stderr.write(`\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkgVersion}), rebuilding…\x1b[0m\n`);
 	try {
 		execFileSync("cargo", ["build", ...binaryPath.includes("/target/release") ? ["--release"] : []], {
 			cwd: rsDir,
@@ -635,7 +465,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	}
 }
 {
-	const { isSubcommand, runSubcommand } = await import("./subcommands-NWIZy8od.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);
@@ -645,12 +475,12 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-D5deJPjk.js");
+	const { startTray } = await import("./tray-CH_G7aXM.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-D5deJPjk.js");
+	const { ensureTray } = await import("./tray-CH_G7aXM.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -664,7 +494,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CqAT1Zud.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C9qkWtPg.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
@@ -694,7 +524,7 @@ if (config.showVersion) {
 	process.exit(0);
 }
 if (config.appendPrompt) {
-	const { PidStore } = await import("./pidStore-CF54dFqr.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-BHCkWll6.js → globalPidIndex-Cr-g75QF.js}

@@ -1,5 +1,5 @@
 import { n as logger } from "./logger-B9h0djqx.js";
-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";
@@ -108,7 +108,37 @@ function isProcessAlive(pid) {
 		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 { readGlobalPids as n, updateGlobalPidStatus as r, appendGlobalPid as t };
-//# sourceMappingURL=globalPidIndex-BHCkWll6.js.map
+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,7 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DfT_yx7e.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-vc6cm9z6.js";
 import "./logger-B9h0djqx.js";
-import "./pidStore-CYmzzaQQ.js";
-import "./globalPidIndex-BHCkWll6.js";
+import "./versionChecker-IVJmMHfo.js";
+import "./pidStore-C1JXxoPi.js";
+import "./globalPidIndex-Cr-g75QF.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

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-CYmzzaQQ.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-BHCkWll6.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-CYmzzaQQ.js.map
+//# sourceMappingURL=pidStore-C1JXxoPi.js.map

package/dist/{runningLock-DQWJSptq.js → runningLock-C22d9SRJ.js}

@@ -28,6 +28,21 @@ function isProcessRunning(pid) {
 	}
 }
 /**
+* Build an env that scrubs inherited GIT_* repo-locating vars so the spawned
+* `git` resolves the repo from `cwd` only. Without this, running inside a git
+* hook (where GIT_DIR / GIT_INDEX_FILE / GIT_WORK_TREE / GIT_COMMON_DIR are
+* exported) makes `git rev-parse --show-toplevel` use the hook's repo context
+* instead of the requested directory.
+*/
+function gitCleanEnv() {
+	const env = { ...process.env };
+	delete env.GIT_DIR;
+	delete env.GIT_WORK_TREE;
+	delete env.GIT_INDEX_FILE;
+	delete env.GIT_COMMON_DIR;
+	return env;
+}
+/**
 * Get git repository root for a directory
 */
 function getGitRoot(cwd) {
@@ -39,7 +54,8 @@ function getGitRoot(cwd) {
 				"pipe",
 				"pipe",
 				"ignore"
-			]
+			],
+			env: gitCleanEnv()
 		}).trim();
 	} catch {
 		return null;
@@ -260,4 +276,4 @@ function shouldUseLock(_cwd) {
 
 //#endregion
 export { shouldUseLock as i, getRunningAgentCount as n, releaseLock as r, acquireLock as t };
-//# sourceMappingURL=runningLock-DQWJSptq.js.map
+//# sourceMappingURL=runningLock-C22d9SRJ.js.map

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

@@ -1,5 +1,5 @@
 import "./logger-B9h0djqx.js";
-import { n as readGlobalPids } from "./globalPidIndex-BHCkWll6.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-NWIZy8od.js.map
+//# sourceMappingURL=subcommands-DSm9WL-6.js.map

package/dist/{tray-D5deJPjk.js → tray-CH_G7aXM.js}

@@ -1,4 +1,4 @@
-import { n as getRunningAgentCount } from "./runningLock-DQWJSptq.js";
+import { n as getRunningAgentCount } from "./runningLock-C22d9SRJ.js";
 import { existsSync } from "fs";
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -175,4 +175,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-D5deJPjk.js.map
+//# sourceMappingURL=tray-CH_G7aXM.js.map

package/dist/{ts-DfT_yx7e.js → ts-vc6cm9z6.js}

@@ -1,13 +1,14 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { n as version } from "./package-DRIilF5m.js";
-import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-DQWJSptq.js";
-import { t as PidStore } from "./pidStore-CYmzzaQQ.js";
+import { r as getInstalledPackage } from "./versionChecker-IVJmMHfo.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-C22d9SRJ.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";
 import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path, { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { execaCommandSync, parseCommandString } from "execa";
 import { fromReadable, fromWritable } from "from-node-stream";
 import DIE from "phpdie";
@@ -15,7 +16,6 @@ import sflow from "sflow";
 import xterm from "@xterm/headless";
 import { createServer } from "net";
 import { execSync as execSync$1 } from "node:child_process";
-import { fileURLToPath } from "url";
 import os from "node:os";
 import { readFile as readFile$1 } from "node:fs/promises";
 import path$1 from "node:path";
@@ -775,7 +775,7 @@ function spawnAgent(options) {
 		let [bin, ...args] = [...parseCommandString(cliConf?.binary || cli), ...cliArgs];
 		logger.debug(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
 		const spawned = pty.spawn(bin, args, ptyOptions);
-		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${version})`);
+		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${getInstalledPackage().version})`);
 		return spawned;
 	};
 	return tryCatch((error, attempts, spawn, ...args) => {
@@ -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-DfT_yx7e.js.map
+//# sourceMappingURL=ts-vc6cm9z6.js.map

package/dist/versionChecker-IVJmMHfo.js

@@ -0,0 +1,224 @@
+import { execFileSync } from "child_process";
+import { existsSync, lstatSync, readFileSync, readlinkSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+//#region package.json
+var name = "agent-yes";
+var version = "1.75.3";
+
+//#endregion
+//#region ts/versionChecker.ts
+const CACHE_DIR = path.join(homedir(), ".cache", "agent-yes");
+const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
+const TTL_MS = 3600 * 1e3;
+const CANONICAL_PKG_NAME = "agent-yes";
+let cachedInstalledPkg = null;
+/**
+* Read the live `package.json` from disk for the running module.
+*
+* The bundled `package.json` import is inlined at build time; if `dist/` is
+* published without a fresh build (issue #39), the inlined `version` lies
+* and the auto-update loop fires forever. Reading the on-disk manifest each
+* run keeps the version honest even when the bundle is stale.
+*/
+function getInstalledPackage() {
+	if (cachedInstalledPkg) return cachedInstalledPkg;
+	let dir = null;
+	try {
+		dir = path.dirname(fileURLToPath(import.meta.url));
+	} catch {}
+	if (dir) for (let i = 0; i < 6; i++) {
+		const candidate = path.join(dir, "package.json");
+		try {
+			if (existsSync(candidate)) {
+				const json = JSON.parse(readFileSync(candidate, "utf8"));
+				if (json.name === name && typeof json.version === "string") {
+					cachedInstalledPkg = {
+						name: json.name,
+						version: json.version
+					};
+					return cachedInstalledPkg;
+				}
+			}
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	cachedInstalledPkg = {
+		name,
+		version
+	};
+	return cachedInstalledPkg;
+}
+async function readUpdateCache() {
+	try {
+		const raw = await readFile(CACHE_FILE, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+async function writeUpdateCache(data) {
+	await mkdir(CACHE_DIR, { recursive: true });
+	await writeFile(CACHE_FILE, JSON.stringify(data));
+}
+function detectPackageManager() {
+	if (process.env.BUN_INSTALL || process.execPath?.includes("bun") || process.env.npm_execpath?.includes("bun")) return "bun";
+	return "npm";
+}
+/**
+* Check for updates, auto-install if newer version is available, and re-exec
+* so the current invocation always runs the latest code.
+*
+* Uses a 1-hour TTL cache to avoid hitting the registry on every run.
+* All errors are swallowed — network issues must never break the tool.
+* Set AGENT_YES_NO_UPDATE=1 to opt out.
+*
+* The AGENT_YES_UPDATED env var prevents infinite re-exec loops:
+* after updating we re-exec with AGENT_YES_UPDATED=<version> so the
+* new process skips the update check.
+*/
+async function checkAndAutoUpdate() {
+	if (process.env.AGENT_YES_NO_UPDATE) return;
+	if (process.env.AGENT_YES_UPDATED) return;
+	if (import.meta.url.startsWith("file://") && !import.meta.url.includes("node_modules")) {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		const repoRoot = path.resolve(scriptDir, "..");
+		if (existsSync(path.join(repoRoot, ".git"))) return;
+	}
+	try {
+		let latestVersion;
+		const cache = await readUpdateCache();
+		if (cache && Date.now() - cache.checkedAt < TTL_MS) latestVersion = cache.latestVersion;
+		else {
+			const fetched = await fetchLatestVersion();
+			if (!fetched) return;
+			latestVersion = fetched;
+			await writeUpdateCache({
+				checkedAt: Date.now(),
+				latestVersion
+			});
+		}
+		if (compareVersions(getInstalledPackage().version, latestVersion) < 0) {
+			if (await runInstall(latestVersion)) reExec(latestVersion);
+		}
+	} catch {}
+}
+async function runInstall(latestVersion) {
+	const installCmd = detectPackageManager() === "bun" ? `bun add -g ${CANONICAL_PKG_NAME}@${latestVersion}` : `npm install -g ${CANONICAL_PKG_NAME}@${latestVersion}`;
+	process.stderr.write(`\x1b[33m[agent-yes] Updating ${getInstalledPackage().version} → ${latestVersion}…\x1b[0m\n`);
+	try {
+		const { execaCommand } = await import("execa");
+		await execaCommand(installCmd, { stdio: "inherit" });
+		process.stderr.write(`\x1b[32m[agent-yes] Updated to ${latestVersion}\x1b[0m\n`);
+		return true;
+	} catch {
+		process.stderr.write(`\x1b[31m[agent-yes] Auto-update failed. Run: ${installCmd}\x1b[0m\n`);
+		return false;
+	}
+}
+/**
+* Re-exec the current process so the newly installed version runs.
+* Sets AGENT_YES_UPDATED=<version> to prevent an infinite loop.
+*/
+function reExec(version) {
+	const [bin, ...args] = process.argv;
+	process.stderr.write(`\x1b[36m[agent-yes] Restarting with v${version}…\x1b[0m\n`);
+	try {
+		execFileSync(bin, args, {
+			stdio: "inherit",
+			env: {
+				...process.env,
+				AGENT_YES_UPDATED: version
+			}
+		});
+		process.exit(0);
+	} catch (err) {
+		process.exit(err.status ?? 1);
+	}
+}
+/**
+* Fetch the latest version of the package from npm registry
+*/
+async function fetchLatestVersion() {
+	try {
+		const response = await fetch(`https://registry.npmjs.org/${CANONICAL_PKG_NAME}/latest`, { signal: AbortSignal.timeout(3e3) });
+		if (!response.ok) return null;
+		return (await response.json()).version;
+	} catch {
+		return null;
+	}
+}
+/**
+* Compare two semantic versions
+* Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+*/
+function compareVersions(v1, v2) {
+	const parts1 = v1.split(".").map(Number);
+	const parts2 = v2.split(".").map(Number);
+	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+		const part1 = parts1[i] || 0;
+		const part2 = parts2[i] || 0;
+		if (part1 > part2) return 1;
+		if (part1 < part2) return -1;
+	}
+	return 0;
+}
+/**
+* Detect how agent-yes was installed.
+* Returns a short label: "git", "bun link", "bun", "npm", "npx", or "unknown"
+*/
+function detectInstallMethod() {
+	try {
+		const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+		if (!scriptDir.includes("node_modules")) {
+			const repoRoot = path.resolve(scriptDir, "..");
+			if (existsSync(path.join(repoRoot, ".git"))) return "git";
+			return "source";
+		}
+		const nodeModulesEntry = scriptDir.replace(/\/dist$/, "");
+		try {
+			if (lstatSync(nodeModulesEntry).isSymbolicLink()) {
+				const target = readlinkSync(nodeModulesEntry);
+				const resolvedTarget = path.resolve(path.dirname(nodeModulesEntry), target);
+				if (existsSync(path.join(resolvedTarget, ".git"))) return "bun link (git)";
+				return "bun link";
+			}
+		} catch {}
+		if (scriptDir.includes(".bun/")) return "bun";
+		if (scriptDir.includes(".npm/")) return "npx";
+		if (process.env.npm_execpath?.includes("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("bun")) return "bun";
+		if (process.env.npm_config_user_agent?.startsWith("npm")) return "npm";
+		return "npm";
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Format version string with install method
+*/
+function versionString() {
+	return `agent-yes v${getInstalledPackage().version} (${detectInstallMethod()})`;
+}
+/**
+* Display version information with async latest version check
+*/
+async function displayVersion() {
+	console.log(versionString());
+	const latestVersion = await fetchLatestVersion();
+	if (latestVersion) {
+		const comparison = compareVersions(getInstalledPackage().version, latestVersion);
+		if (comparison < 0) console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);
+		else if (comparison > 0) console.log(`${latestVersion} (latest published)`);
+		else console.log(`${latestVersion} (latest)`);
+	} else console.log("(unable to check for updates)");
+}
+
+//#endregion
+export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
+//# sourceMappingURL=versionChecker-IVJmMHfo.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.75.1",
+  "version": "1.75.3",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -77,7 +77,7 @@
     "fmt": "oxlint --fix --fix-suggestions && oxfmt",
     "verify-deps": "node ./scripts/verify-deps.js",
     "_prepack": "bun run build",
-    "prepublishOnly": "npm run verify-deps",
+    "prepublishOnly": "bun run build && npm run verify-deps",
     "prepare": "husky",
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",

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";
@@ -153,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.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/ts/runningLock.ts

@@ -43,6 +43,22 @@ function isProcessRunning(pid: number): boolean {
   }
 }
 
+/**
+ * Build an env that scrubs inherited GIT_* repo-locating vars so the spawned
+ * `git` resolves the repo from `cwd` only. Without this, running inside a git
+ * hook (where GIT_DIR / GIT_INDEX_FILE / GIT_WORK_TREE / GIT_COMMON_DIR are
+ * exported) makes `git rev-parse --show-toplevel` use the hook's repo context
+ * instead of the requested directory.
+ */
+function gitCleanEnv(): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  delete env.GIT_COMMON_DIR;
+  return env;
+}
+
 /**
  * Get git repository root for a directory
  */
@@ -52,6 +68,7 @@ function getGitRoot(cwd: string): string | null {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
+      env: gitCleanEnv(),
     });
     return result.trim();
   } catch {

package/ts/rustBinary.ts

@@ -6,7 +6,7 @@ import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
 import path from "path";
-import pkg from "../package.json" with { type: "json" };
+import { getInstalledPackage } from "./versionChecker.ts";
 
 // Platform/arch to binary name mapping
 const PLATFORM_MAP: Record<string, string> = {
@@ -223,11 +223,12 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   }
 
   const binaryVersion = getRustBinaryVersion(binaryPath);
+  const pkgVersion = getInstalledPackage().version;
   if (verbose) {
-    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkg.version}`);
+    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`);
   }
 
-  if (binaryVersion === pkg.version) {
+  if (binaryVersion === pkgVersion) {
     return true; // up to date
   }
 
@@ -239,7 +240,7 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   }
 
   process.stderr.write(
-    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkg.version}), rebuilding…\x1b[0m\n`,
+    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkgVersion}), rebuilding…\x1b[0m\n`,
   );
 
   try {

package/ts/versionChecker.spec.ts

@@ -1,12 +1,14 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import {
+  _setInstalledPackageForTesting,
   checkAndAutoUpdate,
   compareVersions,
   fetchLatestVersion,
   displayVersion,
   detectInstallMethod,
+  getInstalledPackage,
   versionString,
-} from "./versionChecker";
+} from "./versionChecker.ts";
 
 vi.mock("execa", () => ({ execaCommand: vi.fn().mockResolvedValue({}) }));
 vi.mock("fs/promises", () => ({
@@ -18,8 +20,12 @@ vi.mock("fs", async (importOriginal) => {
   const actual = await importOriginal<typeof import("fs")>();
   return {
     ...actual,
-    // Return false for .git checks so the dev-checkout guard doesn't skip auto-update in tests
+    // Return false for .git / package.json lookups so neither the dev-checkout
+    // guard nor getInstalledPackage's disk read fires during the auto-update tests.
     existsSync: vi.fn(() => false),
+    readFileSync: vi.fn(() => {
+      throw new Error("readFileSync not stubbed");
+    }),
     lstatSync: actual.lstatSync,
     readlinkSync: actual.readlinkSync,
   };
@@ -99,6 +105,7 @@ describe("versionChecker", () => {
   describe("checkAndAutoUpdate", () => {
     beforeEach(() => {
       vi.clearAllMocks();
+      _setInstalledPackageForTesting(null);
       vi.stubGlobal("fetch", vi.fn());
       vi.spyOn(process.stderr, "write").mockImplementation(() => true);
       // Use a mock for process.exit to prevent actual exit in tests
@@ -300,4 +307,77 @@ describe("versionChecker", () => {
       expect(str).toMatch(/agent-yes v\d+\.\d+\.\d+ \(.+\)/);
     });
   });
+
+  // Regression test for https://github.com/snomiao/agent-yes/issues/39:
+  // a stale bundled version string must not pin the auto-update comparison
+  // when a fresh package.json is on disk next to the running module.
+  describe("getInstalledPackage (issue #39)", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+      _setInstalledPackageForTesting(null);
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+      _setInstalledPackageForTesting(null);
+    });
+
+    it("prefers the on-disk package.json over the bundled (potentially stale) import", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      vi.mocked(fs.readFileSync).mockReturnValueOnce(
+        JSON.stringify({ name: "agent-yes", version: "999.0.0" }) as any,
+      );
+
+      const resolved = getInstalledPackage();
+      expect(resolved.version).toBe("999.0.0");
+      expect(resolved.name).toBe("agent-yes");
+    });
+
+    it("continues walking parents when a candidate package.json is unreadable", async () => {
+      // Per-candidate try/catch: an unreadable/unparsable manifest at one
+      // level must not abort the upward walk and silently fall back to the
+      // bundled (stale) manifest. The walk must keep going until it finds
+      // a matching package.json or exhausts parents.
+      const fs = await import("fs");
+      let call = 0;
+      vi.mocked(fs.existsSync).mockImplementation(() => true);
+      vi.mocked(fs.readFileSync).mockImplementation(() => {
+        call += 1;
+        if (call === 1) throw new Error("EACCES");
+        if (call === 2) return "{not json" as any;
+        return JSON.stringify({ name: "agent-yes", version: "999.0.0" }) as any;
+      });
+
+      const resolved = getInstalledPackage();
+      expect(resolved.version).toBe("999.0.0");
+      expect(call).toBeGreaterThanOrEqual(3);
+    });
+
+    it("does not trigger an auto-update when on-disk version already matches the registry", async () => {
+      // Simulate the post-fix scenario: the bundled `pkg.version` (frozen at
+      // build time) is older than the registry, but the runtime resolver
+      // surfaces the correct on-disk version and the comparison short-circuits.
+      // Pre-fix behavior was install + reExec on every invocation → infinite loop.
+      _setInstalledPackageForTesting({ name: "agent-yes", version: "999.0.0" });
+
+      const { readFile } = await import("fs/promises");
+      const { execaCommand } = await import("execa");
+      vi.mocked(readFile).mockRejectedValueOnce(new Error("no cache"));
+      vi.stubGlobal(
+        "fetch",
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({ version: "999.0.0" }),
+        } as Response),
+      );
+      vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+      delete process.env.AGENT_YES_NO_UPDATE;
+      delete process.env.AGENT_YES_UPDATED;
+
+      await checkAndAutoUpdate();
+      expect(execaCommand).not.toHaveBeenCalled();
+    });
+  });
 });

package/ts/versionChecker.ts

@@ -1,14 +1,80 @@
 import { execFileSync } from "child_process";
-import { existsSync, lstatSync, readlinkSync } from "fs";
+import { existsSync, lstatSync, readFileSync, readlinkSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
-import pkg from "../package.json" with { type: "json" };
+import { fileURLToPath } from "url";
+import bundledPkg from "../package.json" with { type: "json" };
 
 const CACHE_DIR = path.join(homedir(), ".cache", "agent-yes");
 const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
 const TTL_MS = 60 * 60 * 1000; // 1 hour
 
+// The release pipeline publishes both `agent-yes` and `claude-yes` from the
+// same source by flipping `package.json#name` and re-running `npm publish`
+// (which now triggers `bun run build`, rebuilding dist with whichever name is
+// set). The auto-updater's registry lookup, install command, and shared
+// cache file must all stay pinned to the canonical package — otherwise a
+// `claude-yes` install would query `claude-yes/latest` while `runInstall`
+// still hard-codes `agent-yes`.
+const CANONICAL_PKG_NAME = "agent-yes";
+
+let cachedInstalledPkg: { name: string; version: string } | null = null;
+
+/**
+ * Read the live `package.json` from disk for the running module.
+ *
+ * The bundled `package.json` import is inlined at build time; if `dist/` is
+ * published without a fresh build (issue #39), the inlined `version` lies
+ * and the auto-update loop fires forever. Reading the on-disk manifest each
+ * run keeps the version honest even when the bundle is stale.
+ */
+export function getInstalledPackage(): { name: string; version: string } {
+  if (cachedInstalledPkg) return cachedInstalledPkg;
+  let dir: string | null = null;
+  try {
+    dir = path.dirname(fileURLToPath(import.meta.url));
+  } catch {
+    // import.meta.url malformed; fall through to bundled
+  }
+  if (dir) {
+    for (let i = 0; i < 6; i++) {
+      const candidate = path.join(dir, "package.json");
+      // A per-candidate try/catch: a transient read error, partial write, or
+      // BOM on any single package.json must NOT abort the upward walk —
+      // otherwise we'd silently fall back to the stale bundled manifest that
+      // issue #39 was about. Keep walking until we either find a matching
+      // manifest or exhaust parents.
+      try {
+        if (existsSync(candidate)) {
+          const json = JSON.parse(readFileSync(candidate, "utf8")) as {
+            name?: string;
+            version?: string;
+          };
+          if (json.name === bundledPkg.name && typeof json.version === "string") {
+            cachedInstalledPkg = { name: json.name, version: json.version };
+            return cachedInstalledPkg;
+          }
+        }
+      } catch {
+        // unreadable / unparsable — continue walking
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  cachedInstalledPkg = { name: bundledPkg.name, version: bundledPkg.version };
+  return cachedInstalledPkg;
+}
+
+/** Test-only: clear or seed the memoized lookup. */
+export function _setInstalledPackageForTesting(
+  value: { name: string; version: string } | null,
+): void {
+  cachedInstalledPkg = value;
+}
+
 type UpdateCache = { checkedAt: number; latestVersion: string };
 
 async function readUpdateCache(): Promise<UpdateCache | null> {
@@ -75,7 +141,7 @@ export async function checkAndAutoUpdate(): Promise<void> {
       await writeUpdateCache({ checkedAt: Date.now(), latestVersion });
     }
 
-    if (compareVersions(pkg.version, latestVersion) < 0) {
+    if (compareVersions(getInstalledPackage().version, latestVersion) < 0) {
       const installed = await runInstall(latestVersion);
       if (installed) {
         reExec(latestVersion);
@@ -90,10 +156,12 @@ async function runInstall(latestVersion: string): Promise<boolean> {
   const pm = detectPackageManager();
   const installCmd =
     pm === "bun"
-      ? `bun add -g agent-yes@${latestVersion}`
-      : `npm install -g agent-yes@${latestVersion}`;
+      ? `bun add -g ${CANONICAL_PKG_NAME}@${latestVersion}`
+      : `npm install -g ${CANONICAL_PKG_NAME}@${latestVersion}`;
 
-  process.stderr.write(`\x1b[33m[agent-yes] Updating ${pkg.version} → ${latestVersion}…\x1b[0m\n`);
+  process.stderr.write(
+    `\x1b[33m[agent-yes] Updating ${getInstalledPackage().version} → ${latestVersion}…\x1b[0m\n`,
+  );
   try {
     const { execaCommand } = await import("execa");
     await execaCommand(installCmd, { stdio: "inherit" });
@@ -128,7 +196,7 @@ function reExec(version: string): never {
  */
 export async function fetchLatestVersion(): Promise<string | null> {
   try {
-    const response = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+    const response = await fetch(`https://registry.npmjs.org/${CANONICAL_PKG_NAME}/latest`, {
       signal: AbortSignal.timeout(3000), // 3 second timeout
     });
 
@@ -215,7 +283,7 @@ export function detectInstallMethod(): string {
  * Format version string with install method
  */
 export function versionString(): string {
-  return `agent-yes v${pkg.version} (${detectInstallMethod()})`;
+  return `agent-yes v${getInstalledPackage().version} (${detectInstallMethod()})`;
 }
 
 /**
@@ -227,7 +295,7 @@ export async function displayVersion(): Promise<void> {
   const latestVersion = await fetchLatestVersion();
 
   if (latestVersion) {
-    const comparison = compareVersions(pkg.version, latestVersion);
+    const comparison = compareVersions(getInstalledPackage().version, latestVersion);
 
     if (comparison < 0) {
       console.log(`\x1b[33m${latestVersion} (update available)\x1b[0m`);

package/dist/SUPPORTED_CLIS-CqAT1Zud.js

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

package/dist/package-DRIilF5m.js

@@ -1,7 +0,0 @@
-//#region package.json
-var name = "agent-yes";
-var version = "1.75.0";
-
-//#endregion
-export { version as n, name as t };
-//# sourceMappingURL=package-DRIilF5m.js.map

package/dist/pidStore-CF54dFqr.js

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