agent-yes 1.90.2 → 1.92.0

package/dist/SUPPORTED_CLIS-nqOr59QU.js

@@ -0,0 +1,12 @@
+import { t as CLIS_CONFIG } from "./ts-CIgbGM8b.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-B1TNIVBt.js";
+import "./pidStore-DTzl6zeh.js";
+import "./globalPidIndex-yVd3mbsV.js";
+
+//#region ts/SUPPORTED_CLIS.ts
+const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
+
+//#endregion
+export { SUPPORTED_CLIS };
+//# sourceMappingURL=SUPPORTED_CLIS-nqOr59QU.js.map

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-_0XCEwWt.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-B1TNIVBt.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -80,8 +80,8 @@ function parseCliArgs(argv, supportedClis) {
 		description: "Send a prompt to the active agent's stdin in current directory"
 	}).option("stdpush", {
 		type: "boolean",
-		description: "Enable external input stream to push additional data to stdin",
-		default: false,
+		description: "Enable external input stream to push additional data to stdin (default: true; pass --no-stdpush to disable). Required for `ay send` to deliver messages to this agent.",
+		default: true,
 		alias: ["ipc", "fifo"]
 	}).option("auto", {
 		type: "string",
@@ -227,7 +227,7 @@ function parseCliArgs(argv, supportedClis) {
 		useSkills: parsedArgv.useSkills,
 		swarmHint: parsedArgv.swarmHint,
 		appendPrompt: parsedArgv.appendPrompt,
-		useStdinAppend: Boolean(parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo),
+		useStdinAppend: Boolean(parsedArgv.stdpush),
 		showVersion: parsedArgv.version,
 		autoYes: parsedArgv.auto !== "no",
 		idleAction: parsedArgv.idleAction,
@@ -482,7 +482,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 {
 	const rawArg = process.argv[2];
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-D5WYWmh-.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DjrOWqD9.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp();
 		process.exit(0);
@@ -515,7 +515,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-C4NNZH6T.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-nqOr59QU.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
@@ -545,7 +545,7 @@ if (config.showVersion) {
 	process.exit(0);
 }
 if (config.appendPrompt) {
-	const { PidStore } = await import("./pidStore-BCsY5BW3.js");
+	const { PidStore } = await import("./pidStore-iJY3JFTn.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 → globalPidIndex-yVd3mbsV.js}

@@ -1,5 +1,5 @@
 import { n as logger } from "./logger-B9h0djqx.js";
-import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { appendFile, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -48,7 +48,7 @@ async function appendGlobalPid(record) {
 		logger.debug("[globalPidIndex] append failed:", error);
 	}
 }
-/** Append a partial status update by pid (status, exit_code, exit_reason). */
+/** Append a partial update by pid (status, exit_code, exit_reason, log_file). */
 async function updateGlobalPidStatus(pid, patch) {
 	try {
 		await withLock(async () => {
@@ -138,7 +138,55 @@ async function maybeCompactGlobalPids() {
 		logger.debug("[globalPidIndex] compact failed:", error);
 	}
 }
+/** Default log retention: sessions older than this whose process is gone. */
+const DEFAULT_RETENTION_DAYS = 7;
+function retentionMs() {
+	const days = Number(process.env.AGENT_YES_LOG_RETENTION_DAYS);
+	return (Number.isFinite(days) && days > 0 ? days : DEFAULT_RETENTION_DAYS) * 24 * 60 * 60 * 1e3;
+}
+/** All on-disk log files associated with a record (raw + rendered + sidecars). */
+function logSiblings(logFile) {
+	if (!logFile) return [];
+	const base = logFile.replace(/\.raw\.log$|\.log$/, "");
+	return [
+		`${base}.raw.log`,
+		`${base}.log`,
+		`${base}.lines.log`,
+		`${base}.debug.log`
+	];
+}
+/**
+* Index-driven retention sweep: delete the log files of sessions whose process
+* is gone (exited or dead pid) and that started longer ago than the retention
+* window. Because the index records absolute `log_file` paths, this reclaims
+* logs scattered across many project `.agent-yes/` dirs from one call.
+* Best-effort; never throws. Returns the number of files removed.
+*/
+async function pruneOldLogs(maxAgeMs = retentionMs()) {
+	let records;
+	try {
+		records = await readGlobalPidsRaw();
+	} catch {
+		return 0;
+	}
+	const now = Date.now();
+	let removed = 0;
+	for (const r of records) {
+		const dead = r.status === "exited" || !isProcessAlive(r.pid);
+		const old = now - (r.started_at ?? now) > maxAgeMs;
+		if (!dead || !old) continue;
+		for (const f of logSiblings(r.log_file)) try {
+			await unlink(f);
+			removed++;
+		} catch {}
+	}
+	if (removed > 0) {
+		logger.debug(`[globalPidIndex] pruned ${removed} stale log file(s)`);
+		await maybeCompactGlobalPids();
+	}
+	return removed;
+}
 
 //#endregion
-export { updateGlobalPidStatus as i, maybeCompactGlobalPids as n, readGlobalPids as r, appendGlobalPid as t };
-//# sourceMappingURL=globalPidIndex-Cr-g75QF.js.map
+export { updateGlobalPidStatus as a, readGlobalPids as i, maybeCompactGlobalPids as n, pruneOldLogs as r, appendGlobalPid as t };
+//# sourceMappingURL=globalPidIndex-yVd3mbsV.js.map

package/dist/index.js

@@ -1,7 +1,7 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CdqzM4tm.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CIgbGM8b.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-_0XCEwWt.js";
-import "./pidStore-C1JXxoPi.js";
-import "./globalPidIndex-Cr-g75QF.js";
+import "./versionChecker-B1TNIVBt.js";
+import "./pidStore-DTzl6zeh.js";
+import "./globalPidIndex-yVd3mbsV.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

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

@@ -1,7 +1,8 @@
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as updateGlobalPidStatus, n as maybeCompactGlobalPids, t as appendGlobalPid } from "./globalPidIndex-Cr-g75QF.js";
+import { a as updateGlobalPidStatus, n as maybeCompactGlobalPids, r as pruneOldLogs, t as appendGlobalPid } from "./globalPidIndex-yVd3mbsV.js";
 import { closeSync, existsSync, fsyncSync, openSync } from "fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
 import path from "path";
 import { lock } from "proper-lockfile";
 
@@ -183,6 +184,26 @@ function generateId() {
 	return Date.now().toString(36) + (idCounter++).toString(36) + Math.random().toString(36).slice(2, 6);
 }
 
+//#endregion
+//#region ts/agentYesHome.ts
+/**
+* Root directory for cross-runtime, machine-global agent-yes state:
+* the pid index (`pids.jsonl`), FIFO/named-pipe IPC endpoints (`fifo/`),
+* winsize signals, notes, and the serve token.
+*
+* Durable per-session *logs* deliberately do NOT live here — they go under
+* `<cwd>/.agent-yes/` so they stay colocated with the project that produced
+* them (see `PidStore`). Only ephemeral IPC + the discovery index are global,
+* which keeps FIFOs on the local home filesystem (reliable `mkfifo`) and lets
+* `ay ls`/`ay attach` find every agent regardless of the caller's cwd.
+*
+* Resolved at call time (not module load) so tests and callers can override
+* via `$AGENT_YES_HOME` without juggling the module cache.
+*/
+function agentYesHome() {
+	return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}
+
 //#endregion
 //#region ts/pidStore.ts
 var PidStore = class PidStore {
@@ -197,6 +218,7 @@ var PidStore = class PidStore {
 			await this.ensureGitignore();
 			await this.store.load();
 			await this.cleanStaleRecords();
+			pruneOldLogs().catch(() => null);
 		} catch (error) {
 			logger.warn("[pidStore] Failed to initialize:", error);
 		}
@@ -204,7 +226,7 @@ var PidStore = class PidStore {
 	async registerProcess({ pid, cli, args, prompt, cwd }) {
 		const now = Date.now();
 		const argsJson = JSON.stringify(args);
-		const logFile = path.resolve(this.getLogDir(), `${pid}.log`);
+		const logFile = this.getRawLogPath(pid);
 		const fifoFile = this.getFifoPath(pid);
 		const record = {
 			pid,
@@ -259,12 +281,34 @@ var PidStore = class PidStore {
 	getAllRecords() {
 		return this.store.getAll();
 	}
+	/** Project-local store dir: `<cwd>/.agent-yes`. Durable logs live here. */
+	getStoreDir() {
+		return this.storeDir;
+	}
 	getLogDir() {
 		return path.resolve(this.storeDir, "logs");
 	}
+	/** Raw PTY byte log (runtime), `<cwd>/.agent-yes/<pid>.raw.log`. */
+	getRawLogPath(pid) {
+		return path.resolve(this.storeDir, `${pid}.raw.log`);
+	}
+	/** Rendered plain-text log (final), `<cwd>/.agent-yes/<pid>.log`. */
+	getRenderedLogPath(pid) {
+		return path.resolve(this.storeDir, `${pid}.log`);
+	}
 	getFifoPath(pid) {
 		if (process.platform === "win32") return `\\\\.\\pipe\\agent-yes-${pid}`;
-		else return path.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+		else return path.resolve(agentYesHome(), "fifo", `${pid}.stdin`);
+	}
+	/**
+	* Repoint a session's log from the raw byte stream to its rendered text log
+	* (called on clean exit once the rendered log is durably written and the raw
+	* log has been reclaimed). Updates both the local record and global index.
+	*/
+	async markRendered(pid, renderedPath) {
+		const existing = this.store.findOne((doc) => doc.pid === pid);
+		if (existing) await this.store.updateById(existing._id, { logFile: renderedPath });
+		updateGlobalPidStatus(pid, { log_file: renderedPath }).catch(() => null);
 	}
 	async cleanStaleRecords() {
 		const activeRecords = this.store.find((r) => r.status !== "exited");
@@ -337,4 +381,4 @@ pid-db/
 
 //#endregion
 export { PidStore as t };
-//# sourceMappingURL=pidStore-C1JXxoPi.js.map
+//# sourceMappingURL=pidStore-DTzl6zeh.js.map

package/dist/pidStore-iJY3JFTn.js

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

package/dist/{serve-BYPX6VXm.js → serve-CixOwENN.js}

@@ -1,7 +1,7 @@
 import "./logger-B9h0djqx.js";
-import "./globalPidIndex-Cr-g75QF.js";
+import "./globalPidIndex-yVd3mbsV.js";
 import "./remotes-Bjp2GYPz.js";
-import { c as readNotes, f as snapshotStatus, l as renderRawLog, m as writeToIpc, o as listRecords, r as controlCodeFromName, u as resolveOne } from "./subcommands-LRmJ4_iJ.js";
+import { c as readNotes, f as snapshotStatus, l as renderRawLog, m as writeToIpc, o as listRecords, r as controlCodeFromName, u as resolveOne } from "./subcommands-D9wmaZ3U.js";
 import yargs from "yargs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -312,4 +312,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-BYPX6VXm.js.map
+//# sourceMappingURL=serve-CixOwENN.js.map

package/dist/{subcommands-LRmJ4_iJ.js → subcommands-D9wmaZ3U.js}

@@ -1,4 +1,4 @@
-import { r as readGlobalPids } from "./globalPidIndex-Cr-g75QF.js";
+import { i as readGlobalPids } from "./globalPidIndex-yVd3mbsV.js";
 import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-Bjp2GYPz.js";
 import ms from "ms";
 import yargs from "yargs";
@@ -162,7 +162,7 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-BYPX6VXm.js");
+				const { cmdServe } = await import("./serve-CixOwENN.js");
 				return cmdServe(rest);
 			}
 			case "remote": {
@@ -1447,4 +1447,4 @@ async function cmdStatus(rest) {
 
 //#endregion
 export { isSubcommand as a, readNotes as c, runSubcommand as d, snapshotStatus as f, isPidAlive as i, renderRawLog as l, writeToIpc as m, cmdHelp as n, listRecords as o, stopTipForCli as p, controlCodeFromName as r, matchKeyword as s, GRACEFUL_EXIT_COMMANDS as t, resolveOne as u };
-//# sourceMappingURL=subcommands-LRmJ4_iJ.js.map
+//# sourceMappingURL=subcommands-D9wmaZ3U.js.map

package/dist/{subcommands-D5WYWmh-.js → subcommands-DjrOWqD9.js}

@@ -1,6 +1,6 @@
 import "./logger-B9h0djqx.js";
-import "./globalPidIndex-Cr-g75QF.js";
+import "./globalPidIndex-yVd3mbsV.js";
 import "./remotes-Bjp2GYPz.js";
-import { a as isSubcommand, c as readNotes, d as runSubcommand, f as snapshotStatus, i as isPidAlive, l as renderRawLog, m as writeToIpc, n as cmdHelp, o as listRecords, p as stopTipForCli, r as controlCodeFromName, s as matchKeyword, t as GRACEFUL_EXIT_COMMANDS, u as resolveOne } from "./subcommands-LRmJ4_iJ.js";
+import { a as isSubcommand, c as readNotes, d as runSubcommand, f as snapshotStatus, i as isPidAlive, l as renderRawLog, m as writeToIpc, n as cmdHelp, o as listRecords, p as stopTipForCli, r as controlCodeFromName, s as matchKeyword, t as GRACEFUL_EXIT_COMMANDS, u as resolveOne } from "./subcommands-D9wmaZ3U.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{ts-CdqzM4tm.js → ts-CIgbGM8b.js}

@@ -1,8 +1,8 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-_0XCEwWt.js";
+import { r as getInstalledPackage } from "./versionChecker-B1TNIVBt.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-C22d9SRJ.js";
-import { t as PidStore } from "./pidStore-C1JXxoPi.js";
-import { r as readGlobalPids } from "./globalPidIndex-Cr-g75QF.js";
+import { t as PidStore } from "./pidStore-DTzl6zeh.js";
+import { i as readGlobalPids } from "./globalPidIndex-yVd3mbsV.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -538,13 +538,13 @@ async function sendMessage(context, message, { waitForReady = true } = {}) {
 * @returns Object containing all log paths
 */
 async function initializeLogPaths(pidStore, pid) {
-	const logDir = pidStore.getLogDir();
-	await mkdir(logDir, { recursive: true });
+	const storeDir = pidStore.getStoreDir();
+	await mkdir(storeDir, { recursive: true });
 	return {
-		logPath: logDir,
-		rawLogPath: path.resolve(path.dirname(logDir), `${pid}.raw.log`),
-		rawLinesLogPath: path.resolve(path.dirname(logDir), `${pid}.lines.log`),
-		debuggingLogsPath: path.resolve(path.dirname(logDir), `${pid}.debug.log`)
+		logPath: pidStore.getRenderedLogPath(pid),
+		rawLogPath: pidStore.getRawLogPath(pid),
+		rawLinesLogPath: path.resolve(storeDir, `${pid}.lines.log`),
+		debuggingLogsPath: path.resolve(storeDir, `${pid}.debug.log`)
 	};
 }
 /**
@@ -566,10 +566,17 @@ async function setupDebugLogging(debuggingLogsPath) {
 * @param content Rendered content to save
 */
 async function saveLogFile(logPath, content) {
-	if (!logPath) return;
-	await mkdir(path.dirname(logPath), { recursive: true }).catch(() => null);
-	await writeFile(logPath, content).catch(() => null);
-	logger.info(`Full logs saved to ${logPath}`);
+	if (!logPath) return false;
+	if (!content.trim()) return false;
+	try {
+		await mkdir(path.dirname(logPath), { recursive: true });
+		await writeFile(logPath, content);
+		logger.info(`Full logs saved to ${logPath}`);
+		return true;
+	} catch (error) {
+		logger.warn(`Failed to save rendered log to ${logPath}:`, error);
+		return false;
+	}
 }
 /**
 * Save logs to deprecated logFile option (for backward compatibility)
@@ -1220,6 +1227,7 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 	notifyWebhook("RUNNING", prompt ?? "", workingDir).catch(() => null);
 	const logPaths = await initializeLogPaths(pidStore, shell.pid);
 	await setupDebugLogging(logPaths.debuggingLogsPath);
+	let usedAltScreen = false;
 	const ctx = new AgentContext({
 		shell,
 		pidStore,
@@ -1613,6 +1621,7 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 		return await mkdir(path.dirname(rawLogPath), { recursive: true }).then(() => {
 			logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
 			return f.forEach(async (chars) => {
+				if (!usedAltScreen && /\[\?(?:1049|1047|47)h/.test(chars)) usedAltScreen = true;
 				await writeFile(rawLogPath, chars, { flag: "a" }).catch(() => null);
 			}).run();
 		}).catch(() => f.run());
@@ -1655,7 +1664,10 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 			}
 		});
 	}).by((s) => removeControlCharactersFromStdout ? s.map((e) => removeControlCharacters(e)) : s).by(createTerminatorStream(pendingExitCode.promise)).to(fromWritable(process.stdout));
-	await saveLogFile(ctx.logPaths.logPath, xtermProxy.render());
+	if (await saveLogFile(ctx.logPaths.logPath, xtermProxy.render()) && !usedAltScreen && ctx.logPaths.rawLogPath && ctx.logPaths.logPath) {
+		await unlink(ctx.logPaths.rawLogPath).catch(() => null);
+		await pidStore.markRendered(shell.pid, ctx.logPaths.logPath).catch(() => null);
+	}
 	const exitCode = await pendingExitCode.promise;
 	logger.info(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
 	await pidStore.close();
@@ -1693,4 +1705,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-CdqzM4tm.js.map
+//# sourceMappingURL=ts-CIgbGM8b.js.map

package/dist/{versionChecker-_0XCEwWt.js → versionChecker-B1TNIVBt.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.90.2";
+var version = "1.92.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -221,4 +221,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-_0XCEwWt.js.map
+//# sourceMappingURL=versionChecker-B1TNIVBt.js.map

package/package.json

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

package/ts/agentYesHome.spec.ts

@@ -0,0 +1,25 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { homedir } from "os";
+import path from "path";
+import { agentYesHome } from "./agentYesHome.ts";
+
+describe("agentYesHome", () => {
+  let original: string | undefined;
+  beforeEach(() => {
+    original = process.env.AGENT_YES_HOME;
+  });
+  afterEach(() => {
+    if (original === undefined) delete process.env.AGENT_YES_HOME;
+    else process.env.AGENT_YES_HOME = original;
+  });
+
+  it("uses $AGENT_YES_HOME when set", () => {
+    process.env.AGENT_YES_HOME = "/custom/ay-home";
+    expect(agentYesHome()).toBe("/custom/ay-home");
+  });
+
+  it("falls back to ~/.agent-yes when unset", () => {
+    delete process.env.AGENT_YES_HOME;
+    expect(agentYesHome()).toBe(path.join(homedir(), ".agent-yes"));
+  });
+});

package/ts/agentYesHome.ts

@@ -0,0 +1,20 @@
+import { homedir } from "os";
+import path from "path";
+
+/**
+ * Root directory for cross-runtime, machine-global agent-yes state:
+ * the pid index (`pids.jsonl`), FIFO/named-pipe IPC endpoints (`fifo/`),
+ * winsize signals, notes, and the serve token.
+ *
+ * Durable per-session *logs* deliberately do NOT live here — they go under
+ * `<cwd>/.agent-yes/` so they stay colocated with the project that produced
+ * them (see `PidStore`). Only ephemeral IPC + the discovery index are global,
+ * which keeps FIFOs on the local home filesystem (reliable `mkfifo`) and lets
+ * `ay ls`/`ay attach` find every agent regardless of the caller's cwd.
+ *
+ * Resolved at call time (not module load) so tests and callers can override
+ * via `$AGENT_YES_HOME` without juggling the module cache.
+ */
+export function agentYesHome(): string {
+  return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}

package/ts/globalPidIndex.spec.ts

@@ -205,6 +205,146 @@ describe("globalPidIndex", () => {
     await mod.maybeCompactGlobalPids(); // no throw, no error
   });
 
+  it("updateGlobalPidStatus can repoint log_file (raw -> rendered)", async () => {
+    const mod = await loadModule();
+    await mod.appendGlobalPid({
+      pid: 4242,
+      cli: "claude",
+      prompt: null,
+      cwd: "/a",
+      log_file: "/a/.agent-yes/4242.raw.log",
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: 1,
+    });
+    await mod.updateGlobalPidStatus(4242, { log_file: "/a/.agent-yes/4242.log" });
+    const records = await mod.readGlobalPids();
+    expect(records[0]?.log_file).toBe("/a/.agent-yes/4242.log");
+  });
+
+  describe("pruneOldLogs", () => {
+    it("deletes log siblings of old, dead sessions but keeps live/recent ones", async () => {
+      const mod = await loadModule();
+      const { mkdir, writeFile } = await import("fs/promises");
+      const { existsSync } = await import("fs");
+      const dir = path.join(testHome, "logs");
+      await mkdir(dir, { recursive: true });
+
+      // Old + dead pid: should be pruned (raw + rendered + sidecars).
+      const deadRaw = path.join(dir, "999999.raw.log");
+      const deadRendered = path.join(dir, "999999.log");
+      const deadLines = path.join(dir, "999999.lines.log");
+      for (const f of [deadRaw, deadRendered, deadLines]) await writeFile(f, "x");
+
+      // Live pid (this process), old timestamp: must be kept (still running).
+      const liveRaw = path.join(dir, `${process.pid}.raw.log`);
+      await writeFile(liveRaw, "x");
+
+      // Dead pid but recent: must be kept (inside retention window).
+      const recentRaw = path.join(dir, "999998.raw.log");
+      await writeFile(recentRaw, "x");
+
+      const oldTs = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days ago
+      await mod.appendGlobalPid({
+        pid: 999999,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: deadRaw,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: oldTs,
+      });
+      await mod.appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: liveRaw,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: oldTs,
+      });
+      await mod.appendGlobalPid({
+        pid: 999998,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: recentRaw,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+
+      const removed = await mod.pruneOldLogs();
+
+      expect(removed).toBe(3); // deadRaw + deadRendered + deadLines
+      expect(existsSync(deadRaw)).toBe(false);
+      expect(existsSync(deadRendered)).toBe(false);
+      expect(existsSync(deadLines)).toBe(false);
+      expect(existsSync(liveRaw)).toBe(true);
+      expect(existsSync(recentRaw)).toBe(true);
+    });
+
+    it("returns 0 and does not throw when the index is empty", async () => {
+      const mod = await loadModule();
+      expect(await mod.pruneOldLogs()).toBe(0);
+    });
+
+    it("skips records with no log_file and honors an explicit maxAge", async () => {
+      const mod = await loadModule();
+      await mod.appendGlobalPid({
+        pid: 999999,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: null,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: 1,
+      });
+      // Old + dead but no log_file to delete → nothing removed, no throw.
+      expect(await mod.pruneOldLogs(1)).toBe(0);
+    });
+
+    it("respects $AGENT_YES_LOG_RETENTION_DAYS for the default window", async () => {
+      const mod = await loadModule();
+      const { mkdir, writeFile } = await import("fs/promises");
+      const { existsSync } = await import("fs");
+      const dir = path.join(testHome, "logs");
+      await mkdir(dir, { recursive: true });
+      const raw = path.join(dir, "999999.raw.log");
+      await writeFile(raw, "x");
+      const twoDaysAgo = Date.now() - 2 * 24 * 60 * 60 * 1000;
+      await mod.appendGlobalPid({
+        pid: 999999,
+        cli: "claude",
+        prompt: null,
+        cwd: "/a",
+        log_file: raw,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: twoDaysAgo,
+      });
+
+      const original = process.env.AGENT_YES_LOG_RETENTION_DAYS;
+      try {
+        process.env.AGENT_YES_LOG_RETENTION_DAYS = "1"; // 1-day window → 2-day-old log is stale
+        expect(await mod.pruneOldLogs()).toBe(1);
+        expect(existsSync(raw)).toBe(false);
+      } finally {
+        if (original === undefined) delete process.env.AGENT_YES_LOG_RETENTION_DAYS;
+        else process.env.AGENT_YES_LOG_RETENTION_DAYS = original;
+      }
+    });
+  });
+
   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, rename, writeFile } from "fs/promises";
+import { appendFile, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -86,10 +86,10 @@ export async function appendGlobalPid(record: GlobalPidRecord): Promise<void> {
   }
 }
 
-/** Append a partial status update by pid (status, exit_code, exit_reason). */
+/** Append a partial update by pid (status, exit_code, exit_reason, log_file). */
 export async function updateGlobalPidStatus(
   pid: number,
-  patch: Partial<Pick<GlobalPidRecord, "status" | "exit_code" | "exit_reason">>,
+  patch: Partial<Pick<GlobalPidRecord, "status" | "exit_code" | "exit_reason" | "log_file">>,
 ): Promise<void> {
   try {
     await withLock(async () => {
@@ -190,3 +190,55 @@ export async function maybeCompactGlobalPids(): Promise<void> {
     logger.debug("[globalPidIndex] compact failed:", error);
   }
 }
+
+/** Default log retention: sessions older than this whose process is gone. */
+const DEFAULT_RETENTION_DAYS = 7;
+
+function retentionMs(): number {
+  const days = Number(process.env.AGENT_YES_LOG_RETENTION_DAYS);
+  return (Number.isFinite(days) && days > 0 ? days : DEFAULT_RETENTION_DAYS) * 24 * 60 * 60 * 1000;
+}
+
+/** All on-disk log files associated with a record (raw + rendered + sidecars). */
+function logSiblings(logFile: string | null): string[] {
+  if (!logFile) return [];
+  // logFile may point at either `<pid>.raw.log` or `<pid>.log`; derive the rest.
+  const base = logFile.replace(/\.raw\.log$|\.log$/, "");
+  return [`${base}.raw.log`, `${base}.log`, `${base}.lines.log`, `${base}.debug.log`];
+}
+
+/**
+ * Index-driven retention sweep: delete the log files of sessions whose process
+ * is gone (exited or dead pid) and that started longer ago than the retention
+ * window. Because the index records absolute `log_file` paths, this reclaims
+ * logs scattered across many project `.agent-yes/` dirs from one call.
+ * Best-effort; never throws. Returns the number of files removed.
+ */
+export async function pruneOldLogs(maxAgeMs: number = retentionMs()): Promise<number> {
+  let records: GlobalPidRecord[];
+  try {
+    records = await readGlobalPidsRaw();
+  } catch {
+    return 0;
+  }
+  const now = Date.now();
+  let removed = 0;
+  for (const r of records) {
+    const dead = r.status === "exited" || !isProcessAlive(r.pid);
+    const old = now - (r.started_at ?? now) > maxAgeMs;
+    if (!dead || !old) continue;
+    for (const f of logSiblings(r.log_file)) {
+      try {
+        await unlink(f);
+        removed++;
+      } catch {
+        // missing / already gone — ignore
+      }
+    }
+  }
+  if (removed > 0) {
+    logger.debug(`[globalPidIndex] pruned ${removed} stale log file(s)`);
+    await maybeCompactGlobalPids();
+  }
+  return removed;
+}

package/ts/index.ts

@@ -1,6 +1,6 @@
 import { execaCommandSync, parseCommandString } from "execa";
 import { fromWritable } from "from-node-stream";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import path from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
@@ -383,6 +383,13 @@ export default async function agentYes({
   const logPaths = await initializeLogPaths(pidStore, shell.pid);
   await setupDebugLogging(logPaths.debuggingLogsPath);
 
+  // Track whether the session ever switched to the alternate screen buffer.
+  // render() reconstructs scrollback of the normal buffer only; the alt buffer
+  // keeps no scrollback, so for alt-screen apps the rendered log would be just
+  // the final frame and must NOT replace the raw byte log. Current CLIs (ink-
+  // based claude/codex) stay on the normal buffer, but guard for the future.
+  let usedAltScreen = false;
+
   // Create agent context
   const ctx = new AgentContext({
     shell,
@@ -949,6 +956,11 @@ export default async function agentYes({
           logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
           return f
             .forEach(async (chars) => {
+              // Detect alt-screen enter (DECSET 1049/1047/47) so we know whether
+              // the rendered log can safely stand in for this raw log on exit.
+              if (!usedAltScreen && /\[\?(?:1049|1047|47)h/.test(chars)) {
+                usedAltScreen = true;
+              }
               await writeFile(rawLogPath, chars, { flag: "a" }).catch(() => null);
             })
             .run();
@@ -1054,7 +1066,17 @@ export default async function agentYes({
     .by(createTerminatorStream(pendingExitCode.promise))
     .to(fromWritable(process.stdout));
 
-  await saveLogFile(ctx.logPaths.logPath, xtermProxy.render());
+  const renderedSaved = await saveLogFile(ctx.logPaths.logPath, xtermProxy.render());
+
+  // The raw byte log exists for live tailing during the run. Once a non-empty
+  // rendered log is durably written — and the session stayed on the normal
+  // screen buffer, so the render holds the full scrollback — the raw log is
+  // redundant: drop it and repoint the index at the rendered log. On crash /
+  // empty render / alt-screen we keep the raw log; the startup sweep prunes it.
+  if (renderedSaved && !usedAltScreen && ctx.logPaths.rawLogPath && ctx.logPaths.logPath) {
+    await unlink(ctx.logPaths.rawLogPath).catch(() => null);
+    await pidStore.markRendered(shell.pid, ctx.logPaths.logPath).catch(() => null);
+  }
 
   // and then get its exitcode
   const exitCode = await pendingExitCode.promise;

package/ts/parseCliArgs.spec.ts

@@ -421,4 +421,22 @@ describe("CLI argument parsing", () => {
     expect(result.queue).toBe(false);
     expect(result.cliArgs).not.toContain("--no-queue");
   });
+
+  it("enables stdpush IPC by default", () => {
+    // --stdpush defaults to true so `ay send` works out of the box.
+    // Without this, fifo_file ends up null in pids.jsonl and `ay send` returns 409.
+    const result = parseCliArgs(["node", "/path/to/ay", "claude"]);
+
+    expect(result.useStdinAppend).toBe(true);
+  });
+
+  it("respects --no-stdpush opt-out only when placed before the CLI positional", () => {
+    // halt-at-non-option means agent-yes flags must precede the CLI positional.
+    const beforeCli = parseCliArgs(["node", "/path/to/ay", "--no-stdpush", "claude"]);
+    const afterCli = parseCliArgs(["node", "/path/to/ay", "claude", "--no-stdpush"]);
+
+    expect(beforeCli.useStdinAppend).toBe(false);
+    expect(afterCli.useStdinAppend).toBe(true);
+    expect(afterCli.cliArgs).toContain("--no-stdpush");
+  });
 });

package/ts/parseCliArgs.ts

@@ -114,8 +114,9 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
     })
     .option("stdpush", {
       type: "boolean",
-      description: "Enable external input stream to push additional data to stdin",
-      default: false,
+      description:
+        "Enable external input stream to push additional data to stdin (default: true; pass --no-stdpush to disable). Required for `ay send` to deliver messages to this agent.",
+      default: true,
       alias: ["ipc", "fifo"], // backward compatibility
     })
     .option("auto", {
@@ -321,7 +322,7 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
     useSkills: parsedArgv.useSkills,
     swarmHint: parsedArgv.swarmHint,
     appendPrompt: parsedArgv.appendPrompt,
-    useStdinAppend: Boolean(parsedArgv.stdpush || parsedArgv.ipc || parsedArgv.fifo), // Support --stdpush, --ipc, and --fifo (backward compatibility)
+    useStdinAppend: Boolean(parsedArgv.stdpush), // --ipc and --fifo are yargs aliases of --stdpush; reading the canonical key ensures --no-stdpush wins over alias defaults
     showVersion: parsedArgv.version,
     autoYes: parsedArgv.auto !== "no", // auto-yes enabled by default, disabled with --auto=no
     idleAction: parsedArgv.idleAction as string | undefined,

package/ts/pidStore.spec.ts

@@ -106,7 +106,9 @@ describe("PidStore", () => {
         cwd: "/tmp",
       });
 
-      expect(rec.logFile).toContain("42.log");
+      // The index points at the raw log during the run (repointed to the
+      // rendered <pid>.log on clean exit via markRendered).
+      expect(rec.logFile).toContain("42.raw.log");
       if (isWindows) {
         expect(rec.fifoFile).toContain("agent-yes-42");
       } else {
@@ -245,9 +247,32 @@ describe("PidStore", () => {
       if (isWindows) {
         expect(fifo).toBe(`\\\\.\\pipe\\agent-yes-42`);
       } else {
-        expect(fifo).toBe(path.resolve(TEST_DIR, ".agent-yes", "fifo", "42.stdin"));
+        // FIFO lives under the global home root (AGENT_YES_HOME), not the
+        // project dir — ephemeral IPC is intentionally not colocated with logs.
+        expect(fifo).toBe(path.resolve(GLOBAL_TEST_DIR, "fifo", "42.stdin"));
       }
     });
+
+    it("raw/rendered/store paths resolve under the project store dir", () => {
+      expect(store.getStoreDir()).toBe(path.resolve(TEST_DIR, ".agent-yes"));
+      expect(store.getRawLogPath(42)).toBe(path.resolve(TEST_DIR, ".agent-yes", "42.raw.log"));
+      expect(store.getRenderedLogPath(42)).toBe(path.resolve(TEST_DIR, ".agent-yes", "42.log"));
+    });
+  });
+
+  describe("markRendered", () => {
+    it("repoints the record's logFile to the rendered path", async () => {
+      await store.registerProcess({ pid: 51, cli: "claude", args: [], cwd: "/tmp" });
+      const rendered = store.getRenderedLogPath(51);
+      await store.markRendered(51, rendered);
+
+      const rec = store.getAllRecords().find((r) => r.pid === 51);
+      expect(rec?.logFile).toBe(rendered);
+    });
+
+    it("is a no-op for an unknown pid", async () => {
+      await expect(store.markRendered(999123, "/whatever/999123.log")).resolves.toBeUndefined();
+    });
   });
 
   describe("gitignore", () => {

package/ts/pidStore.ts

@@ -2,9 +2,11 @@ import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { logger } from "./logger.ts";
 import { JsonlStore } from "./JsonlStore.ts";
+import { agentYesHome } from "./agentYesHome.ts";
 import {
   appendGlobalPid,
   maybeCompactGlobalPids,
+  pruneOldLogs,
   updateGlobalPidStatus,
 } from "./globalPidIndex.ts";
 
@@ -37,6 +39,10 @@ export class PidStore {
       await this.ensureGitignore();
       await this.store.load();
       await this.cleanStaleRecords();
+      // Best-effort, fire-and-forget: reclaim raw/rendered logs of long-dead
+      // sessions across all projects. Index-driven so scattered pwd logs are
+      // still swept. Never block startup on it.
+      pruneOldLogs().catch(() => null);
     } catch (error) {
       logger.warn("[pidStore] Failed to initialize:", error);
     }
@@ -57,7 +63,10 @@ export class PidStore {
   }): Promise<PidRecord> {
     const now = Date.now();
     const argsJson = JSON.stringify(args);
-    const logFile = path.resolve(this.getLogDir(), `${pid}.log`);
+    // The index points at the file readers should tail. During the run that is
+    // the raw byte log (`ay logs`/`attach` stream it live); on clean exit it is
+    // repointed to the rendered log via `markRendered`.
+    const logFile = this.getRawLogPath(pid);
     const fifoFile = this.getFifoPath(pid);
 
     const record: Omit<PidRecord, "_id"> = {
@@ -138,16 +147,47 @@ export class PidStore {
     return this.store.getAll();
   }
 
+  /** Project-local store dir: `<cwd>/.agent-yes`. Durable logs live here. */
+  getStoreDir() {
+    return this.storeDir;
+  }
+
   getLogDir() {
     return path.resolve(this.storeDir, "logs");
   }
 
+  /** Raw PTY byte log (runtime), `<cwd>/.agent-yes/<pid>.raw.log`. */
+  getRawLogPath(pid: number) {
+    return path.resolve(this.storeDir, `${pid}.raw.log`);
+  }
+
+  /** Rendered plain-text log (final), `<cwd>/.agent-yes/<pid>.log`. */
+  getRenderedLogPath(pid: number) {
+    return path.resolve(this.storeDir, `${pid}.log`);
+  }
+
   getFifoPath(pid: number) {
     if (process.platform === "win32") {
       return `\\\\.\\pipe\\agent-yes-${pid}`;
     } else {
-      return path.resolve(this.storeDir, "fifo", `${pid}.stdin`);
+      // Ephemeral IPC lives under the global home root, not the project dir:
+      // keeps the FIFO on a local filesystem (reliable mkfifo) and stable even
+      // if the project dir is moved/removed while the agent runs.
+      return path.resolve(agentYesHome(), "fifo", `${pid}.stdin`);
+    }
+  }
+
+  /**
+   * Repoint a session's log from the raw byte stream to its rendered text log
+   * (called on clean exit once the rendered log is durably written and the raw
+   * log has been reclaimed). Updates both the local record and global index.
+   */
+  async markRendered(pid: number, renderedPath: string): Promise<void> {
+    const existing = this.store.findOne((doc) => doc.pid === pid);
+    if (existing) {
+      await this.store.updateById(existing._id!, { logFile: renderedPath });
     }
+    updateGlobalPidStatus(pid, { log_file: renderedPath }).catch(() => null);
   }
 
   async cleanStaleRecords(): Promise<void> {

package/dist/SUPPORTED_CLIS-C4NNZH6T.js

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

package/dist/pidStore-BCsY5BW3.js

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