agent-yes 1.265.3 → 1.265.4

package/dist/{SUPPORTED_CLIS-X3jH37iY.js → SUPPORTED_CLIS-C3tcRetU.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-ZKWh7obB.js";
+import { t as CLIS_CONFIG } from "./ts-nuUnrVcf.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-X3jH37iY.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-C3tcRetU.js.map

package/dist/{SUPPORTED_CLIS-DnYyo_km.js → SUPPORTED_CLIS-CY3SaV0D.js}

@@ -1,11 +1,11 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C6RmYXss.js";
-import "./ts-ZKWh7obB.js";
+import "./versionChecker-CMOLbEEi.js";
+import "./ts-nuUnrVcf.js";
 import "./todoAutomation-BQRW614S.js";
 import "./JsonlStore-CPGIR0Wy.js";
 import "./globalPidIndex-Dq4KY2IV.js";
 import "./pidStore-DJqSZPJi.js";
 import "./messageLog-BYFwioFY.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-X3jH37iY.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C3tcRetU.js";
 
 export { SUPPORTED_CLIS };

package/dist/{agentShare-D8Qx06xK.js → agentShare-g6N1A6A_.js}

@@ -3,9 +3,9 @@ import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
 import "./e2e-CUMZC53I.js";
 import "./configShared-DtHMBCl7.js";
-import { R as resolveOne } from "./subcommands-Cbhtldub.js";
+import { R as resolveOne } from "./subcommands-CQPnT5qu.js";
 import "./webrtcLink-CS4D-3G1.js";
-import "./remotes-Cn-wszbK.js";
+import "./remotes-iIvqiFWK.js";
 import { a as startShare } from "./share-B-e_9WBx.js";
 
 //#region ts/agentShare.ts
@@ -229,4 +229,4 @@ function transformEvent(rawEvent, agentId, forwarded) {
 
 //#endregion
 export { createScopedShare, listShares, revokeAllShares, revokeShare };
-//# sourceMappingURL=agentShare-D8Qx06xK.js.map
+//# sourceMappingURL=agentShare-g6N1A6A_.js.map

package/dist/{callback-CByNygd_.js → callback-L4k-v2GG.js}

@@ -3,10 +3,10 @@ import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
 import "./e2e-CUMZC53I.js";
 import "./configShared-DtHMBCl7.js";
-import "./subcommands-Cbhtldub.js";
+import "./subcommands-CQPnT5qu.js";
 import "./webrtcLink-CS4D-3G1.js";
-import "./remotes-Cn-wszbK.js";
+import "./remotes-iIvqiFWK.js";
 import "./callbackCore-Cg3Ye0ZS.js";
-import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-C5A5zDzb.js";
+import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-z-w0ND5z.js";
 
 export { cmdCallback };

package/dist/{callback-C5A5zDzb.js → callback-z-w0ND5z.js}

@@ -1,5 +1,5 @@
 import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
-import { R as resolveOne } from "./subcommands-Cbhtldub.js";
+import { R as resolveOne } from "./subcommands-CQPnT5qu.js";
 import { a as mintCapability, o as parseExpires } from "./callbackCore-Cg3Ye0ZS.js";
 import { randomBytes } from "node:crypto";
 import { chmodSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -72,7 +72,7 @@ async function resolveBase(flag) {
 	if (flag) return flag;
 	if (process.env.AGENT_YES_CALLBACK_BASE) return process.env.AGENT_YES_CALLBACK_BASE;
 	try {
-		const { resolveLocalServeUrl } = await import("./serve-bXCIgnq_.js");
+		const { resolveLocalServeUrl } = await import("./serve-CpGJD2Kt.js");
 		const url = await resolveLocalServeUrl();
 		if (url) return url;
 	} catch {}
@@ -187,4 +187,4 @@ async function cmdCallback(rest) {
 
 //#endregion
 export { loadOrCreateCallbackSecret as i, isCallbackRevoked as n, loadCallbackSecretReadOnly as r, cmdCallback as t };
-//# sourceMappingURL=callback-C5A5zDzb.js.map
+//# sourceMappingURL=callback-z-w0ND5z.js.map

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-C6RmYXss.js";
-import { r as getRustBinary } from "./rustBinary-CkTiZVJ4.js";
+import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-CMOLbEEi.js";
+import { r as getRustBinary } from "./rustBinary-DSVRhDzO.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
@@ -295,7 +295,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-CnARtyVR.js");
+	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-Cgt2-kjg.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		await cmdHelp(managerCommands);
 		process.exit(0);
@@ -309,7 +309,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 		process.exit(code ?? 0);
 	}
 	{
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DnYyo_km.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CY3SaV0D.js");
 		if (isUnknownManagerToken(rawArg, managerCommands, SUPPORTED_CLIS)) {
 			process.stderr.write(`ay: unknown subcommand or CLI '${rawArg}'.\n    See 'ay help' for subcommands. To run an agent, name a CLI:\n    'ay <cli> …' (e.g. 'ay claude …') or 'ay --cli <cli> …'.\n`);
 			process.exit(1);
@@ -328,16 +328,16 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-wWMvGWeY.js");
+	const { startTray } = await import("./tray-Cjm3a8JH.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-wWMvGWeY.js");
+	const { ensureTray } = await import("./tray-Cjm3a8JH.js");
 	ensureTray();
 }
 if (!config.showVersion && !config.appendPrompt && !config.tray) {
-	const { waitForSpawnCapacity } = await import("./spawnGate-DqKBA07k.js");
+	const { waitForSpawnCapacity } = await import("./spawnGate-S6EoFdzX.js");
 	await waitForSpawnCapacity({
 		onWait: (reason, waitedMs) => {
 			if (config.verbose || waitedMs === 0) console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
@@ -360,7 +360,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DnYyo_km.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CY3SaV0D.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/hist-CoXBBjJt.js

@@ -0,0 +1,442 @@
+import yargs from "yargs";
+import { open, readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+
+//#region ts/histStore.ts
+/**
+* `ay hist` — read the tail of *coding-agent conversation transcripts* that
+* already exist on this machine (Claude Code, Codex), newest-last.
+*
+* This is deliberately NOT `ay tail`. `ay tail` follows the live PTY log of an
+* agent process agent-yes spawned; `ay hist` reads the durable JSONL transcript
+* the CLI itself writes, including sessions from before agent-yes was involved
+* and sessions whose process already exited.
+*
+* Design notes (the two that actually matter):
+*
+* 1. **Read backwards.** Transcript lines are whole JSON records and routinely
+*    reach 1.3MB (tool outputs, base64 images). Reading a file forward — or
+*    `readFile().split("\n")` — costs megabytes to show six records. We seek to
+*    EOF and walk back in chunks, stopping as soon as the caller has enough, so
+*    cost is proportional to what's displayed, not to session length.
+*
+* 2. **No index.** These files are append-only, so a sidecar index storing
+*    `indexed_up_to_bytes` would let a future `ay hist search` re-scan only the
+*    tail delta. Tailing needs none of that, and the 90% case is tailing — so
+*    v1 ships with zero index, zero daemon, zero cache invalidation.
+*/
+const NEWLINE = 10;
+/**
+* Claude Code names each project directory after its cwd with every
+* non-alphanumeric byte replaced by `-`:
+* `/code/snomiao/cv.snomiao.com` → `-code-snomiao-cv-snomiao-com`.
+*
+* Encoding the cwd and comparing is exact and costs no file reads — decoding
+* the slug back to a path is not possible, since `-` is ambiguous.
+*/
+function encodeProjectSlug(cwd) {
+	return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function claudeProjectsDir(home = homedir()) {
+	return path.join(home, ".claude", "projects");
+}
+function codexSessionsDir(home = homedir()) {
+	return path.join(home, ".codex", "sessions");
+}
+async function listJsonlDeep(dir, out = [], depth = 0) {
+	if (depth > 4) return out;
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return out;
+	}
+	for (const e of entries) {
+		const full = path.join(dir, e.name);
+		if (e.isDirectory()) await listJsonlDeep(full, out, depth + 1);
+		else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(full);
+	}
+	return out;
+}
+/**
+* Locate transcripts, newest first. Only stats files — never opens them — so
+* this stays cheap even with thousands of sessions on disk.
+*/
+async function discoverTranscripts(opts = {}) {
+	const home = opts.home ?? homedir();
+	const sources = opts.sources ?? ["claude", "codex"];
+	const found = [];
+	if (sources.includes("claude")) {
+		const root = claudeProjectsDir(home);
+		const wanted = opts.cwd ? encodeProjectSlug(opts.cwd) : null;
+		let projects = [];
+		try {
+			projects = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+		} catch {
+			projects = [];
+		}
+		for (const slug of projects) {
+			if (wanted && slug !== wanted) continue;
+			for (const file of await listJsonlDeep(path.join(root, slug))) {
+				const st = await stat(file).catch(() => null);
+				if (!st?.isFile() || st.size === 0) continue;
+				found.push({
+					path: file,
+					source: "claude",
+					sessionId: path.basename(file, ".jsonl"),
+					mtimeMs: st.mtimeMs,
+					size: st.size
+				});
+			}
+		}
+	}
+	if (sources.includes("codex")) for (const file of await listJsonlDeep(codexSessionsDir(home))) {
+		if (!path.basename(file).startsWith("rollout-")) continue;
+		const st = await stat(file).catch(() => null);
+		if (!st?.isFile() || st.size === 0) continue;
+		found.push({
+			path: file,
+			source: "codex",
+			sessionId: path.basename(file, ".jsonl"),
+			mtimeMs: st.mtimeMs,
+			size: st.size
+		});
+	}
+	found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+	if (opts.cwd && sources.includes("codex")) {
+		const kept = [];
+		for (const f of found) {
+			if (f.source !== "codex") {
+				kept.push(f);
+				continue;
+			}
+			const cwd = await readCodexCwd(f.path);
+			if (cwd === opts.cwd) kept.push({
+				...f,
+				cwd
+			});
+		}
+		return kept;
+	}
+	return found;
+}
+/** Read the leading `session_meta` record of a Codex rollout to learn its cwd. */
+async function readCodexCwd(file) {
+	let fh;
+	try {
+		fh = await open(file, "r");
+		const buf = Buffer.alloc(64 * 1024);
+		const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+		const nl = buf.indexOf(NEWLINE);
+		const end = nl === -1 ? bytesRead : nl;
+		return JSON.parse(buf.subarray(0, end).toString("utf8")).payload?.cwd;
+	} catch {
+		return;
+	} finally {
+		await fh?.close();
+	}
+}
+/**
+* Yield whole lines from EOF toward the start, newest first, as
+* `{ offset, text }`. Lazy: the generator only reads another chunk when the
+* consumer asks for another line, so `take(6)` reads ~one chunk regardless of
+* whether the file is 4KB or 400MB.
+*
+* A trailing partial line (a session being appended to right now) is dropped —
+* we stop at the last complete newline rather than hand back half a record.
+*/
+async function* readLinesBackward(file, opts = {}) {
+	const chunkSize = opts.chunkSize ?? 64 * 1024;
+	const maxRecordBytes = opts.maxRecordBytes ?? 16 * 1024 * 1024;
+	const fh = await open(file, "r");
+	try {
+		let pos = (await fh.stat()).size;
+		if (pos === 0) return;
+		let pending = Buffer.alloc(0);
+		let base = pos;
+		let first = true;
+		while (pos > 0) {
+			const len = Math.min(chunkSize, pos);
+			pos -= len;
+			const buf = Buffer.alloc(len);
+			await fh.read(buf, 0, len, pos);
+			const combined = pending.length ? Buffer.concat([buf, pending]) : buf;
+			base = pos;
+			let end = combined.length;
+			if (first) {
+				first = false;
+				const last = combined.lastIndexOf(NEWLINE);
+				end = last === -1 ? 0 : last;
+			}
+			while (end > 0) {
+				const nl = combined.lastIndexOf(NEWLINE, end - 1);
+				if (nl === -1) break;
+				const text = combined.subarray(nl + 1, end).toString("utf8");
+				if (text.trim()) yield {
+					offset: base + nl + 1,
+					text
+				};
+				end = nl;
+			}
+			pending = combined.subarray(0, end);
+			if (pending.length > maxRecordBytes) pending = Buffer.alloc(0);
+		}
+		const head = pending.toString("utf8");
+		if (head.trim()) yield {
+			offset: 0,
+			text: head
+		};
+	} finally {
+		await fh.close();
+	}
+}
+function claudeText(content, includeTools) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const raw of content) {
+		if (!raw || typeof raw !== "object") continue;
+		if (raw.type === "text" && typeof raw.text === "string") parts.push(raw.text);
+		else if (includeTools && raw.type === "thinking" && typeof raw.thinking === "string") parts.push(`(thinking) ${raw.thinking}`);
+		else if (includeTools && raw.type === "tool_use") parts.push(`[tool: ${raw.name ?? "?"}]`);
+		else if (includeTools && raw.type === "tool_result") parts.push(`[tool result]`);
+	}
+	return parts.join("\n").trim();
+}
+/**
+* Reduce one raw transcript line to a displayable turn, or null when the record
+* is not conversational (metadata, token counts, tool plumbing, …).
+*
+* Returning null for the great majority of records is the point: it is what
+* makes six records of *conversation* cost six records of output rather than
+* six records of JSON noise.
+*/
+function projectRecord(line, source, opts = {}) {
+	let rec;
+	try {
+		rec = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (!rec || typeof rec !== "object") return null;
+	if (source === "claude") {
+		if (rec.type !== "user" && rec.type !== "assistant") return null;
+		if (rec.isSidechain && !opts.includeSidechains) return null;
+		const role = rec.message?.role === "assistant" ? "assistant" : "user";
+		const text = claudeText(rec.message?.content, opts.includeTools ?? false);
+		if (!text) return null;
+		return {
+			ts: typeof rec.timestamp === "string" ? rec.timestamp : null,
+			role,
+			text
+		};
+	}
+	if (rec.type !== "event_msg") return null;
+	const kind = rec.payload?.type;
+	if (kind !== "user_message" && kind !== "agent_message") return null;
+	const text = typeof rec.payload?.message === "string" ? rec.payload.message.trim() : "";
+	if (!text) return null;
+	return {
+		ts: typeof rec.timestamp === "string" ? rec.timestamp : null,
+		role: kind === "user_message" ? "user" : "assistant",
+		text
+	};
+}
+function encodeCursor(r) {
+	return `${r.ts ?? ""}|${r.sessionId}|${r.offset}`;
+}
+/** Parse an encoded cursor; returns null for a bare timestamp or garbage. */
+function decodeCursor(raw) {
+	const parts = raw.split("|");
+	if (parts.length !== 3) return null;
+	const offset = Number(parts[2]);
+	if (!Number.isFinite(offset)) return null;
+	return {
+		ts: parts[0],
+		sessionId: parts[1],
+		offset
+	};
+}
+/** Total order over records: timestamp, then session, then byte offset. */
+function compareRecords(a, b) {
+	return (a.ts ?? "").localeCompare(b.ts ?? "") || a.sessionId.localeCompare(b.sessionId) || a.offset - b.offset;
+}
+/**
+* Newest `limit` conversational records of one transcript, oldest-first.
+*
+* Stops reading as soon as `limit` records are collected — the whole reason the
+* backward reader is a generator.
+*/
+async function tailTranscript(file, opts) {
+	const out = [];
+	for await (const { offset, text } of readLinesBackward(file.path, opts)) {
+		const projected = projectRecord(text, file.source, opts);
+		if (!projected) continue;
+		if (opts.role && projected.role !== opts.role) continue;
+		const record = {
+			...projected,
+			source: file.source,
+			sessionId: file.sessionId,
+			file: file.path,
+			offset
+		};
+		if (opts.cursor) {
+			if (compareRecords(record, opts.cursor) >= 0) continue;
+		} else if (opts.before && projected.ts && projected.ts >= opts.before) continue;
+		out.push(record);
+		if (out.length >= opts.limit) break;
+	}
+	return out.reverse();
+}
+/**
+* Merge the tails of the most recently touched transcripts into one
+* chronological page — "what have my agents been saying", across sessions.
+*/
+async function histPage(q) {
+	const considered = (await discoverTranscripts({
+		home: q.home,
+		cwd: q.cwd,
+		sources: q.sources
+	})).slice(0, q.maxFiles ?? 40);
+	const perFile = q.limit > 0 ? q.limit + 1 : Number.MAX_SAFE_INTEGER;
+	const cursor = q.cursor ?? (q.before ? decodeCursor(q.before) : null);
+	const merged = (await Promise.all(considered.map((f) => tailTranscript(f, {
+		...q,
+		limit: perFile,
+		cursor: cursor ?? void 0
+	})))).flat();
+	merged.sort(compareRecords);
+	const records = q.limit > 0 ? merged.slice(-q.limit) : merged;
+	const oldest = records[0];
+	return {
+		records,
+		cursor: merged.length > records.length && oldest ? encodeCursor(oldest) : null,
+		scanned: considered.length
+	};
+}
+
+//#endregion
+//#region ts/hist.ts
+/**
+* `ay hist` — CLI surface over {@link ./histStore.ts}.
+*
+* Reads past coding-agent conversations (Claude Code, Codex) that already exist
+* on disk. Distinct from `ay tail`, which follows the live PTY log of a process
+* agent-yes spawned; `ay hist` reads the CLI's own durable transcript, so it
+* still works for sessions that already exited.
+*/
+const DEFAULT_LIMIT = 6;
+const DEFAULT_SNIPPET = 600;
+const DIM = "\x1B[2m";
+const CYAN = "\x1B[36m";
+const GREEN = "\x1B[32m";
+const RESET = "\x1B[0m";
+function shortTime(ts) {
+	if (!ts) return "??:??";
+	const d = new Date(ts);
+	if (Number.isNaN(d.getTime())) return "??:??";
+	const now = Date.now();
+	const sameDay = new Date(now).toDateString() === d.toDateString();
+	const hhmm = d.toTimeString().slice(0, 5);
+	return sameDay ? hhmm : `${d.toISOString().slice(5, 10)} ${hhmm}`;
+}
+/**
+* Collapse a turn to `max` chars, noting how much was withheld.
+*
+* `color` gates the dim tint on that note. Everything else in the renderer
+* already honours it, but this note hardcoded the escapes — so `ay hist | cat`
+* stayed clean only until a turn was long enough to truncate, i.e. the common
+* case. Defaults true so a direct `snippet()` call keeps its old look.
+*/
+function snippet(text, max, color = true) {
+	const trimmed = text.trim();
+	if (max <= 0 || trimmed.length <= max) return trimmed;
+	const head = trimmed.slice(0, max);
+	const hiddenLines = trimmed.slice(max).split("\n").length;
+	const dim = color ? DIM : "";
+	const off = color ? RESET : "";
+	return `${head}… ${dim}(+${trimmed.length - max} chars, ${hiddenLines} more lines)${off}`;
+}
+function renderRecord(r, opts) {
+	const who = r.role === "user" ? "user" : r.source;
+	const tint = opts.color ? r.role === "user" ? CYAN : GREEN : "";
+	const dim = opts.color ? DIM : "";
+	const off = opts.color ? RESET : "";
+	const body = snippet(r.text, opts.max, opts.color).split("\n").map((l) => `  ${l}`).join("\n");
+	return `${`${tint}${who}${off} ${dim}${shortTime(r.ts)} ${r.sessionId.slice(0, 8)}${off}`}\n${body}\n`;
+}
+async function cmdHist(rest) {
+	const argv = await yargs(rest).usage("Usage: ay hist [options]\n\nTail past coding-agent conversations (Claude Code, Codex) from this machine.\nDefaults to sessions for the current directory, newest last.\n\nPagination: rerun with --before <cursor> using the cursor printed at the end.").option("n", {
+		type: "number",
+		default: DEFAULT_LIMIT,
+		description: `Number of turns (default ${DEFAULT_LIMIT}; 0 = no cap)`
+	}).option("all", {
+		type: "boolean",
+		default: false,
+		description: "All projects, not just the current directory"
+	}).option("cwd", {
+		type: "string",
+		description: "Scope to this directory instead of $PWD"
+	}).option("source", {
+		choices: ["claude", "codex"],
+		description: "Only one agent's transcripts"
+	}).option("role", {
+		choices: ["user", "assistant"],
+		description: "Only my prompts, or only the agent's replies"
+	}).option("before", {
+		type: "string",
+		description: "Cursor: only turns older than this ISO timestamp"
+	}).option("tools", {
+		type: "boolean",
+		default: false,
+		description: "Include tool calls/results and thinking as markers"
+	}).option("sidechains", {
+		type: "boolean",
+		default: false,
+		description: "Include Claude sub-agent turns"
+	}).option("full", {
+		type: "boolean",
+		default: false,
+		description: "Do not truncate turns"
+	}).option("json", {
+		type: "boolean",
+		default: false,
+		description: "JSONL for scripts/agents"
+	}).help().parse();
+	const cwd = argv.all ? void 0 : argv.cwd ?? process.cwd();
+	const page = await histPage({
+		cwd,
+		limit: Number(argv.n),
+		before: argv.before,
+		role: argv.role,
+		sources: argv.source ? [argv.source] : void 0,
+		includeTools: Boolean(argv.tools),
+		includeSidechains: Boolean(argv.sidechains)
+	});
+	if (argv.json) {
+		for (const r of page.records) process.stdout.write(JSON.stringify(r) + "\n");
+		return page.records.length ? 0 : 1;
+	}
+	if (!page.records.length) {
+		const where = cwd ? `for ${cwd}` : "on this machine";
+		process.stderr.write(`no agent conversation history ${where} (scanned ${page.scanned} transcript${page.scanned === 1 ? "" : "s"}).\n` + (cwd ? `try: ay hist --all\n` : ""));
+		return 1;
+	}
+	const color = process.stdout.isTTY === true;
+	const max = argv.full ? 0 : DEFAULT_SNIPPET;
+	for (const r of page.records) process.stdout.write(renderRecord(r, {
+		color,
+		max
+	}) + "\n");
+	if (page.cursor) {
+		const dim = color ? DIM : "";
+		const off = color ? RESET : "";
+		process.stderr.write(`${dim}older: ay hist --before ${page.cursor}${off}\n`);
+	}
+	return 0;
+}
+
+//#endregion
+export { cmdHist };
+//# sourceMappingURL=hist-CoXBBjJt.js.map

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C6RmYXss.js";
-import { a as hasTodoStore, i as answerAsk, l as AgentContext, n as agentYes, o as listAsks, r as config, s as listAsksForProject, t as CLIS_CONFIG } from "./ts-ZKWh7obB.js";
+import "./versionChecker-CMOLbEEi.js";
+import { a as hasTodoStore, i as answerAsk, l as AgentContext, n as agentYes, o as listAsks, r as config, s as listAsksForProject, t as CLIS_CONFIG } from "./ts-nuUnrVcf.js";
 import { _ as isKnownKind, a as renderTree, b as statesOf, c as monitorHint, d as openStore, f as DONE_STATE, g as initialState, h as canTransition, i as renderDigest, l as CycleError, m as ORPHANED_STATE, o as unblockedTasks, p as LIFECYCLES, r as openBlockers, s as describeBlock, t as reconcileTodos, u as TodoStore, v as nextStates, x as removeControlCharacters, y as requiredGate } from "./todoAutomation-BQRW614S.js";
 import "./JsonlStore-CPGIR0Wy.js";
 import "./globalPidIndex-Dq4KY2IV.js";

package/dist/{nodeRuntime-vhOBffJ3.js → nodeRuntime-CT0w6zsB.js}

@@ -53,4 +53,4 @@ async function ensureNodeRuntime(which = Bun.which) {
 
 //#endregion
 export { liveEnv as n, ensureNodeRuntime as t };
-//# sourceMappingURL=nodeRuntime-vhOBffJ3.js.map
+//# sourceMappingURL=nodeRuntime-CT0w6zsB.js.map

package/dist/{notifyDaemon-DuKvOHJJ.js → notifyDaemon-BL1tmxUK.js}

@@ -3,9 +3,9 @@ import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
 import "./e2e-CUMZC53I.js";
 import "./configShared-DtHMBCl7.js";
-import { E as listRecords, F as renderLogTailLines, Q as hostId, X as appendEvent, Z as gcInboxes, at as daemonLockOwnerPath, b as isPidAlive, et as listInboxParents, it as daemonLockDir, nt as readInbox, ot as notifyDir, rt as shouldStealLock, tt as liveWatchers, u as deriveLiveState } from "./subcommands-Cbhtldub.js";
+import { E as listRecords, F as renderLogTailLines, Q as hostId, X as appendEvent, Z as gcInboxes, at as daemonLockOwnerPath, b as isPidAlive, et as listInboxParents, it as daemonLockDir, nt as readInbox, ot as notifyDir, rt as shouldStealLock, tt as liveWatchers, u as deriveLiveState } from "./subcommands-CQPnT5qu.js";
 import "./webrtcLink-CS4D-3G1.js";
-import "./remotes-Cn-wszbK.js";
+import "./remotes-iIvqiFWK.js";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
 import { randomUUID } from "node:crypto";
 import { execFile, execFileSync } from "node:child_process";
@@ -836,4 +836,4 @@ async function ensureDaemon() {
 
 //#endregion
 export { daemonStatus, ensureDaemon, requestDaemonStop, runDaemon };
-//# sourceMappingURL=notifyDaemon-DuKvOHJJ.js.map
+//# sourceMappingURL=notifyDaemon-BL1tmxUK.js.map

package/dist/{openBrowser-D-aQjh3y.js → openBrowser-Cw8hg7ok.js}

@@ -68,4 +68,4 @@ async function offerOpenInBrowser(url, prompt = "Open in browser now? [Y/n] ") {
 
 //#endregion
 export { offerOpenInBrowser };
-//# sourceMappingURL=openBrowser-D-aQjh3y.js.map
+//# sourceMappingURL=openBrowser-Cw8hg7ok.js.map

package/dist/{remotes-lOhHSoSS.js → remotes-DWVw-Q7V.js}

@@ -1,5 +1,5 @@
 import "./e2e-CUMZC53I.js";
 import "./webrtcLink-CS4D-3G1.js";
-import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-Cn-wszbK.js";
+import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-iIvqiFWK.js";
 
 export { cmdRemote };

package/dist/{remotes-Cn-wszbK.js → remotes-iIvqiFWK.js}

@@ -86,7 +86,7 @@ async function resolveRemoteSpec(spec) {
 * The bridge lives for the rest of the process (torn down on `process.exit`).
 */
 async function resolveWebrtc(link, keyword) {
-	const { startWebrtcBridge } = await import("./webrtcRemote-BkZcA5yq.js");
+	const { startWebrtcBridge } = await import("./webrtcRemote-zQybN9IR.js");
 	const bridge = await startWebrtcBridge(link);
 	return {
 		url: bridge.baseUrl,
@@ -173,4 +173,4 @@ async function cmdRemote(rest) {
 
 //#endregion
 export { resolveRemoteSpec as a, readRemotes as i, deleteRemoteAlias as n, writeRemoteAlias as o, parseDirectRemoteSpec as r, cmdRemote as t };
-//# sourceMappingURL=remotes-Cn-wszbK.js.map
+//# sourceMappingURL=remotes-iIvqiFWK.js.map

package/dist/{rustBinary-CkTiZVJ4.js → rustBinary-DSVRhDzO.js}

@@ -1,4 +1,4 @@
-import { r as getInstalledPackage } from "./versionChecker-C6RmYXss.js";
+import { r as getInstalledPackage } from "./versionChecker-CMOLbEEi.js";
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
@@ -243,4 +243,4 @@ async function getRustBinary(options = {}) {
 
 //#endregion
 export { findTrayLauncher as n, getRustBinary as r, findSpawnHiddenLauncher as t };
-//# sourceMappingURL=rustBinary-CkTiZVJ4.js.map
+//# sourceMappingURL=rustBinary-DSVRhDzO.js.map