agent-yes 1.60.6 → 1.61.0

package/dist/{SUPPORTED_CLIS--w_SPLyp.js → SUPPORTED_CLIS-C0l1NfFH.js}

@@ -1,22 +1,22 @@
-import { t as logger } from "./logger-CY9ormLF.js";
+import { t as logger } from "./logger-CX77vJDA.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync } from "fs";
-import path, { dirname, join } from "path";
-import { readFile } from "node:fs/promises";
-import os from "node:os";
-import path$1 from "node:path";
-import winston from "winston";
 import { execaCommandSync, parseCommandString } from "execa";
 import { fromWritable } from "from-node-stream";
-import { appendFile, mkdir as mkdir$1, readFile as readFile$1, readdir, rename, writeFile as writeFile$1 } from "fs/promises";
+import { appendFile, mkdir, readFile, readdir, rename, writeFile } from "fs/promises";
+import path, { dirname, join } from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
 import { TerminalRenderStream } from "terminal-render";
 import { homedir } from "os";
+import winston from "winston";
+import { closeSync, existsSync, fsyncSync, openSync } from "fs";
 import { lock } from "proper-lockfile";
 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";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -44,7 +44,7 @@ const getCodexSessionsDir = () => process.env.CLI_YES_TEST_HOME ? path.join(proc
 */
 async function loadSessionMap() {
 	try {
-		const content = await readFile$1(getSessionsFile(), "utf-8");
+		const content = await readFile(getSessionsFile(), "utf-8");
 		return JSON.parse(content);
 	} catch {
 		return {};
@@ -56,8 +56,8 @@ async function loadSessionMap() {
 async function saveSessionMap(sessionMap) {
 	try {
 		const sessionsFile = getSessionsFile();
-		await mkdir$1(path.dirname(sessionsFile), { recursive: true });
-		await writeFile$1(sessionsFile, JSON.stringify(sessionMap, null, 2));
+		await mkdir(path.dirname(sessionsFile), { recursive: true });
+		await writeFile(sessionsFile, JSON.stringify(sessionMap, null, 2));
 	} catch (error) {
 		console.warn("Failed to save codex session map:", error);
 	}
@@ -78,7 +78,7 @@ async function storeSessionForCwd(cwd, sessionId) {
 */
 async function parseCodexSessionFile(filePath) {
 	try {
-		const lines = (await readFile$1(filePath, "utf-8")).trim().split("\n");
+		const lines = (await readFile(filePath, "utf-8")).trim().split("\n");
 		for (const line of lines) {
 			if (!line.trim()) continue;
 			const data = JSON.parse(line);
@@ -252,9 +252,9 @@ async function readLockFile() {
 	try {
 		const lockDir = getLockDir();
 		const lockFilePath = getLockFile();
-		await mkdir$1(lockDir, { recursive: true });
+		await mkdir(lockDir, { recursive: true });
 		if (!existsSync(lockFilePath)) return { tasks: [] };
-		const content = await readFile$1(lockFilePath, "utf8");
+		const content = await readFile(lockFilePath, "utf8");
 		const lockFile = JSON.parse(content);
 		lockFile.tasks = lockFile.tasks.filter((task) => {
 			if (isProcessRunning(task.pid)) return true;
@@ -272,9 +272,9 @@ async function writeLockFile(lockFile, retryCount = 0) {
 	try {
 		const lockDir = getLockDir();
 		const lockFilePath = getLockFile();
-		await mkdir$1(lockDir, { recursive: true });
+		await mkdir(lockDir, { recursive: true });
 		const tempFile = `${lockFilePath}.tmp.${process.pid}`;
-		await writeFile$1(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
+		await writeFile(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
 		await rename(tempFile, lockFilePath);
 	} catch (error) {
 		if (retryCount < MAX_RETRIES) {
@@ -437,19 +437,17 @@ function shouldUseLock(_cwd) {
 var JsonlStore = class {
 	filePath;
 	tempPath;
-	lockPath;
 	docs = /* @__PURE__ */ new Map();
 	constructor(filePath) {
 		this.filePath = filePath;
 		this.tempPath = filePath + "~";
-		this.lockPath = path.dirname(filePath);
 	}
 	/**
 	* Load all records from the JSONL file. No lock needed.
 	* Handles crash recovery: partial last line skipped, temp file recovery.
 	*/
 	async load() {
-		await mkdir$1(path.dirname(this.filePath), { recursive: true });
+		await mkdir(path.dirname(this.filePath), { recursive: true });
 		if (!existsSync(this.filePath) && existsSync(this.tempPath)) {
 			logger.debug("[JsonlStore] Recovering from temp file");
 			await rename(this.tempPath, this.filePath);
@@ -457,7 +455,7 @@ var JsonlStore = class {
 		this.docs = /* @__PURE__ */ new Map();
 		let raw = "";
 		try {
-			raw = await readFile$1(this.filePath, "utf-8");
+			raw = await readFile(this.filePath, "utf-8");
 		} catch (err) {
 			if (err.code === "ENOENT") return this.docs;
 			throw err;
@@ -561,7 +559,7 @@ var JsonlStore = class {
 	*/
 	async compact() {
 		const lines = Array.from(this.docs.values()).map((doc) => {
-			const { _id, $$deleted, ...rest } = doc;
+			const { _id, $$deleted: _$$deleted, ...rest } = doc;
 			return JSON.stringify({
 				_id,
 				...rest
@@ -570,14 +568,14 @@ var JsonlStore = class {
 		const content = lines ? lines + "\n" : "";
 		try {
 			await this.withLock(async () => {
-				await writeFile$1(this.tempPath, content);
+				await writeFile(this.tempPath, content);
 				const fd = openSync(this.tempPath, "r");
 				fsyncSync(fd);
 				closeSync(fd);
 				await rename(this.tempPath, this.filePath);
 			});
 		} catch {
-			await writeFile$1(this.filePath, content);
+			await writeFile(this.filePath, content);
 		}
 	}
 	async withLock(fn) {
@@ -714,8 +712,8 @@ pid-db/
 
 `;
 		try {
-			await mkdir$1(this.storeDir, { recursive: true });
-			await writeFile$1(gitignorePath, gitignoreContent, { flag: "wx" });
+			await mkdir(this.storeDir, { recursive: true });
+			await writeFile(gitignorePath, gitignoreContent, { flag: "wx" });
 			logger.debug(`[pidStore] Created .gitignore in ${this.storeDir}`);
 		} catch (error) {
 			if (error.code !== "EEXIST") logger.warn(`[pidStore] Failed to create .gitignore:`, error);
@@ -837,7 +835,7 @@ async function sendMessage(context, message, { waitForReady = true } = {}) {
 */
 async function initializeLogPaths(pidStore, pid) {
 	const logDir = pidStore.getLogDir();
-	await mkdir$1(logDir, { recursive: true });
+	await mkdir(logDir, { recursive: true });
 	return {
 		logPath: logDir,
 		rawLogPath: path.resolve(path.dirname(logDir), `${pid}.raw.log`),
@@ -862,8 +860,8 @@ function setupDebugLogging(debuggingLogsPath) {
 */
 async function saveLogFile(logPath, content) {
 	if (!logPath) return;
-	await mkdir$1(path.dirname(logPath), { recursive: true }).catch(() => null);
-	await writeFile$1(logPath, content).catch(() => null);
+	await mkdir(path.dirname(logPath), { recursive: true }).catch(() => null);
+	await writeFile(logPath, content).catch(() => null);
 	logger.info(`Full logs saved to ${logPath}`);
 }
 /**
@@ -876,8 +874,8 @@ async function saveDeprecatedLogFile(logFile, content, verbose) {
 	if (!logFile) return;
 	if (verbose) logger.info(`Writing rendered logs to ${logFile}`);
 	const logFilePath = path.resolve(logFile);
-	await mkdir$1(path.dirname(logFilePath), { recursive: true }).catch(() => null);
-	await writeFile$1(logFilePath, content);
+	await mkdir(path.dirname(logFilePath), { recursive: true }).catch(() => null);
+	await writeFile(logFilePath, content);
 }
 
 //#endregion
@@ -906,7 +904,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.60.6";
+var version = "1.61.0";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -1071,7 +1069,7 @@ function isCommandNotFoundError(e) {
 * ```
 */
 function spawnAgent(options) {
-	const { cli, cliConf, cliArgs, verbose, install, ptyOptions } = options;
+	const { cli, cliConf, cliArgs, verbose: _verbose, install, ptyOptions } = options;
 	const spawn = () => {
 		let [bin, ...args] = [...parseCommandString(cliConf?.binary || cli), ...cliArgs];
 		logger.debug(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
@@ -1079,7 +1077,7 @@ function spawnAgent(options) {
 		logger.info(`[${cli}-yes] Spawned ${bin} with PID ${spawned.pid} (agent-yes v${version})`);
 		return spawned;
 	};
-	return tryCatch((error, attempts, spawn, ...args) => {
+	return tryCatch((error, _attempts, spawn, ...args) => {
 		logger.error(`Fatal: Failed to start ${cli}.`);
 		const isNotFound = isCommandNotFoundError(error);
 		if (cliConf?.install && isNotFound) {
@@ -1293,7 +1291,7 @@ async function loadInstallEnv() {
 	if (_installEnv) return _installEnv;
 	const envPath = path$1.join(installDir, ".env");
 	try {
-		_installEnv = parseEnvContent(await readFile(envPath, "utf-8"));
+		_installEnv = parseEnvContent(await readFile$1(envPath, "utf-8"));
 	} catch {
 		_installEnv = {};
 	}
@@ -1332,7 +1330,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-XmUcKFde.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-DcxG25Gv.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1362,7 +1360,7 @@ const CLIS_CONFIG = config.clis;
 * });
 * ```
 */
-async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, exitOnIdle, logFile, removeControlCharactersFromStdout = false, verbose = false, queue = false, install = false, resume = false, useSkills = false, useStdinAppend = false, autoYes = true }) {
+async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, exitOnIdle, logFile, removeControlCharactersFromStdout = false, verbose = false, queue = false, install = false, resume = false, useSkills = false, useStdinAppend: _useStdinAppend = false, autoYes = true }) {
 	if (!cli) throw new Error(`cli is required`);
 	const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(" ")}`);
 	const workingDir = cwd ?? process.cwd();
@@ -1411,7 +1409,7 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 			let currentDir = workingDir;
 			const searchLimit = gitRoot || path.parse(currentDir).root;
 			while (true) {
-				const md = await readFile$1(path.resolve(currentDir, "SKILL.md"), "utf8").catch(() => null);
+				const md = await readFile(path.resolve(currentDir, "SKILL.md"), "utf8").catch(() => null);
 				if (md) {
 					const headerMatch = md.match(/^[\s\S]*?(?=\n##\s)/);
 					const headerRaw = (headerMatch ? headerMatch[0] : md).trim();
@@ -1776,7 +1774,7 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 			process.stdin.on("close", endHandler);
 			process.stdin.on("error", errorHandler);
 		},
-		cancel(reason) {
+		cancel(_reason) {
 			process.stdin.pause();
 		}
 	});
@@ -1857,10 +1855,10 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 	}).forkTo(async function rawLogger(f) {
 		const rawLogPath = ctx.logPaths.rawLogPath;
 		if (!rawLogPath) return f.run();
-		return await mkdir$1(path.dirname(rawLogPath), { recursive: true }).then(() => {
+		return await mkdir(path.dirname(rawLogPath), { recursive: true }).then(() => {
 			logger.debug(`[${cli}-yes] raw logs streaming to ${rawLogPath}`);
 			return f.forEach(async (chars) => {
-				await writeFile$1(rawLogPath, chars, { flag: "a" }).catch(() => null);
+				await writeFile(rawLogPath, chars, { flag: "a" }).catch(() => null);
 			}).run();
 		}).catch(() => f.run());
 	}).by(function consoleResponder(e) {
@@ -1953,4 +1951,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, PidStore as c, config as i, removeControlCharacters as l, CLIS_CONFIG as n, name as o, agentYes as r, version as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS--w_SPLyp.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-C0l1NfFH.js.map

package/dist/{agent-yes.config-B-sre0vp.js → agent-yes.config-DcxG25Gv.js}

@@ -1,6 +1,6 @@
-import { t as logger } from "./logger-CY9ormLF.js";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { t as logger } from "./logger-CX77vJDA.js";
 import os from "node:os";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { parse } from "yaml";
 
@@ -331,5 +331,5 @@ function getDefaultConfig() {
 }
 
 //#endregion
-export { agent_yes_config_default as t };
-//# sourceMappingURL=agent-yes.config-B-sre0vp.js.map
+export { agent_yes_config_default as default };
+//# sourceMappingURL=agent-yes.config-DcxG25Gv.js.map

package/dist/cli.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS--w_SPLyp.js";
-import "./agent-yes.config-B-sre0vp.js";
-import { t as logger } from "./logger-CY9ormLF.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C0l1NfFH.js";
+import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
-import { existsSync, mkdirSync, unlinkSync } from "fs";
-import path from "path";
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { chmod, copyFile, rename } from "fs/promises";
+import { chmod, copyFile } from "fs/promises";
+import path from "path";
+import { existsSync, mkdirSync, unlinkSync } from "fs";
 
 //#region ts/parseCliArgs.ts
 /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS--w_SPLyp.js";
-import "./logger-CY9ormLF.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-C0l1NfFH.js";
+import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/dist/{logger-CY9ormLF.js → logger-CX77vJDA.js}

@@ -13,4 +13,4 @@ const logger = winston.createLogger({
 
 //#endregion
 export { logger as t };
-//# sourceMappingURL=logger-CY9ormLF.js.map
+//# sourceMappingURL=logger-CX77vJDA.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.60.6",
+  "version": "1.61.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -80,7 +80,8 @@
     "prepare": "husky",
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",
-    "test": "bun test --coverage"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@snomiao/bun-pty": "^0.3.4",
@@ -91,7 +92,7 @@
     "phpdie": "^1.7.0",
     "proper-lockfile": "^4.1.2",
     "sflow": "^1.27.0",
-    "terminal-render": "^1.5.0",
+    "terminal-render": "^1.5.1",
     "winston": "^3.19.0",
     "yaml": "^2.8.2",
     "yargs": "^18.0.0"
@@ -106,6 +107,7 @@
     "@types/proper-lockfile": "^4.1.4",
     "@types/yargs": "^17.0.35",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "@vitest/coverage-v8": "^4.1.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "node-pty": "^1.1.0",
@@ -116,7 +118,7 @@
     "semantic-release": "^25.0.2",
     "standard-version": "^9.5.0",
     "tsdown": "^0.20.3",
-    "vitest": "^4.0.17",
+    "vitest": "4.1.0",
     "zod": "^3.23.0"
   },
   "peerDependencies": {

package/ts/JsonlStore.spec.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { JsonlStore } from "./JsonlStore";
+import { rm, readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+
+const TEST_DIR = "/tmp/jsonlstore-test-" + process.pid;
+const TEST_FILE = path.join(TEST_DIR, "test.jsonl");
+
+describe("JsonlStore", () => {
+  let store: JsonlStore;
+
+  beforeEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+    store = new JsonlStore(TEST_FILE);
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("load", () => {
+    it("should return empty map for new file", async () => {
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should load existing JSONL data", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"2","name":"Bob"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice" });
+    });
+
+    it("should merge duplicate IDs (last wins)", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"1","name":"Alice Updated"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice Updated", age: 30 });
+    });
+
+    it("should handle $$deleted tombstones", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"1","$$deleted":true}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should skip lines without _id", async () => {
+      await writeFile(TEST_FILE, '{"name":"no id"}\n{"_id":"1","name":"valid"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+    });
+
+    it("should skip corrupt lines gracefully", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"ok"}\n{corrupt json\n{"_id":"2","name":"also ok"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+    });
+
+    it("should recover from temp file when main file missing", async () => {
+      const tempFile = TEST_FILE + "~";
+      await writeFile(tempFile, '{"_id":"1","name":"recovered"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")!.name).toBe("recovered");
+    });
+  });
+
+  describe("getAll / getById / find / findOne", () => {
+    beforeEach(async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"2","name":"Bob","age":25}\n{"_id":"3","name":"Charlie","age":35}\n',
+      );
+      await store.load();
+    });
+
+    it("getAll returns all documents", () => {
+      expect(store.getAll()).toHaveLength(3);
+    });
+
+    it("getById returns correct doc", () => {
+      expect(store.getById("2")).toEqual({ _id: "2", name: "Bob", age: 25 });
+    });
+
+    it("getById returns undefined for missing id", () => {
+      expect(store.getById("999")).toBeUndefined();
+    });
+
+    it("find returns matching docs", () => {
+      const result = store.find((d) => d.age > 28);
+      expect(result).toHaveLength(2);
+    });
+
+    it("findOne returns first match", () => {
+      const result = store.findOne((d) => d.age > 28);
+      expect(result).toBeDefined();
+      expect(result!.age).toBeGreaterThan(28);
+    });
+
+    it("findOne returns undefined when no match", () => {
+      expect(store.findOne((d) => d.age > 100)).toBeUndefined();
+    });
+  });
+
+  describe("append", () => {
+    it("should append and return doc with generated id", async () => {
+      await store.load();
+      const doc = await store.append({ name: "test" } as any);
+      expect(doc._id).toBeDefined();
+      expect(doc.name).toBe("test");
+      expect(store.getAll()).toHaveLength(1);
+    });
+
+    it("should append with provided _id", async () => {
+      await store.load();
+      const doc = await store.append({ _id: "custom-id", name: "test" } as any);
+      expect(doc._id).toBe("custom-id");
+    });
+
+    it("should merge with existing doc of same _id", async () => {
+      await store.load();
+      await store.append({ _id: "x", name: "first", value: 1 } as any);
+      await store.append({ _id: "x", name: "second" } as any);
+      const doc = store.getById("x")!;
+      expect(doc.name).toBe("second");
+      expect(doc.value).toBe(1);
+    });
+  });
+
+  describe("updateById", () => {
+    it("should update existing doc", async () => {
+      await store.load();
+      await store.append({ _id: "u1", name: "original", status: "active" } as any);
+      await store.updateById("u1", { status: "done" });
+      expect(store.getById("u1")!.status).toBe("done");
+      expect(store.getById("u1")!.name).toBe("original");
+    });
+
+    it("should no-op for non-existent id", async () => {
+      await store.load();
+      await store.updateById("nonexistent", { status: "done" });
+      expect(store.getAll()).toHaveLength(0);
+    });
+  });
+
+  describe("deleteById", () => {
+    it("should remove doc from memory and write tombstone", async () => {
+      await store.load();
+      await store.append({ _id: "d1", name: "to delete" } as any);
+      expect(store.getAll()).toHaveLength(1);
+
+      await store.deleteById("d1");
+      expect(store.getAll()).toHaveLength(0);
+      expect(store.getById("d1")).toBeUndefined();
+
+      // Tombstone should be written to file
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toContain('"$$deleted":true');
+    });
+  });
+
+  describe("compact", () => {
+    it("should deduplicate entries", async () => {
+      await store.load();
+      await store.append({ _id: "c1", name: "v1" } as any);
+      await store.updateById("c1", { name: "v2" });
+      await store.updateById("c1", { name: "v3" });
+
+      // Before compact: 3 lines
+      const before = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(before).toHaveLength(3);
+
+      await store.compact();
+
+      // After compact: 1 line
+      const after = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(after).toHaveLength(1);
+      expect(JSON.parse(after[0]!).name).toBe("v3");
+    });
+
+    it("should handle empty store", async () => {
+      await store.load();
+      await store.compact();
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toBe("");
+    });
+  });
+});

package/ts/JsonlStore.ts

@@ -1,8 +1,8 @@
-import { appendFile, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { fsyncSync, openSync, closeSync } from "fs";
 import path from "path";
-import { lock, unlock } from "proper-lockfile";
+import { lock } from "proper-lockfile";
 import { logger } from "./logger.ts";
 
 export interface JsonlDoc {
@@ -24,14 +24,11 @@ export interface JsonlDoc {
 export class JsonlStore<T extends Record<string, any> = Record<string, any>> {
   private filePath: string;
   private tempPath: string;
-  private lockPath: string;
   private docs = new Map<string, T & JsonlDoc>();
 
   constructor(filePath: string) {
     this.filePath = filePath;
     this.tempPath = filePath + "~";
-    // Lock on the directory (proper-lockfile needs an existing path)
-    this.lockPath = path.dirname(filePath);
   }
 
   /**
@@ -169,7 +166,7 @@ export class JsonlStore<T extends Record<string, any> = Record<string, any>> {
   async compact(): Promise<void> {
     const lines = Array.from(this.docs.values())
       .map((doc) => {
-        const { _id, $$deleted, ...rest } = doc;
+        const { _id, $$deleted: _$$deleted, ...rest } = doc;
         return JSON.stringify({ _id, ...rest });
       })
       .join("\n");

package/ts/cli.ts

@@ -1,9 +1,6 @@
 #!/usr/bin/env bun
 import { argv } from "process";
 import { spawn } from "child_process";
-import { existsSync } from "fs";
-import path from "path";
-import cliYesConfig from "../agent-yes.config.ts";
 import { parseCliArgs } from "./parseCliArgs.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { logger } from "./logger.ts";

package/ts/configLoader.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { loadCascadingConfig, getConfigPaths, ensureSchemaInConfigFiles } from "./configLoader.ts";
 import { mkdir, writeFile, readFile, rm } from "node:fs/promises";
 import path from "node:path";
@@ -187,4 +187,68 @@ configDir: /test
     expect(result.skipped).toContain(configPath);
     expect(result.modified).not.toContain(configPath);
   });
+
+  it("should handle invalid JSON config gracefully", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.json");
+    await writeFile(configPath, "not valid json {{{");
+
+    const config = await loadCascadingConfig({ projectDir: testDir, homeDir: testDir });
+    // Should not throw, returns empty
+    expect(config).toEqual({});
+  });
+
+  it("should handle empty YAML config returning null", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.yaml");
+    await writeFile(configPath, "");
+
+    const config = await loadCascadingConfig({ projectDir: testDir, homeDir: testDir });
+    expect(config).toEqual({});
+  });
+
+  it("should add schema to YAML with leading comments", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.yaml");
+    await writeFile(
+      configPath,
+      `# My config comment
+# Another comment
+configDir: /test
+`,
+    );
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: testDir, homeDir: testDir });
+    expect(result.modified).toContain(configPath);
+    const content = await readFile(configPath, "utf-8");
+    expect(content).toContain("yaml-language-server:");
+  });
+
+  it("should handle ensureSchema when no config files exist", async () => {
+    const emptyDir = path.join(testDir, "empty");
+    await mkdir(emptyDir, { recursive: true });
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: emptyDir, homeDir: emptyDir });
+    expect(result.modified).toHaveLength(0);
+    expect(result.skipped).toHaveLength(0);
+  });
+
+  it("should handle addSchemaReference for JSON that already has schema", async () => {
+    const configPath = path.join(testDir, ".agent-yes.config.json");
+    const content = JSON.stringify({ $schema: "existing", configDir: "/test" }, null, 2);
+    await writeFile(configPath, content);
+
+    const result = await ensureSchemaInConfigFiles({ projectDir: testDir, homeDir: testDir });
+    expect(result.skipped).toContain(configPath);
+  });
+
+  it("should use defaults for getConfigPaths without options", () => {
+    const paths = getConfigPaths();
+    expect(paths.length).toBeGreaterThan(0);
+    expect(paths.some((p) => p.includes(".agent-yes.config.json"))).toBe(true);
+  });
+
+  it("should use defaults for loadCascadingConfig without options", async () => {
+    // This tests the default path (process.cwd() and os.homedir())
+    const config = await loadCascadingConfig();
+    // Should not throw, may or may not find configs
+    expect(config).toBeDefined();
+  });
 });

package/ts/defineConfig.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { defineCliYesConfig } from "./defineConfig";
+
+describe("defineCliYesConfig", () => {
+  it("should return a plain config object", async () => {
+    const cfg = await defineCliYesConfig({ clis: {} });
+    expect(cfg).toEqual({ clis: {} });
+  });
+
+  it("should accept a function that receives the default config", async () => {
+    const cfg = await defineCliYesConfig((original) => {
+      expect(original).toEqual({ clis: {} });
+      return { ...original, clis: { claude: { bin: "claude" } } };
+    });
+    expect(cfg.clis).toHaveProperty("claude");
+  });
+
+  it("should accept an async function", async () => {
+    const cfg = await defineCliYesConfig(async () => {
+      return { clis: { test: { bin: "test-cli" } } };
+    });
+    expect(cfg.clis.test).toEqual({ bin: "test-cli" });
+  });
+
+  it("should accept a promise", async () => {
+    const cfg = await defineCliYesConfig(Promise.resolve({ clis: {} }));
+    expect(cfg).toEqual({ clis: {} });
+  });
+});

package/ts/idleWaiter.spec.ts

@@ -52,4 +52,20 @@ describe("IdleWaiter", () => {
     const result = waiter.ping().ping().ping();
     expect(result).toBe(waiter);
   });
+
+  it("should wait until idle period has passed", async () => {
+    const waiter = new IdleWaiter();
+    waiter.checkInterval = 10;
+
+    // Ping right now so it's not idle
+    waiter.ping();
+
+    const start = Date.now();
+    // Wait for 50ms idle period — the wait loop should actually iterate
+    await waiter.wait(50);
+    const elapsed = Date.now() - start;
+
+    // Should have waited at least ~50ms
+    expect(elapsed).toBeGreaterThanOrEqual(40);
+  });
 });

package/ts/index.ts

@@ -1,10 +1,10 @@
 import { execaCommandSync, parseCommandString } from "execa";
-import { fromReadable, fromWritable } from "from-node-stream";
+import { fromWritable } from "from-node-stream";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
-import { TerminalRenderStream, TerminalTextRender } from "terminal-render";
+import { TerminalRenderStream } from "terminal-render";
 import {
   extractSessionId,
   getSessionForCwd,
@@ -14,7 +14,7 @@ import pty, { ptyPackage } from "./pty.ts";
 import { removeControlCharacters } from "./removeControlCharacters.ts";
 import { acquireLock, releaseLock, shouldUseLock } from "./runningLock.ts";
 import { logger } from "./logger.ts";
-import { createFifoStream } from "./beta/fifo.ts";
+// import { createFifoStream } from "./beta/fifo.ts";
 import { PidStore } from "./pidStore.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { sendEnter, sendMessage } from "./core/messaging.ts";
@@ -26,10 +26,10 @@ import {
 } from "./core/logging.ts";
 import { spawnAgent } from "./core/spawner.ts";
 import { AgentContext } from "./core/context.ts";
-import { createAutoResponseHandler } from "./core/responders.ts";
+// import { createAutoResponseHandler } from "./core/responders.ts";
 import { createTerminatorStream } from "./core/streamHelpers.ts";
 import { globalAgentRegistry } from "./agentRegistry.ts";
-import { ReadyManager } from "./ReadyManager.ts";
+// import { ReadyManager } from "./ReadyManager.ts";
 import { notifyWebhook } from "./webhookNotifier.ts";
 
 export { removeControlCharacters };
@@ -119,7 +119,7 @@ export default async function agentYes({
   install = false,
   resume = false,
   useSkills = false,
-  useStdinAppend = false,
+  useStdinAppend: _useStdinAppend = false,
   autoYes = true,
 }: {
   cli: SUPPORTED_CLIS;
@@ -730,7 +730,7 @@ export default async function agentYes({
       process.stdin.on("close", endHandler);
       process.stdin.on("error", errorHandler);
     },
-    cancel(reason) {
+    cancel(_reason) {
       process.stdin.pause();
     },
   });
@@ -802,6 +802,7 @@ export default async function agentYes({
               // Only check for /auto if line is short enough
               if (line.length <= 20) {
                 const cleanLine = line
+                  // oxlint-disable-next-line no-control-regex
                   .replace(/[\x00-\x1f]|\x1b\[[0-9;]*[A-Za-z]|\[[A-Z]/g, "")
                   .trim();
                 if (cleanLine === "/auto") {

package/ts/parseCliArgs.ts

@@ -2,7 +2,6 @@ import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
-import pkg from "../package.json" with { type: "json" };
 
 // const pkg = await JSON.parse(await readFile(path.resolve((import.meta.dir) + "/../package.json"), 'utf8'))
 /**

package/ts/pidStore.spec.ts

@@ -115,6 +115,20 @@ describe("PidStore", () => {
       expect(rec?.exitReason).toBe("crash");
       expect(rec?.exitCode).toBe(1);
     });
+
+    it("should no-op when updating non-existent pid", async () => {
+      await store.updateStatus(999888, "exited");
+      // Should not throw and records should be unchanged
+      expect(store.getAllRecords()).toHaveLength(0);
+    });
+
+    it("should update status without extra params", async () => {
+      await store.registerProcess({ pid: 333, cli: "test", args: [], cwd: "/tmp" });
+      await store.updateStatus(333, "idle");
+      const rec = store.getAllRecords().find((r) => r.pid === 333);
+      expect(rec?.status).toBe("idle");
+      expect(rec?.exitReason).toBe("");
+    });
   });
 
   describe("getAllRecords", () => {

package/ts/rustBinary.ts

@@ -2,8 +2,8 @@
  * Rust binary helper - finds or downloads the appropriate prebuilt binary
  */
 
-import { existsSync, mkdirSync, unlinkSync, renameSync, copyFileSync } from "fs";
-import { chmod, unlink, rename, copyFile } from "fs/promises";
+import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { chmod, copyFile } from "fs/promises";
 import path from "path";
 
 // Platform/arch to binary name mapping
@@ -60,7 +60,7 @@ export function getBinDir(): string {
  */
 export function findRustBinary(verbose = false): string | undefined {
   const binaryName = getBinaryName();
-  const baseName = binaryName.replace(/\.exe$/, "");
+  const _baseName = binaryName.replace(/\.exe$/, "");
 
   const searchPaths = [
     // 1. Check in npm package bin directory

package/ts/session-integration.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test";
+import { describe, expect, it } from "vitest";
 import { extractSessionId, extractSessionIdFromSessionMeta } from "./resume/codexSessionManager";
 
 describe("Session Extraction Test", () => {

package/ts/versionChecker.spec.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { compareVersions, fetchLatestVersion, displayVersion } from "./versionChecker";
+
+describe("versionChecker", () => {
+  describe("compareVersions", () => {
+    it("should return 0 for equal versions", () => {
+      expect(compareVersions("1.0.0", "1.0.0")).toBe(0);
+      expect(compareVersions("2.3.4", "2.3.4")).toBe(0);
+    });
+
+    it("should return 1 when v1 > v2", () => {
+      expect(compareVersions("2.0.0", "1.0.0")).toBe(1);
+      expect(compareVersions("1.1.0", "1.0.0")).toBe(1);
+      expect(compareVersions("1.0.1", "1.0.0")).toBe(1);
+    });
+
+    it("should return -1 when v1 < v2", () => {
+      expect(compareVersions("1.0.0", "2.0.0")).toBe(-1);
+      expect(compareVersions("1.0.0", "1.1.0")).toBe(-1);
+      expect(compareVersions("1.0.0", "1.0.1")).toBe(-1);
+    });
+
+    it("should handle versions with different segment counts", () => {
+      expect(compareVersions("1.0", "1.0.0")).toBe(0);
+      expect(compareVersions("1.0.0", "1.0")).toBe(0);
+      expect(compareVersions("1.0.1", "1.0")).toBe(1);
+      expect(compareVersions("1.0", "1.0.1")).toBe(-1);
+    });
+  });
+
+  describe("fetchLatestVersion", () => {
+    beforeEach(() => {
+      vi.stubGlobal("fetch", vi.fn());
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should return version from npm registry", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "1.2.3" }),
+      } as Response);
+
+      const version = await fetchLatestVersion();
+      expect(version).toBe("1.2.3");
+    });
+
+    it("should return null on non-ok response", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: false,
+      } as Response);
+
+      const version = await fetchLatestVersion();
+      expect(version).toBeNull();
+    });
+
+    it("should return null on network error", async () => {
+      vi.mocked(fetch).mockRejectedValue(new Error("network error"));
+
+      const version = await fetchLatestVersion();
+      expect(version).toBeNull();
+    });
+  });
+
+  describe("displayVersion", () => {
+    beforeEach(() => {
+      vi.stubGlobal("fetch", vi.fn());
+      vi.spyOn(console, "log").mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should log update available when behind", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "999.0.0" }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("update available"));
+    });
+
+    it("should log latest when versions match", async () => {
+      const pkg = await import("../package.json");
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: pkg.default.version }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("latest"));
+    });
+
+    it("should log latest published when ahead", async () => {
+      vi.mocked(fetch).mockResolvedValue({
+        ok: true,
+        json: async () => ({ version: "0.0.1" }),
+      } as Response);
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("latest published"));
+    });
+
+    it("should handle fetch failure gracefully", async () => {
+      vi.mocked(fetch).mockRejectedValue(new Error("fail"));
+
+      await displayVersion();
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining("unable to check"));
+    });
+  });
+});

package/dist/agent-yes.config-XmUcKFde.js

@@ -1,4 +0,0 @@
-import { t as agent_yes_config_default } from "./agent-yes.config-B-sre0vp.js";
-import "./logger-CY9ormLF.js";
-
-export { agent_yes_config_default as default };