@tekmidian/pai 0.27.2 → 0.28.0

package/dist/main-resolver-BfSL8zio.mjs

@@ -0,0 +1,1369 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { _ as warn, c as ok, h as smartDecodeDir, i as err, l as renderTable, n as dim, o as header } from "./utils-BAxjW3j8.mjs";
+import { t as aibrokerSocketPath } from "./runtime-paths-B0P1TvUr.mjs";
+import { createReadStream, existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import chalk from "chalk";
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/cli/lib/session-scan.ts
+/**
+* Shared scanner for Claude Code sessions stored in ~/.claude/projects/ .
+*
+* Storage layout (Claude Code v2.1.143+):
+*
+*   <project>/<uuid>.jsonl          — top-level: metadata, system snapshots, hook events.
+*                                     REQUIRED for claude --resume to work.
+*   <project>/sessions/<uuid>.jsonl — full transcript: user/assistant/attachment lines.
+*                                     3000+ files, almost none resumable on their own.
+*
+* Resumability rule (empirically verified):
+*   A session is resumable iff the TOP-LEVEL jsonl exists AND contains at least one
+*   line of type "system". Sessions that only have a sessions/ counterpart cannot be
+*   resumed by Claude Code regardless of how much transcript content they have.
+*
+* Stale-UUID problem (fixed in this version):
+*   The clc session.json registry stores ONE uuid per named session — the uuid Claude Code
+*   had when the user last named the session. If the user resumes and the session gets a
+*   new uuid (or they Ctrl+C and start fresh), the registry entry still points to the OLD
+*   uuid. The scanner now resolves names to the MOST RECENT top-level jsonl in the project
+*   directory, not the clc-cached uuid.
+*
+* Resolution strategy:
+*   1. Walk top-level <project>/<uuid>.jsonl files (Pass 1).
+*   2. For each, attach the clc name if the uuid matches (exact hit).
+*   3. After Pass 1, for every clc registry entry:
+*      a. If the cached uuid was found → already handled.
+*      b. Find the encodedDir for this entry's directory.
+*      c. Check ALL sessions in that encodedDir (already in our Pass-1 results).
+*      d. Pick the MOST RECENT resumable session in that dir and attach the name to it.
+*         If no resumable session, fall through to transcript-only pass.
+*   4. This means the displayed uuid for "Jobs Matthias" is always today's active session,
+*      not the stale cached one.
+*
+* Used by: pai sessions, pai resume
+*/
+const CLC_SESSIONS_FILE = join(homedir(), ".claude", "session.json");
+/** Load clc's session registry → uuid → ClcInfo map. Verbatim, never slugified. */
+function buildClcInfoMap() {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const raw = readFileSync(CLC_SESSIONS_FILE, "utf8");
+		const data = JSON.parse(raw);
+		for (const entry of data.sessions ?? []) {
+			const name = entry.name?.trim();
+			const uuid = (entry.resume ?? entry.session ?? "").trim();
+			if (name && uuid) map.set(uuid, {
+				name,
+				directory: entry.directory?.trim() || void 0
+			});
+		}
+	} catch {}
+	return map;
+}
+/** Build encoded_dir → root_path map from PAI registry (authoritative cwd). */
+function buildRegistryRootPathMap(db) {
+	try {
+		const rows = db.prepare(`SELECT root_path, encoded_dir FROM projects
+         WHERE encoded_dir IS NOT NULL AND encoded_dir != ''`).all();
+		const map = /* @__PURE__ */ new Map();
+		for (const row of rows) map.set(row.encoded_dir, row.root_path);
+		return map;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function parseTopLevel(filePath) {
+	let systemLines = 0;
+	let size = 0;
+	let mtime = 0;
+	try {
+		const st = statSync(filePath);
+		size = st.size;
+		mtime = st.mtimeMs;
+		const content = readFileSync(filePath, "utf8");
+		for (const line of content.split("\n")) {
+			const t = line.trim();
+			if (!t) continue;
+			if (t.includes("\"type\":\"system\"") || t.includes("\"type\": \"system\"")) systemLines++;
+		}
+	} catch {}
+	return {
+		systemLines,
+		size,
+		mtime
+	};
+}
+function parseTranscript(filePath) {
+	let userLines = 0;
+	let lastUserPrompt = "";
+	let msgCount = 0;
+	let aiTitle;
+	let mtime = 0;
+	try {
+		mtime = statSync(filePath).mtimeMs;
+	} catch {
+		return {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime: 0
+		};
+	}
+	let content;
+	try {
+		content = readFileSync(filePath, "utf8");
+	} catch {
+		return {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime
+		};
+	}
+	for (const line of content.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		msgCount++;
+		const hasUser = t.includes("\"type\":\"user\"") || t.includes("\"type\": \"user\"");
+		const hasTitle = t.includes("\"type\":\"ai-title\"") || t.includes("\"type\": \"ai-title\"");
+		if (!hasUser && !hasTitle) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(t);
+		} catch {
+			continue;
+		}
+		if (parsed.type === "ai-title") {
+			const v = parsed.title ?? parsed.name;
+			if (typeof v === "string" && v.trim()) aiTitle = v.trim();
+			continue;
+		}
+		if (parsed.type !== "user") continue;
+		userLines++;
+		const msg = parsed.message;
+		if (!msg) continue;
+		const c = msg.content;
+		let text = "";
+		if (typeof c === "string") text = c;
+		else if (Array.isArray(c) && c.length > 0) {
+			const first = c[0];
+			if (typeof first.text === "string") text = first.text;
+		}
+		if (text) lastUserPrompt = text.slice(0, 80).replace(/\n/g, " ");
+	}
+	return {
+		userLines,
+		lastUserPrompt,
+		msgCount,
+		aiTitle,
+		mtime
+	};
+}
+const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Compute the effective filter mode, resolving the legacy resumableOnly flag.
+*/
+function resolveFilter(opts) {
+	if (opts.filter) return opts.filter;
+	if (opts.resumableOnly === true) return "resumable";
+	if (opts.resumableOnly === false) return "all";
+	return "named";
+}
+/**
+* Scan ~/.claude/projects/ for all Claude Code sessions.
+*
+* Pass 1: walk top-level <project>/<uuid>.jsonl files (the resumability source).
+* Pass 2: handle clc registry entries whose cached UUID was not found in Pass 1.
+*         For each such entry, scan the entry's project dir for the FRESHEST session
+*         and attach the registry name to it. This fixes the stale-UUID bug where
+*         clc's session.json points to an old uuid after a fresh start.
+* Pass 3: any remaining clc entries with truly no top-level jsonl → transcript-only.
+*
+* Filter modes:
+*   "named"     — resumable + registry-known stubs + transcript-only (default)
+*   "all"       — all of the above + unnamed orphans from sessions/ subdirs
+*   "resumable" — only sessions claude --resume accepts
+*
+* Returns results sorted by mtime descending.
+*/
+function scanSessions(db, opts = {}) {
+	const limit = opts.limit ?? 200;
+	const filterMode = resolveFilter(opts);
+	if (!existsSync(CLAUDE_PROJECTS_DIR)) return [];
+	const clcInfoMap = buildClcInfoMap();
+	const rootPathMap = buildRegistryRootPathMap(db);
+	const results = [];
+	const seenUuids = /* @__PURE__ */ new Set();
+	const attachedClcUuids = /* @__PURE__ */ new Set();
+	let encodedDirs;
+	try {
+		encodedDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+	} catch {
+		return [];
+	}
+	const sessionsByEncodedDir = /* @__PURE__ */ new Map();
+	for (const encodedDir of encodedDirs) {
+		const projectDir = join(CLAUDE_PROJECTS_DIR, encodedDir);
+		try {
+			if (!statSync(projectDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let files;
+		try {
+			files = readdirSync(projectDir);
+		} catch {
+			continue;
+		}
+		const decodedPath = smartDecodeDir(encodedDir) ?? encodedDir.replace(/-/g, "/");
+		const registryRootPath = rootPathMap.get(encodedDir);
+		const projectBasename = basename(decodedPath);
+		for (const file of files) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			const topLevelPath = join(projectDir, file);
+			const topInfo = parseTopLevel(topLevelPath);
+			const resumable = topInfo.systemLines > 0;
+			const clcInfo = clcInfoMap.get(uuid);
+			const inRegistry = !!clcInfo;
+			const sessionStatus = resumable ? "resumable" : inRegistry ? "stub" : "orphan";
+			const passesFilter = filterMode === "resumable" ? resumable : filterMode === "named" ? resumable || inRegistry : true;
+			const sessionJsonlPath = join(projectDir, "sessions", `${uuid}.jsonl`);
+			const hasTranscript = existsSync(sessionJsonlPath);
+			const transcript = hasTranscript ? parseTranscript(sessionJsonlPath) : {
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime: 0
+			};
+			const mtime = topInfo.mtime || transcript.mtime;
+			const friendlyName = clcInfo?.name ?? transcript.aiTitle ?? projectBasename ?? void 0;
+			const session = {
+				uuid,
+				shortId: uuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath,
+				topLevelSystemLines: topInfo.systemLines,
+				topLevelSize: topInfo.size,
+				resumable,
+				sessionStatus,
+				sessionJsonlPath: hasTranscript ? sessionJsonlPath : void 0,
+				userLines: transcript.userLines,
+				lastUserPrompt: transcript.lastUserPrompt,
+				msgCount: transcript.msgCount,
+				aiTitle: transcript.aiTitle,
+				mtime,
+				friendlyName,
+				clcDirectory: clcInfo?.directory,
+				registryRootPath
+			};
+			if (!sessionsByEncodedDir.has(encodedDir)) sessionsByEncodedDir.set(encodedDir, []);
+			sessionsByEncodedDir.get(encodedDir).push(session);
+			seenUuids.add(uuid);
+			if (inRegistry) attachedClcUuids.add(uuid);
+			if (passesFilter) results.push(session);
+		}
+	}
+	if (filterMode !== "resumable") for (const [cachedUuid, clcInfo] of clcInfoMap) {
+		if (attachedClcUuids.has(cachedUuid)) continue;
+		let foundEncodedDir;
+		if (clcInfo.directory) {
+			const real = realpathSyncSafe(clcInfo.directory);
+			if (real) {
+				const encoded = encodeProjectDir(real);
+				if (existsSync(join(CLAUDE_PROJECTS_DIR, encoded))) foundEncodedDir = encoded;
+			}
+		}
+		if (!foundEncodedDir) {
+			for (const encodedDir of encodedDirs) if (existsSync(join(CLAUDE_PROJECTS_DIR, encodedDir, "sessions", `${cachedUuid}.jsonl`))) {
+				foundEncodedDir = encodedDir;
+				break;
+			}
+		}
+		if (foundEncodedDir) {
+			const freshestResumable = (sessionsByEncodedDir.get(foundEncodedDir) ?? []).filter((s) => s.resumable && !s.friendlyName).sort((a, b) => b.mtime - a.mtime)[0];
+			if (freshestResumable) {
+				freshestResumable.friendlyName = clcInfo.name;
+				freshestResumable.clcDirectory = freshestResumable.clcDirectory ?? clcInfo.directory;
+				freshestResumable.sessionStatus = "resumable";
+				attachedClcUuids.add(freshestResumable.uuid);
+				if (!seenUuids.has(freshestResumable.uuid) || !results.includes(freshestResumable)) {
+					if (!results.includes(freshestResumable)) results.push(freshestResumable);
+				}
+				continue;
+			}
+		}
+		if (!foundEncodedDir) {
+			const encodedDir = "";
+			const decodedPath = clcInfo.directory ?? cachedUuid;
+			const registryRootPath = void 0;
+			const mtime = {
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime: 0
+			}.mtime;
+			seenUuids.add(cachedUuid);
+			results.push({
+				uuid: cachedUuid,
+				shortId: cachedUuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath: "",
+				topLevelSystemLines: 0,
+				topLevelSize: 0,
+				resumable: false,
+				sessionStatus: "transcript-only",
+				sessionJsonlPath: void 0,
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime,
+				friendlyName: clcInfo.name,
+				clcDirectory: clcInfo.directory,
+				registryRootPath
+			});
+			continue;
+		}
+		const foundTranscriptPath = existsSync(join(CLAUDE_PROJECTS_DIR, foundEncodedDir, "sessions", `${cachedUuid}.jsonl`)) ? join(CLAUDE_PROJECTS_DIR, foundEncodedDir, "sessions", `${cachedUuid}.jsonl`) : void 0;
+		const decodedPath = clcInfo.directory ?? smartDecodeDir(foundEncodedDir) ?? foundEncodedDir.replace(/-/g, "/");
+		const registryRootPath = rootPathMap.get(foundEncodedDir);
+		const topLevelPath = join(CLAUDE_PROJECTS_DIR, foundEncodedDir, `${cachedUuid}.jsonl`);
+		const transcript = foundTranscriptPath ? parseTranscript(foundTranscriptPath) : {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime: 0
+		};
+		seenUuids.add(cachedUuid);
+		results.push({
+			uuid: cachedUuid,
+			shortId: cachedUuid.slice(0, 8),
+			encodedDir: foundEncodedDir,
+			decodedPath,
+			topLevelPath,
+			topLevelSystemLines: 0,
+			topLevelSize: 0,
+			resumable: false,
+			sessionStatus: "transcript-only",
+			sessionJsonlPath: foundTranscriptPath,
+			userLines: transcript.userLines,
+			lastUserPrompt: transcript.lastUserPrompt,
+			msgCount: transcript.msgCount,
+			aiTitle: transcript.aiTitle,
+			mtime: transcript.mtime,
+			friendlyName: clcInfo.name,
+			clcDirectory: clcInfo.directory,
+			registryRootPath
+		});
+	}
+	results.sort((a, b) => b.mtime - a.mtime);
+	return results.slice(0, limit);
+}
+/** Claude Code's project-dir encoding: replace /  .  -  (space) with - */
+function encodeProjectDir(realPath) {
+	return realPath.replace(/[/.\- ]/g, "-");
+}
+/** realpathSync that returns null instead of throwing */
+function realpathSyncSafe(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+function fmtAge(mtime) {
+	const diffMs = Date.now() - mtime;
+	const diffMin = Math.floor(diffMs / 6e4);
+	const diffHr = Math.floor(diffMs / 36e5);
+	const diffDay = Math.floor(diffMs / 864e5);
+	if (diffMin < 60) return `${diffMin}m`;
+	if (diffHr < 24) return `${diffHr}h`;
+	if (diffDay < 30) return `${diffDay}d`;
+	return `${Math.floor(diffDay / 30)}mo`;
+}
+/**
+* Filesystem-level UUID scan: walk ALL ~/.claude/projects/<encoded-dir>/<uuid>.jsonl
+* looking for top-level files whose UUID starts with `prefix`.
+*
+* Returns a ScannedSession-like object (minimal fields) for each match, or an empty
+* array if nothing is found. This is used as a fallback when the regular catalog
+* (limited to named/recent sessions) doesn't contain the requested UUID.
+*
+* Complexity: O(number of project directories + files per dir). Typically <200 dirs
+* with a handful of top-level jsonl each — fast enough for an interactive CLI.
+*/
+function scanFilesystemForUuidPrefix(prefix) {
+	if (!existsSync(CLAUDE_PROJECTS_DIR)) return [];
+	const prefixLower = prefix.toLowerCase();
+	const matches = [];
+	let encodedDirs;
+	try {
+		encodedDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+	} catch {
+		return [];
+	}
+	for (const encodedDir of encodedDirs) {
+		const projectDir = join(CLAUDE_PROJECTS_DIR, encodedDir);
+		try {
+			if (!statSync(projectDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let files;
+		try {
+			files = readdirSync(projectDir);
+		} catch {
+			continue;
+		}
+		for (const file of files) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			if (!uuid.toLowerCase().startsWith(prefixLower)) continue;
+			const topLevelPath = join(projectDir, file);
+			const topInfo = parseTopLevel(topLevelPath);
+			const resumable = topInfo.systemLines > 0;
+			const decodedPath = smartDecodeDir(encodedDir) ?? encodedDir.replace(/-/g, "/");
+			const sessionJsonlPath = join(projectDir, "sessions", `${uuid}.jsonl`);
+			const hasTranscript = existsSync(sessionJsonlPath);
+			const transcript = hasTranscript ? parseTranscript(sessionJsonlPath) : {
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime: 0
+			};
+			matches.push({
+				uuid,
+				shortId: uuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath,
+				topLevelSystemLines: topInfo.systemLines,
+				topLevelSize: topInfo.size,
+				resumable,
+				sessionStatus: resumable ? "resumable" : "stub",
+				sessionJsonlPath: hasTranscript ? sessionJsonlPath : void 0,
+				userLines: transcript.userLines,
+				lastUserPrompt: transcript.lastUserPrompt,
+				msgCount: transcript.msgCount,
+				aiTitle: transcript.aiTitle,
+				mtime: topInfo.mtime || transcript.mtime,
+				friendlyName: transcript.aiTitle ?? basename(decodedPath),
+				clcDirectory: void 0,
+				registryRootPath: void 0
+			});
+		}
+	}
+	return matches.sort((a, b) => b.mtime - a.mtime);
+}
+/**
+* Resolve a name-or-id-or-prefix to a single ScannedSession.
+*
+* Comparisons are case-insensitive; stored casing is preserved in output.
+*
+* Priority:
+*  1. Exact case-insensitive match on friendlyName
+*  2. Partial case-insensitive match (contains)
+*  3. UUID prefix match against the in-memory catalog
+*  4. UUID prefix match against the full filesystem (fallback for any session)
+*/
+function resolveSessionByNameOrId(sessions, query) {
+	const qLower = query.toLowerCase().trim();
+	const byExact = sessions.filter((s) => s.friendlyName && s.friendlyName.toLowerCase() === qLower);
+	if (byExact.length >= 1) return {
+		session: byExact[0],
+		friendlyName: byExact[0].friendlyName
+	};
+	const byPartial = sessions.filter((s) => s.friendlyName && s.friendlyName.toLowerCase().includes(qLower));
+	if (byPartial.length === 1) return {
+		session: byPartial[0],
+		friendlyName: byPartial[0].friendlyName
+	};
+	if (byPartial.length > 1) {
+		const candidates = byPartial.slice(0, 5).map((s, i) => `  ${i + 1}. ${s.shortId}  ${s.friendlyName ?? s.decodedPath}  (${fmtAge(s.mtime)} ago)`).join("\n");
+		throw new Error(`Ambiguous name "${query}" — ${byPartial.length} matches:\n${candidates}\n\nBe more specific or use a UUID prefix.`);
+	}
+	const byUuid = sessions.filter((s) => s.uuid.startsWith(qLower));
+	if (byUuid.length === 1) return {
+		session: byUuid[0],
+		friendlyName: byUuid[0].friendlyName
+	};
+	if (byUuid.length > 1) {
+		const candidates = byUuid.slice(0, 5).map((s, i) => `  ${i + 1}. ${s.shortId}  ${s.friendlyName ?? s.decodedPath}  (${fmtAge(s.mtime)} ago)`).join("\n");
+		throw new Error(`UUID prefix "${query}" is ambiguous — ${byUuid.length} matches:\n${candidates}\n\nProvide more characters.`);
+	}
+	if (/^[0-9a-f-]{4,36}$/i.test(qLower)) {
+		const fsSessions = scanFilesystemForUuidPrefix(qLower);
+		if (fsSessions.length === 1) return {
+			session: fsSessions[0],
+			friendlyName: fsSessions[0].friendlyName
+		};
+		if (fsSessions.length > 1) {
+			const candidates = fsSessions.slice(0, 5).map((s, i) => `  ${i + 1}. ${s.shortId}  ${s.friendlyName ?? s.decodedPath}  (${fmtAge(s.mtime)} ago)`).join("\n");
+			throw new Error(`UUID prefix "${query}" is ambiguous — ${fsSessions.length} matches:\n${candidates}\n\nProvide more characters.`);
+		}
+	}
+	throw new Error(`No session found matching "${query}".\n\nRun: pai sessions          to list sessions.\nRun: pai sessions --all    to include transcript-only sessions.\nRun: pai find <words>      to search prompt history.`);
+}
+
+//#endregion
+//#region src/cli/lib/aibroker-client.ts
+/**
+* aibroker-client.ts — Lightweight IPC client for AIBroker daemon.
+*
+* Connects to the AIBroker Unix Domain Socket, sends a JSON-RPC request,
+* and reads a single newline-terminated JSON response. No class needed —
+* just a thin async function matching the WatcherClient protocol.
+*
+* Socket path: /tmp/aibroker.sock (default; override via AIBROKER_SOCKET env).
+*/
+const DEFAULT_SOCKET = process.env.AIBROKER_SOCKET ?? aibrokerSocketPath();
+/**
+* How long to wait for `send_to_session`, which must exceed the server's own
+* ack window or the caller gives up while the callee is still working.
+*
+* AIBroker waits up to SEND_ACK_TIMEOUT_MS (15s) for the submit confirmation —
+* the text leaving the input line — before answering. The generic client
+* timeout is 8s. So every send needing 8-15s to confirm reported
+* "AIBroker IPC call timed out" while succeeding, and the handler's eventual
+* `delivered: true` was written into a socket nobody was reading any more.
+*
+* Measured on `pai pause all` across 15 sessions: 9 reported failed, 8 of them
+* verifiably paused. A caller's deadline shorter than the callee's is not a
+* tuning question, it is a guaranteed false negative on every slow success.
+*/
+const SEND_TIMEOUT_MS = 3e4;
+/**
+* Call an AIBroker IPC method and return the result.
+*
+* Resolves with the `result` field of a successful response.
+* Rejects if the socket is not available, the call times out, or the
+* daemon returns an error.
+*
+* @param method   IPC method name (e.g. "session_content", "send_to_session")
+* @param params   Method parameters object
+* @param timeoutMs  Connection + response timeout in milliseconds (default: 8 000)
+*/
+function callAiBroker(method, params = {}, timeoutMs = 8e3) {
+	return new Promise((resolve, reject) => {
+		const socketPath = DEFAULT_SOCKET;
+		let done = false;
+		let buffer = "";
+		let timer = null;
+		function finish(err, value) {
+			if (done) return;
+			done = true;
+			if (timer !== null) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			try {
+				socket.destroy();
+			} catch {}
+			if (err) reject(err);
+			else resolve(value);
+		}
+		const socket = connect(socketPath, () => {
+			const request = {
+				id: randomUUID(),
+				sessionId: process.env.TERM_SESSION_ID ?? "pai-cli",
+				method,
+				params
+			};
+			const itermId = process.env.ITERM_SESSION_ID;
+			if (itermId) Object.assign(request, { itermSessionId: itermId });
+			socket.write(JSON.stringify(request) + "\n");
+		});
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString("utf8");
+			const nl = buffer.indexOf("\n");
+			if (nl === -1) return;
+			const line = buffer.slice(0, nl);
+			let response;
+			try {
+				response = JSON.parse(line);
+			} catch {
+				finish(/* @__PURE__ */ new Error(`AIBroker IPC parse error: ${line.slice(0, 120)}`));
+				return;
+			}
+			if (!response.ok) finish(new Error(response.error ?? "AIBroker IPC call failed"));
+			else finish(null, response.result ?? {});
+		});
+		socket.on("error", (e) => {
+			if (e.code === "ENOENT" || e.code === "ECONNREFUSED") finish(/* @__PURE__ */ new Error("AIBroker not running (socket not found)."));
+			else finish(e);
+		});
+		socket.on("end", () => {
+			if (!done) finish(/* @__PURE__ */ new Error("AIBroker IPC connection closed before response."));
+		});
+		timer = setTimeout(() => finish(/* @__PURE__ */ new Error("AIBroker IPC call timed out.")), timeoutMs);
+	});
+}
+/**
+* Fetch all live iTerm2 session metadata from AIBroker via the `sessions` method.
+* Returns an empty array if AIBroker is not running.
+*
+* This is metadata-only (no scrollback). It is faster than `session_content`
+* and the correct source for listing/routing purposes.
+*/
+async function fetchLiveSessions() {
+	try {
+		const sessions = (await callAiBroker("sessions", {})).sessions;
+		if (!Array.isArray(sessions)) return [];
+		return sessions;
+	} catch {
+		return [];
+	}
+}
+/**
+* Send text to a specific AIBroker session by its iTerm2 sessionId.
+*
+* The wire keys are `target` and `message`, and neither is negotiable — the
+* handler rejects anything else with "target is required" before it looks at
+* the rest. This was written as `{ target: sessionId, message: text }`, which is the shape of
+* THIS function's own parameters rather than the shape of the IPC, so every
+* call failed identically. `pai pause all` was the only caller, so the live
+* path had never once executed: its --dry-run branch returns before sending,
+* and that was the only branch anyone had exercised.
+*
+* The caller must NOT terminate `text` with a newline. The transport sends with
+* `enter: true` and appends the Enter itself, so a trailing \n submits twice —
+* once for the text and once for an empty prompt.
+*/
+async function sendToSession(sessionId, text, timeoutMs = SEND_TIMEOUT_MS) {
+	try {
+		await callAiBroker("send_to_session", {
+			target: sessionId,
+			message: text
+		}, timeoutMs);
+		return { ok: true };
+	} catch (e) {
+		const error = String(e);
+		return {
+			ok: false,
+			error,
+			timedOut: /timed out/i.test(error)
+		};
+	}
+}
+/**
+* Switch iTerm2 focus to the session identified by `target`.
+*
+* `target` can be a sessionId, paiName, or tab index number (as string).
+* After switching, activates the iTerm2 application itself so the window
+* comes to the foreground.
+*
+* Returns { ok: true } if AIBroker confirmed the switch, or
+* { ok: false, error } if AIBroker is not running or the session was not found.
+*/
+async function switchToSession(target) {
+	try {
+		await callAiBroker("switch", { target });
+		const { spawnSync } = await import("node:child_process");
+		spawnSync("osascript", ["-e", "tell application \"iTerm\" to activate"], { stdio: "ignore" });
+		return { ok: true };
+	} catch (e) {
+		return {
+			ok: false,
+			error: String(e)
+		};
+	}
+}
+/**
+* Bring the iTerm2 tab containing a specific session to the front.
+*
+* This is the mechanism AIBroker's screenshot path uses: match the session by
+* its iTerm2 session id (the `sessionId` returned by `fetchLiveSessions`, which
+* is iTerm's own `id of session`), then `select` its window, tab, and session.
+* Unlike the `switch` IPC (which only flips an internal index and never touches
+* iTerm), this actually reveals the tab.
+*/
+function revealItermSession(itermSessionId) {
+	const script = `tell application "iTerm2"
+  activate
+  repeat with w in windows
+    repeat with t in tabs of w
+      repeat with s in sessions of t
+        if id of s is "${itermSessionId.replace(/^iterm:/i, "").trim()}" then
+          select w
+          select t
+          select s
+          return "ok"
+        end if
+      end repeat
+    end repeat
+  end repeat
+  return "not-found"
+end tell`;
+	try {
+		const r = spawnSync("osascript", ["-e", script], { encoding: "utf8" });
+		if (r.status !== 0) return {
+			ok: false,
+			error: (r.stderr || "osascript failed").trim()
+		};
+		if ((r.stdout ?? "").trim() === "ok") return { ok: true };
+		return {
+			ok: false,
+			error: "session not found in any iTerm2 window"
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: String(e)
+		};
+	}
+}
+
+//#endregion
+//#region src/cli/lib/exit-dir.ts
+/**
+* Print the working directory of a `claude` session that pai launched, right
+* after it exits. This lets the user cd back into the same directory and
+* restart claude to continue — Claude Code's own `--resume` hint is unreliable
+* for this workflow.
+*
+* Why here and not a SessionEnd hook: a hook inside Claude Code is cancelled
+* during teardown (anthropics/claude-code#41577) and races the terminal
+* restore, so it can't reliably print anything. pai spawns the `claude` binary
+* directly (no shell), so the `claude()` shell wrapper never sees pai-launched
+* sessions either. Printing here — after spawnSync has returned and claude has
+* fully exited — is the one place that reliably reaches the terminal.
+*/
+function printExitDir(dir) {
+	process.stdout.write(`\n\x1b[2m📂 Working directory:\x1b[0m ${dir}\n\x1b[2m   cd "${dir}"\x1b[0m\n`);
+}
+
+//#endregion
+//#region src/cli/lib/history-search.ts
+/**
+* history-search.ts
+*
+* Content-based search across ~/.claude/history.jsonl.
+* Streams the file (avoids loading 26k+ lines into memory), groups matching
+* lines by sessionId, and returns results sorted by most-recent match.
+*
+* Used by: pai <query> (main resolver) and pai find (compat alias)
+*/
+const HISTORY_FILE = join(homedir(), ".claude", "history.jsonl");
+/**
+* Search ~/.claude/history.jsonl for prompts matching the query (case-insensitive
+* substring). Results are grouped by sessionId and sorted by most-recent match.
+*
+* Entries without a sessionId (old Claude Code versions) are excluded from
+* results since they can't be resumed.
+*/
+async function searchHistory(query, maxResults) {
+	if (!existsSync(HISTORY_FILE)) return [];
+	const queryLower = query.toLowerCase();
+	const bySession = /* @__PURE__ */ new Map();
+	const rl = createInterface({
+		input: createReadStream(HISTORY_FILE, { encoding: "utf8" }),
+		crlfDelay: Infinity
+	});
+	for await (const line of rl) {
+		const t = line.trim();
+		if (!t) continue;
+		let entry;
+		try {
+			entry = JSON.parse(t);
+		} catch {
+			continue;
+		}
+		const display = entry.display ?? "";
+		if (!display.toLowerCase().includes(queryLower)) continue;
+		const ts = entry.timestamp ?? 0;
+		const project = entry.project ?? "";
+		const sessionId = entry.sessionId ?? null;
+		if (!sessionId) continue;
+		const existing = bySession.get(sessionId);
+		if (!existing) bySession.set(sessionId, {
+			sessionId,
+			lastMatchTs: ts,
+			lastMatchDisplay: display,
+			project,
+			matchCount: 1
+		});
+		else {
+			existing.matchCount++;
+			if (ts > existing.lastMatchTs) {
+				existing.lastMatchTs = ts;
+				existing.lastMatchDisplay = display;
+				existing.project = project;
+			}
+		}
+	}
+	return [...bySession.values()].sort((a, b) => b.lastMatchTs - a.lastMatchTs).slice(0, maxResults);
+}
+
+//#endregion
+//#region src/cli/lib/dedup-sessions.ts
+const STATUS_PRIORITY = {
+	live: 0,
+	resumable: 1,
+	"transcript-only": 2,
+	stub: 3,
+	project: 4,
+	orphan: 5
+};
+/**
+* Strip Claude Code spinner characters, decoration prefixes, and " (node)" suffixes
+* from a session name so that "✳ Chenarlier (node)" and "Chenarlier" group together.
+*
+* Handles:
+*   - Unicode braille spinner frames: ⠐ ⠂ ⠁ ⠈ ⠘ ⠙ ⠚ ⠛ ⠗ ⠝
+*   - Decoration characters: ✻ ✳ ✲ ✼ ✦ * ★ ☆ • ●
+*   - Any leading non-letter/digit characters followed by whitespace
+*   - Trailing " (node)" suffix (Claude Code appends this on some platforms)
+*/
+function normalizeName(s) {
+	return s.replace(/^[⠀-⣿✀-➿✻✳✲✼✦*★☆•●⠐⠂⠁⠈⠘⠙⠚⠛⠗⠝]+\s*/u, "").replace(/^[^a-zA-Z0-9À-ÿ　-鿿]+\s*/u, "").replace(/\s*\(node\)\s*$/i, "").trim();
+}
+/**
+* Normalize a slug (kebab-case) to a human-readable form for matching.
+* "jobs-grazyna" → "jobs grazyna"
+*/
+function slugToWords(slug) {
+	return slug.replace(/-/g, " ");
+}
+/**
+* Merge live (AIBroker) + disk (session-scan) + registry (projects DB) sessions
+* into a deduped catalog.
+*
+* Algorithm:
+*   1. Normalize names before grouping
+*   2. Group by normalized name (case-insensitive)
+*   3. Within each group, rank by STATUS_PRIORITY (live wins)
+*   4. Within same priority, keep the most recent (highest mtime)
+*   5. Sort output: by priority, then by lastActivity desc
+*   6. Filter idle project entries (default) or show all (showAll=true)
+*
+* @param showAll  When true, include cold / zero-session / archived projects.
+*/
+function buildDeduped(liveSessions, diskSessions, registeredProjects, showAll = false) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const s of liveSessions) {
+		if (s.kind === "shell") continue;
+		const normalized = normalizeName(s.paiName ?? s.sessionId.slice(0, 8));
+		const key = normalized.toLowerCase();
+		const entry = {
+			name: normalized,
+			status: "live",
+			liveSessionId: s.sessionId,
+			lastActivity: Date.now(),
+			project: "",
+			lastPrompt: s.lastPrompt ?? ""
+		};
+		const existing = byName.get(key);
+		if (!existing || STATUS_PRIORITY["live"] < STATUS_PRIORITY[existing.status]) byName.set(key, entry);
+	}
+	for (const s of diskSessions) {
+		const normalized = normalizeName(s.friendlyName ?? s.shortId);
+		const key = normalized.toLowerCase();
+		let status;
+		if (s.resumable) status = "resumable";
+		else if (s.sessionStatus === "transcript-only") status = "transcript-only";
+		else if (s.sessionStatus === "stub") status = "stub";
+		else status = "orphan";
+		const entry = {
+			name: normalized,
+			status,
+			diskSession: s,
+			lastActivity: s.mtime,
+			project: s.decodedPath ?? "",
+			lastPrompt: s.lastUserPrompt ?? ""
+		};
+		const existing = byName.get(key);
+		if (!existing) byName.set(key, entry);
+		else {
+			const ep = STATUS_PRIORITY[existing.status];
+			const np = STATUS_PRIORITY[status];
+			if (np < ep || np === ep && entry.lastActivity > existing.lastActivity) byName.set(key, entry);
+		}
+	}
+	const COLD_THRESHOLD_MS = 2160 * 60 * 60 * 1e3;
+	const now = Date.now();
+	if (registeredProjects) for (const p of registeredProjects) {
+		if (!showAll && p.status !== "active") continue;
+		const normalized = normalizeName(p.display_name ?? p.slug);
+		const key = normalized.toLowerCase();
+		const slugKey = slugToWords(p.slug).toLowerCase();
+		if (!byName.has(key) && !byName.has(slugKey)) {
+			if (!showAll) {
+				if (p.session_count === 0) continue;
+				if (p.session_count < 3) {
+					if (now - (p.last_active ?? 0) > COLD_THRESHOLD_MS) continue;
+				}
+			}
+			byName.set(key, {
+				name: normalized,
+				slug: p.slug,
+				status: "project",
+				lastActivity: p.last_active ?? 0,
+				project: p.root_path,
+				lastPrompt: "",
+				sessionCount: p.session_count
+			});
+		} else {
+			const existing = byName.get(key) ?? byName.get(slugKey);
+			if (existing && !existing.slug) existing.slug = p.slug;
+			if (existing && existing.sessionCount === void 0) existing.sessionCount = p.session_count;
+		}
+	}
+	const entries = Array.from(byName.values());
+	entries.sort((a, b) => {
+		const pa = STATUS_PRIORITY[a.status];
+		const pb = STATUS_PRIORITY[b.status];
+		if (pa !== pb) return pa - pb;
+		return b.lastActivity - a.lastActivity;
+	});
+	return entries;
+}
+function fmtUnifiedStatus(s) {
+	switch (s) {
+		case "live": return chalk.green("live");
+		case "resumable": return chalk.cyan("resumable");
+		case "transcript-only": return chalk.dim("transcript");
+		case "stub": return chalk.dim("stub");
+		case "project": return chalk.dim("idle");
+		case "orphan": return chalk.dim("orphan");
+	}
+}
+function shortenProject$1(p, maxLen = 28) {
+	if (!p || p.length <= maxLen) return p || dim("—");
+	return "…" + p.slice(-(maxLen - 1));
+}
+/**
+* Render the deduped session catalog to stdout.
+*
+* @param entries   Output of buildDeduped()
+* @param maxRows   Maximum rows to display. undefined = no limit (for --all).
+*/
+function renderDedupedSessions(entries, maxRows) {
+	if (entries.length === 0) {
+		console.log(warn("No sessions found. Start Claude Code in a project directory first."));
+		return;
+	}
+	console.log("\n" + header("Sessions") + "\n");
+	const visible = maxRows !== void 0 ? entries.slice(0, maxRows) : entries;
+	const tableHeaders = [
+		"#",
+		"name",
+		"status",
+		"age",
+		"project",
+		"last prompt"
+	];
+	const tableRows = visible.map((entry, i) => {
+		const age = entry.status === "live" ? chalk.green("now") : entry.lastActivity > 0 ? dim(fmtAge(entry.lastActivity)) : dim("—");
+		const snippet = entry.lastPrompt.replace(/\n+/g, " ").trim().slice(0, 36);
+		const project = dim(shortenProject$1(entry.diskSession ? entry.diskSession.friendlyName ?? entry.diskSession.decodedPath : entry.project, 28));
+		return [
+			dim(String(i + 1)),
+			chalk.white(entry.name),
+			fmtUnifiedStatus(entry.status),
+			age,
+			project,
+			chalk.dim(snippet ? `"${snippet}"` : "—")
+		];
+	});
+	console.log(renderTable(tableHeaders, tableRows));
+	if (maxRows !== void 0 && entries.length > maxRows) console.log(dim(`  … ${entries.length - maxRows} more — use --all to show everything`));
+	console.log();
+	console.log(dim("  Switch/resume/start: ") + chalk.white("pai <name>") + dim("  or  ") + chalk.white("pai <uuid-prefix>"));
+	console.log();
+}
+
+//#endregion
+//#region src/cli/commands/main-resolver.ts
+var main_resolver_exports = /* @__PURE__ */ __exportAll({ cmdMain: () => cmdMain });
+function probeResume(uuid, cwd) {
+	const result = spawnSync("claude", [
+		"--resume",
+		uuid,
+		"--print",
+		"--output-format=json",
+		"_"
+	], {
+		cwd,
+		timeout: 5e3,
+		env: process.env,
+		stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		]
+	});
+	if (result.error) return {
+		ok: false,
+		reason: `spawn error: ${result.error.message}`
+	};
+	const stderr = result.stderr?.toString("utf8") ?? "";
+	if (stderr.toLowerCase().includes("no conversation found") || stderr.toLowerCase().includes("session not found")) return {
+		ok: false,
+		reason: "No conversation found for this UUID"
+	};
+	if (result.status !== 0) return {
+		ok: false,
+		reason: `claude exited ${result.status ?? "signal"}${stderr ? `: ${stderr.slice(0, 120).trim()}` : ""}`
+	};
+	return { ok: true };
+}
+function launchSession(session, allSessions, dryRun) {
+	let resumableUuid;
+	if (session.resumable) resumableUuid = session.uuid;
+	else if (session.encodedDir) {
+		const sameProject = allSessions.filter((s) => s.encodedDir === session.encodedDir && s.resumable);
+		sameProject.sort((a, b) => b.mtime - a.mtime);
+		if (sameProject.length > 0) resumableUuid = sameProject[0].uuid;
+	}
+	const rawDir = session.clcDirectory ?? session.registryRootPath ?? session.decodedPath;
+	let projectDir;
+	try {
+		projectDir = realpathSync(rawDir);
+	} catch {
+		console.error(err(`Session directory does not exist or cannot be resolved.\n  Path: ${rawDir}\n  The directory may have moved or been deleted.`));
+		process.exit(1);
+		return;
+	}
+	const name = session.friendlyName ?? session.shortId;
+	const promptArg = `/Name ${name}\ngo`;
+	if (dryRun) {
+		if (resumableUuid) {
+			console.log("\n" + chalk.bold("Dry run — would probe then exec (RESUME path):") + "\n");
+			console.log(`  cwd:      ${chalk.cyan(projectDir)}`);
+			console.log(`  probe:    claude --resume ${resumableUuid} --print --output-format=json "_"`);
+			console.log(`  argv:     claude --resume ${resumableUuid} --name "${name}" "/Name ${name}\\ngo"`);
+			console.log(`  fallback: claude --name "${name}" "/Name ${name}\\ngo"`);
+		} else {
+			console.log("\n" + chalk.bold("Dry run — would exec (FRESH path):") + "\n");
+			console.log(`  cwd:  ${chalk.cyan(projectDir)}`);
+			console.log(`  argv: claude --name "${name}" "/Name ${name}\\ngo"`);
+		}
+		console.log();
+		return;
+	}
+	if (resumableUuid) {
+		const probe = probeResume(resumableUuid, projectDir);
+		if (probe.ok) {
+			const result = spawnSync("claude", [
+				"--resume",
+				resumableUuid,
+				"--name",
+				name,
+				promptArg
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.error) {
+				console.error(err(`Failed to launch claude: ${result.error.message}`));
+				process.exit(1);
+			}
+			printExitDir(projectDir);
+			process.exit(result.status ?? 0);
+		} else {
+			process.stderr.write(chalk.yellow(`\n  Resume failed for ${resumableUuid.slice(0, 8)}: ${probe.reason ?? "unknown error"}\n  Starting fresh session in same directory.\n\n`));
+			const result = spawnSync("claude", [
+				"--name",
+				name,
+				promptArg
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.error) {
+				console.error(err(`Failed to launch claude: ${result.error.message}`));
+				process.exit(1);
+			}
+			printExitDir(projectDir);
+			process.exit(result.status ?? 0);
+		}
+	} else {
+		const result = spawnSync("claude", [
+			"--name",
+			name,
+			promptArg
+		], {
+			cwd: projectDir,
+			stdio: "inherit",
+			env: process.env
+		});
+		if (result.error) {
+			console.error(err(`Failed to launch claude: ${result.error.message}`));
+			process.exit(1);
+		}
+		printExitDir(projectDir);
+		process.exit(result.status ?? 0);
+	}
+}
+function matchToSession(match, allSessions) {
+	if (!match.sessionId) return null;
+	const catalogMatch = allSessions.find((s) => s.uuid === match.sessionId);
+	if (catalogMatch) return catalogMatch;
+	if (!match.project) return null;
+	return {
+		uuid: match.sessionId,
+		shortId: match.sessionId.slice(0, 8),
+		encodedDir: "",
+		decodedPath: match.project,
+		topLevelPath: "",
+		topLevelSystemLines: 0,
+		topLevelSize: 0,
+		resumable: false,
+		sessionStatus: "transcript-only",
+		sessionJsonlPath: void 0,
+		userLines: 0,
+		lastUserPrompt: match.lastMatchDisplay.slice(0, 80),
+		msgCount: 0,
+		mtime: match.lastMatchTs,
+		friendlyName: void 0,
+		clcDirectory: void 0,
+		registryRootPath: match.project
+	};
+}
+function fmtTs(ts) {
+	const d = new Date(ts);
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function shortenProject(p, maxLen = 44) {
+	if (!p || p.length <= maxLen) return p || dim("—");
+	return "…" + p.slice(-(maxLen - 1));
+}
+async function askForChoice(max) {
+	return new Promise((resolve) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		rl.question(dim(`\n  Enter # to launch (1-${max}), or press Enter to cancel: `), (answer) => {
+			rl.close();
+			const n = parseInt(answer.trim(), 10);
+			if (!isNaN(n) && n >= 1 && n <= max) resolve(n);
+			else resolve(null);
+		});
+	});
+}
+async function doSwitch(entry, dryRun) {
+	if (!entry.liveSessionId) return false;
+	if (dryRun) {
+		console.log("\n" + chalk.bold("Dry run — would switch iTerm tab:") + "\n");
+		console.log(`  target: ${entry.name} (${entry.liveSessionId.slice(0, 8)})`);
+		console.log(`  action: aibroker_switch + osascript iTerm activate`);
+		console.log();
+		return true;
+	}
+	const result = await switchToSession(entry.liveSessionId);
+	if (result.ok) {
+		console.log(ok(`Switched to live session: ${chalk.white(entry.name)} ` + chalk.dim(`(${entry.liveSessionId.slice(0, 8)})`)));
+		return true;
+	}
+	console.error(warn(`Could not switch via AIBroker: ${result.error ?? "unknown error"}`));
+	return false;
+}
+function getRegisteredProjects(db, all = false) {
+	try {
+		const statusClause = all ? "" : "WHERE p.status = 'active'";
+		return db.prepare(`
+        SELECT
+          p.slug,
+          p.display_name,
+          p.root_path,
+          p.status,
+          COUNT(s.id) AS session_count,
+          MAX(s.created_at) AS last_active
+        FROM projects p
+        LEFT JOIN sessions s ON s.project_id = p.id
+        ${statusClause}
+        GROUP BY p.id
+        ORDER BY last_active DESC NULLS LAST, p.updated_at DESC
+      `).all();
+	} catch {
+		return [];
+	}
+}
+async function cmdMain(db, query, pickN, opts) {
+	const maxResults = parseInt(opts.n ?? "20", 10);
+	const showAll = opts.all ?? false;
+	const livePromise = !query ? fetchLiveSessions().catch(() => []) : Promise.resolve([]);
+	const allSessions = scanSessions(db, {
+		limit: 500,
+		filter: "named"
+	});
+	const registeredProjects = getRegisteredProjects(db, showAll);
+	if (!query) {
+		renderDedupedSessions(buildDeduped(await livePromise, allSessions, registeredProjects, showAll), showAll ? void 0 : maxResults);
+		return;
+	}
+	if (/^[0-9a-f-]{8,36}$/i.test(query)) {
+		const byUuid = allSessions.filter((s) => s.uuid.startsWith(query.toLowerCase()));
+		if (byUuid.length === 1) {
+			launchSession(byUuid[0], allSessions, opts.dryRun ?? false);
+			return;
+		}
+		if (byUuid.length > 1) {
+			console.error(err(`UUID prefix "${query}" is ambiguous — ${byUuid.length} catalog matches.`));
+			process.exitCode = 1;
+			return;
+		}
+	}
+	{
+		let liveSessions = [];
+		try {
+			liveSessions = await fetchLiveSessions();
+		} catch {}
+		const deduped = buildDeduped(liveSessions, allSessions, registeredProjects, showAll);
+		const qNorm = normalizeName(query).toLowerCase();
+		const qSlug = query.toLowerCase().replace(/\s+/g, "-");
+		const nameMatches = (e, q) => e.name.toLowerCase() === q || e.slug !== void 0 && e.slug.toLowerCase() === qSlug;
+		const nameIncludes = (e, q) => e.name.toLowerCase().includes(q) || e.slug !== void 0 && e.slug.toLowerCase().includes(qSlug);
+		const exactMatch = deduped.find((e) => nameMatches(e, qNorm));
+		if (exactMatch) {
+			if (exactMatch.status === "live") {
+				if (await doSwitch(exactMatch, opts.dryRun ?? false)) return;
+			}
+			if (exactMatch.diskSession) {
+				launchSession(exactMatch.diskSession, allSessions, opts.dryRun ?? false);
+				return;
+			}
+		}
+		const partialMatches = deduped.filter((e) => nameIncludes(e, qNorm));
+		if (partialMatches.length === 1) {
+			const match = partialMatches[0];
+			if (match.status === "live") {
+				if (await doSwitch(match, opts.dryRun ?? false)) return;
+			}
+			if (match.diskSession) {
+				launchSession(match.diskSession, allSessions, opts.dryRun ?? false);
+				return;
+			}
+		}
+		if (partialMatches.length > 1) {
+			console.log("\n" + header(`Sessions matching "${query}"`) + "\n");
+			const headers = [
+				"#",
+				"name",
+				"status",
+				"age",
+				"project"
+			];
+			const rows = partialMatches.slice(0, maxResults).map((entry, i) => {
+				const age = entry.status === "live" ? chalk.green("now") : dim(fmtAge(entry.lastActivity));
+				const project = entry.diskSession ? dim(shortenProject(entry.diskSession.decodedPath, 36)) : dim("—");
+				return [
+					dim(String(i + 1)),
+					chalk.white(entry.name),
+					fmtUnifiedStatus(entry.status),
+					age,
+					project
+				];
+			});
+			console.log(renderTable(headers, rows));
+			console.log();
+			const pickMatch = async (match) => {
+				if (match.status === "live") {
+					await doSwitch(match, opts.dryRun ?? false);
+					return;
+				}
+				if (match.diskSession) launchSession(match.diskSession, allSessions, opts.dryRun ?? false);
+			};
+			if (pickN !== void 0) {
+				const idx = pickN - 1;
+				if (idx >= 0 && idx < partialMatches.length) {
+					await pickMatch(partialMatches[idx]);
+					return;
+				}
+				console.error(err(`Invalid choice: ${pickN}`));
+				process.exitCode = 1;
+				return;
+			}
+			if (opts.auto) {
+				await pickMatch(partialMatches[0]);
+				return;
+			}
+			const choice = await askForChoice(Math.min(partialMatches.length, maxResults));
+			if (choice !== null) await pickMatch(partialMatches[choice - 1]);
+			return;
+		}
+	}
+	if (!existsSync(HISTORY_FILE)) {
+		console.error(err("~/.claude/history.jsonl not found."));
+		console.error(dim("  No prompt history available for search."));
+		console.error(dim("  Try: pai  (no args) to see all sessions."));
+		process.exitCode = 1;
+		return;
+	}
+	process.stderr.write(dim(`  Searching prompt history for "${query}"...\n`));
+	const matches = await searchHistory(query, maxResults);
+	if (matches.length === 0) {
+		console.log(warn(`No sessions found matching "${query}".`));
+		console.log(dim("  Try a shorter or different search term."));
+		console.log(dim("  Or run: ") + chalk.white("pai") + dim(" (no args) to see all sessions."));
+		return;
+	}
+	console.log("\n" + header(`Sessions matching "${query}"`) + "\n");
+	const headers = [
+		"#",
+		"id",
+		"when",
+		"project",
+		"last matching prompt"
+	];
+	const rows = matches.map((m, idx) => {
+		const shortId = (m.sessionId ?? "—").slice(0, 8);
+		const when = m.lastMatchTs > 0 ? fmtTs(m.lastMatchTs) : dim("—");
+		const project = shortenProject(m.project || "—");
+		const snippet = m.lastMatchDisplay.replace(/\n+/g, " ").trim().slice(0, 48);
+		const fullSnippet = m.lastMatchDisplay.replace(/\n+/g, " ").trim();
+		const display = snippet.length < fullSnippet.length ? `"${snippet}…"` : `"${snippet}"`;
+		return [
+			dim(String(idx + 1)),
+			chalk.cyan(shortId),
+			when,
+			dim(project),
+			chalk.dim(display)
+		];
+	});
+	console.log(renderTable(headers, rows));
+	console.log();
+	const launchHistoryMatch = (match) => {
+		const session = matchToSession(match, allSessions);
+		if (!session) {
+			console.error(err("Could not resolve session for launch (no project path)."));
+			process.exitCode = 1;
+			return;
+		}
+		launchSession(session, allSessions, opts.dryRun ?? false);
+	};
+	if (pickN !== void 0) {
+		const idx = pickN - 1;
+		if (idx >= 0 && idx < matches.length) {
+			launchHistoryMatch(matches[idx]);
+			return;
+		}
+		console.error(err(`Invalid choice: ${pickN}`));
+		process.exitCode = 1;
+		return;
+	}
+	if (opts.auto) {
+		launchHistoryMatch(matches[0]);
+		return;
+	}
+	const choice = await askForChoice(matches.length);
+	if (choice !== null) launchHistoryMatch(matches[choice - 1]);
+}
+
+//#endregion
+export { renderDedupedSessions as a, fetchLiveSessions as c, fmtAge as d, resolveSessionByNameOrId as f, normalizeName as i, revealItermSession as l, main_resolver_exports as n, printExitDir as o, scanSessions as p, buildDeduped as r, callAiBroker as s, cmdMain as t, sendToSession as u };
+//# sourceMappingURL=main-resolver-BfSL8zio.mjs.map