@tekmidian/pai 0.9.16 → 0.10.0

package/dist/cli/index.mjs

@@ -16,7 +16,7 @@ import { t as PaiClient } from "../ipc-client-C3pjwy2m.mjs";
 import { a as expandHome, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, t as CONFIG_DIR } from "../config-DqBY3aT0.mjs";
 import { t as createStorageBackend } from "../factory-BufouUQ1.mjs";
 import { s as kgQuery } from "../kg-entity-DVzTsy6G.mjs";
-import { appendFileSync, chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import chalk from "chalk";
@@ -218,6 +218,117 @@ function findProjectNotesDirs(project) {
 	} catch {}
 	return results;
 }
+const SKIP_DIRS = new Set([
+	".git",
+	"node_modules",
+	".next",
+	".nuxt",
+	"dist",
+	"build",
+	"coverage",
+	".cache",
+	"__pycache__",
+	"vendor",
+	".svn",
+	".hg",
+	"venv",
+	".venv",
+	"target",
+	"Notes"
+]);
+/**
+* Walk `dir` up to `maxDepth` levels deep, collecting all subdirectory paths
+* whose basename matches `targetBasename` (case-insensitive on macOS/case-sensitive
+* on Linux, whichever is appropriate — we use exact case matching to keep it
+* correct and fast).
+*
+* Skips hidden directories and known build/tool dirs.
+* Stops walking a branch if the deadline is exceeded (returns partial results).
+*/
+function walkForBasename(dir, targetBasename, maxDepth, deadline, results) {
+	if (Date.now() > deadline) return;
+	if (maxDepth <= 0) return;
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (Date.now() > deadline) return;
+		if (entry.startsWith(".")) continue;
+		if (SKIP_DIRS.has(entry)) continue;
+		const full = join(dir, entry);
+		let isDir = false;
+		try {
+			isDir = statSync(full).isDirectory();
+		} catch {
+			continue;
+		}
+		if (!isDir) continue;
+		if (entry.toLowerCase() === targetBasename.toLowerCase()) {
+			results.push(full);
+			continue;
+		}
+		walkForBasename(full, targetBasename, maxDepth - 1, deadline, results);
+	}
+}
+/**
+* Try to find where a project has moved.
+*
+* Searches scan_dirs from config (plus a set of common fallback dirs) for a
+* directory whose basename matches the basename of the registered root_path.
+*
+* Returns:
+*   { found: string }   — exactly one match found
+*   { ambiguous: string[] }  — multiple matches found
+*   { found: undefined }     — no match found (or timed out)
+*/
+function findMovedPath(registeredPath) {
+	const targetBasename = basename(registeredPath);
+	const config = loadScanConfig();
+	const deadline = Date.now() + 5e3;
+	const home = homedir();
+	const configDirs = (config.scan_dirs ?? []).map((d) => resolveHome(d));
+	function deepestExistingAncestor(p) {
+		let current = p;
+		while (true) {
+			const parent = join(current, "..");
+			if (parent === current) return null;
+			if (parent === home) return null;
+			if (existsSync(parent)) return parent;
+			current = parent;
+		}
+	}
+	const ancestorRoot = deepestExistingAncestor(registeredPath);
+	const fallbackDirs = [
+		join(home, "dev"),
+		join(home, "Desktop"),
+		join(home, "Projects"),
+		join(home, "Documents"),
+		join(home, "Cloud"),
+		join(home, "Daten", "Cloud"),
+		join(home, "Daten"),
+		join(home, "Library", "Mobile Documents", "com~apple~CloudDocs"),
+		...ancestorRoot ? [ancestorRoot] : []
+	];
+	const searchRoots = [...new Set([...configDirs, ...fallbackDirs])].map((d) => {
+		try {
+			return resolve(d);
+		} catch {
+			return null;
+		}
+	}).filter((d) => d !== null && existsSync(d));
+	const results = [];
+	for (const root of searchRoots) {
+		if (Date.now() > deadline) break;
+		walkForBasename(root, targetBasename, 6, deadline, results);
+	}
+	const unique = [...new Set(results)];
+	if (unique.length === 0) return {};
+	if (unique.length === 1) return { found: unique[0] };
+	return { ambiguous: unique };
+}
 function cmdAdd(db, rawPath, opts) {
 	const rootPath = resolvePath(rawPath);
 	const slug = opts.slug ?? slugFromPath(rootPath);
@@ -272,7 +383,7 @@ function cmdList$3(db, opts) {
 	if (opts.status) {
 		where.push("p.status = ?");
 		params.push(opts.status);
-	}
+	} else if (!opts.all) where.push("p.status = 'active'");
 	if (opts.type) {
 		where.push("p.type = ?");
 		params.push(opts.type);
@@ -310,7 +421,9 @@ function cmdList$3(db, opts) {
 		"Last Active"
 	], tableRows));
 	console.log();
-	console.log(dim(`  ${rows.length} project(s)`));
+	const hiddenCount = db.prepare("SELECT COUNT(*) AS cnt FROM projects").get().cnt - rows.length;
+	if (!opts.all && !opts.status && hiddenCount > 0) console.log(dim(`  ${rows.length} active project(s)  (${hiddenCount} archived — use --all to show)`));
+	else console.log(dim(`  ${rows.length} project(s)`));
 }
 function cmdInfo$1(db, identifier) {
 	const project = resolveIdentifier(db, identifier) ?? requireProject(db, identifier);
@@ -518,6 +631,32 @@ function cmdConsolidate(db, identifier, opts) {
 	console.log();
 	console.log(ok(`  Consolidated ${movedCount} file(s) into ${canonicalNotes}`));
 }
+/**
+* Attempt moved-path recovery for a project whose registered root_path is
+* missing. Updates the DB if exactly one candidate is found.
+*
+* Returns the new path on success, or undefined if ambiguous/not found.
+* Prints all messages to stderr (safe for shell-wrapper stdout capture).
+*/
+function tryRecoverMovedProject(db, project) {
+	process.stderr.write(warn(`Path not found: ${project.root_path}\n`) + dim("  Searching for moved location...\n"));
+	const result = findMovedPath(project.root_path);
+	if (result.found) {
+		const newPath = result.found;
+		const newEncoded = encodeDir(newPath);
+		const ts = now();
+		db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(newPath, newEncoded, ts, project.id);
+		process.stderr.write(ok(`Project moved: ${shortenPath(project.root_path, 50)}\n`) + dim(`  → ${newPath}\n`) + ok("Registry updated.\n"));
+		return newPath;
+	}
+	if (result.ambiguous) {
+		process.stderr.write(warn(`Multiple directories named "${basename(project.root_path)}" found:\n`));
+		for (const candidate of result.ambiguous) process.stderr.write(dim(`  ${candidate}\n`));
+		process.stderr.write(dim(`\n  Disambiguate with: pai projects rebind ${project.slug} <path>\n`));
+		return;
+	}
+	process.stderr.write(err(`Project "${project.slug}" root_path "${project.root_path}" does not exist on disk\n  and no folder named "${basename(project.root_path)}" was found in scan dirs.\n`) + dim(`  Fix with: pai projects rebind ${project.slug} <new-path>\n`));
+}
 function cmdGo(db, query) {
 	const all = db.prepare("SELECT * FROM projects WHERE status = 'active' ORDER BY updated_at DESC").all();
 	if (!all.length) {
@@ -527,12 +666,31 @@ function cmdGo(db, query) {
 	const q = query.trim().toLowerCase();
 	const exact = getProject$2(db, query);
 	if (exact) {
+		if (!existsSync(exact.root_path)) {
+			const recovered = tryRecoverMovedProject(db, exact);
+			if (!recovered) {
+				process.exitCode = 1;
+				return;
+			}
+			process.stdout.write(recovered + "\n");
+			return;
+		}
 		process.stdout.write(exact.root_path + "\n");
 		return;
 	}
 	const partial = all.filter((p) => containsIgnoreCase(p.slug, q) || containsIgnoreCase(p.display_name, q) || containsIgnoreCase(basename(p.root_path), q));
 	if (partial.length === 1) {
-		process.stdout.write(partial[0].root_path + "\n");
+		const p = partial[0];
+		if (!existsSync(p.root_path)) {
+			const recovered = tryRecoverMovedProject(db, p);
+			if (!recovered) {
+				process.exitCode = 1;
+				return;
+			}
+			process.stdout.write(recovered + "\n");
+			return;
+		}
+		process.stdout.write(p.root_path + "\n");
 		return;
 	}
 	if (partial.length > 1) {
@@ -563,6 +721,34 @@ function cmdGo(db, query) {
 	}
 	process.exit(1);
 }
+function cmdRebind(db, slug, newPath) {
+	const project = requireProject(db, slug);
+	const resolved = resolve(newPath.startsWith("~/") ? join(homedir(), newPath.slice(2)) : newPath);
+	if (!existsSync(resolved)) {
+		console.error(err(`Path does not exist: ${resolved}`));
+		process.exit(1);
+	}
+	let isDir = false;
+	try {
+		isDir = statSync(resolved).isDirectory();
+	} catch {}
+	if (!isDir) {
+		console.error(err(`Path is not a directory: ${resolved}`));
+		process.exit(1);
+	}
+	const newEncoded = encodeDir(resolved);
+	const conflict = db.prepare("SELECT slug FROM projects WHERE encoded_dir = ? AND id != ?").get(newEncoded, project.id);
+	if (conflict) {
+		console.error(err(`Path is already registered to project: ${bold(conflict.slug)}\n`) + dim(`  ${resolved}\n`) + dim(`  Archive or move that project first, or choose a different path.`));
+		process.exit(1);
+	}
+	const ts = now();
+	db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(resolved, newEncoded, ts, project.id);
+	console.log(ok(`Rebound: ${bold(slug)}`));
+	console.log(dim(`  Old path: ${project.root_path}`));
+	console.log(dim(`  New path: ${resolved}`));
+	console.log(dim(`  Encoded:  ${newEncoded}`));
+}
 
 //#endregion
 //#region src/cli/commands/project/session-config.ts
@@ -1099,16 +1285,41 @@ function cmdHealth$1(db, opts) {
 //#endregion
 //#region src/cli/commands/project/projects-index.ts
 function registerProjectsCommands(projectsCmd, getDb) {
-	projectsCmd.command("list", { isDefault: true }).description("List registered projects. Short form: pai projects (bare, no subcommand)").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
+	projectsCmd.command("list", { isDefault: true }).description("List registered projects. Short form: pai projects (bare, no subcommand)\nDefault: active projects only. Use --all to include archived.").option("--all", "Include archived projects (default: active only)").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
 		cmdList$3(getDb(), opts);
 	});
-	projectsCmd.command("cd <identifier>").description("cd to a project directory. Short form: pai cd <name>\n(The shell wrapper handles the actual cd; pure output here.)").action((identifier) => {
-		const project = resolveIdentifier(getDb(), identifier);
+	projectsCmd.command("cd <identifier>").description("cd to a project directory. Short form: pai cd <name>\n(The shell wrapper handles the actual cd; pure output here.)\nAuto-detects moved projects when the registered path no longer exists.").action((identifier) => {
+		const db = getDb();
+		const project = resolveIdentifier(db, identifier);
 		if (!project) {
 			console.error(`Project not found: ${identifier}`);
 			process.exit(1);
+			return;
 		}
-		process.stdout.write(project.root_path + "\n");
+		if (existsSync(project.root_path)) {
+			process.stdout.write(project.root_path + "\n");
+			return;
+		}
+		process.stderr.write(warn(`Path not found: ${project.root_path}\n`) + dim("  Searching for moved location...\n"));
+		const result = findMovedPath(project.root_path);
+		if (result.found) {
+			const newPath = result.found;
+			const newEncoded = encodeDir(newPath);
+			const ts = now();
+			db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(newPath, newEncoded, ts, project.id);
+			process.stderr.write(ok(`Project moved: ${shortenPath(project.root_path, 50)}\n`) + dim(`  → ${newPath}\n`) + ok("Registry updated.\n"));
+			process.stdout.write(newPath + "\n");
+			return;
+		}
+		if (result.ambiguous) {
+			process.stderr.write(warn(`Multiple directories named "${basename(project.root_path)}" found:\n`));
+			for (const candidate of result.ambiguous) process.stderr.write(dim(`  ${candidate}\n`));
+			process.stderr.write(dim(`\n  Disambiguate with: pai projects rebind ${project.slug} <path>\n`));
+			process.exitCode = 1;
+			return;
+		}
+		process.stderr.write(err(`Project "${project.slug}" root_path "${project.root_path}" does not exist on disk\n  and no folder named "${basename(project.root_path)}" was found in scan dirs.\n`) + dim(`  Fix with: pai projects rebind ${project.slug} <new-path>\n`));
+		process.exitCode = 1;
 	});
 	projectsCmd.command("add <path>").description("Register a project directory in the PAI registry").option("--slug <slug>", "Override auto-generated slug").option("--type <type>", "Project type: local | central | obsidian-linked | external", "local").option("--display-name <name>", "Human-readable display name").action((rawPath, opts) => {
 		cmdAdd(getDb(), rawPath, opts);
@@ -1125,6 +1336,9 @@ function registerProjectsCommands(projectsCmd, getDb) {
 	projectsCmd.command("move <slug> <new-path>").description("Update the root path for a project").action((slug, newPath) => {
 		cmdMove(getDb(), slug, newPath);
 	});
+	projectsCmd.command("rebind <slug> <new-path>").description("Manually update the root_path for a project (for when auto-detect found multiple matches).\nValidates the new path exists and is a directory, then updates the registry.").action((slug, newPath) => {
+		cmdRebind(getDb(), slug, newPath);
+	});
 	projectsCmd.command("tag <slug> <tags...>").description("Add one or more tags to a project").action((slug, tags) => {
 		cmdTag$1(getDb(), slug, tags);
 	});
@@ -2309,6 +2523,81 @@ function fmtAge(mtime) {
 	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.
@@ -2316,7 +2605,8 @@ function fmtAge(mtime) {
 * Priority:
 *  1. Exact case-insensitive match on friendlyName
 *  2. Partial case-insensitive match (contains)
-*  3. UUID prefix match
+*  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();
@@ -2343,7 +2633,18 @@ function resolveSessionByNameOrId(sessions, query) {
 		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.`);
 	}
-	throw new Error(`No session found matching "${query}".\n\nRun: pai sessions          to list sessions.\nRun: pai sessions --all    to include transcript-only sessions.`);
+	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
@@ -2425,12 +2726,15 @@ function callAiBroker(method, params = {}, timeoutMs = 8e3) {
 	});
 }
 /**
-* Fetch all live iTerm2 sessions from AIBroker.
+* 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("session_content", { lineCount: 0 })).sessions;
+		const sessions = (await callAiBroker("sessions", {})).sessions;
 		if (!Array.isArray(sessions)) return [];
 		return sessions;
 	} catch {
@@ -2470,37 +2774,39 @@ function fmtStatus(status) {
 		case "orphan": return chalk.dim("orphan");
 	}
 }
-function renderLiveSessions(allLiveSessions) {
-	const claudeSessions = allLiveSessions.filter((s) => s.paiName !== null && s.paiName !== void 0 && s.paiName !== "");
-	const skippedCount = allLiveSessions.length - claudeSessions.length;
-	if (claudeSessions.length === 0) return;
+function renderLiveSessions(allLiveSessions, allTabs) {
+	const displayed = allTabs ? allLiveSessions : allLiveSessions.filter((s) => s.kind !== "shell");
+	const skippedCount = allLiveSessions.length - displayed.length;
+	if (displayed.length === 0) return;
 	console.log("\n" + header("Live Sessions") + "\n");
 	const liveHeaders = [
 		"#",
-		"iTerm2 id",
+		"id",
 		"name",
 		"at prompt",
-		"paiName"
+		"kind"
 	];
-	const liveRows = claudeSessions.map((s, idx) => {
+	const liveRows = displayed.map((s, idx) => {
 		const shortId = s.sessionId.slice(0, 8);
-		const name = s.name.length > 32 ? s.name.slice(0, 31) + "…" : s.name;
-		const paiName = s.paiName.length > 20 ? s.paiName.slice(0, 19) + "…" : s.paiName;
+		const rawName = s.paiName ?? s.name;
+		const name = rawName.length > 36 ? rawName.slice(0, 35) + "…" : rawName;
 		const atPrompt = s.atPrompt ? chalk.green("yes") : chalk.yellow("busy");
+		const kind = s.kind === "claude" ? chalk.cyan(s.kind) : chalk.dim(s.kind);
 		return [
 			chalk.dim(String(idx + 1)),
 			chalk.cyan(shortId),
 			name,
 			atPrompt,
-			paiName
+			kind
 		];
 	});
 	console.log(renderTable(liveHeaders, liveRows));
-	if (skippedCount > 0) console.log(dim(`  (${skippedCount} non-Claude tab${skippedCount === 1 ? "" : "s"} hidden — use pai pause all to see full list)`));
+	if (skippedCount > 0) console.log(dim(`  (${skippedCount} shell tab${skippedCount === 1 ? "" : "s"} hidden — use --all-tabs to show)`));
 }
 async function cmdRecent(db, opts) {
 	const limit = parseInt(opts.n ?? "20", 10);
 	const includeAll = opts.all === true;
+	const allTabs = opts.allTabs === true;
 	const liveSessions = await fetchLiveSessions();
 	const sessions = scanSessions(db, {
 		limit,
@@ -2509,10 +2815,13 @@ async function cmdRecent(db, opts) {
 	if (opts.json) {
 		const output = {
 			live: liveSessions.map((s) => ({
+				index: s.index,
 				sessionId: s.sessionId,
 				name: s.name,
-				paiName: s.paiName ?? null,
-				atPrompt: s.atPrompt
+				paiName: s.paiName,
+				atPrompt: s.atPrompt,
+				kind: s.kind,
+				active: s.active
 			})),
 			paused: sessions.map((s, idx) => ({
 				idx: idx + 1,
@@ -2533,8 +2842,8 @@ async function cmdRecent(db, opts) {
 		console.log(JSON.stringify(output, null, 2));
 		return;
 	}
-	const hasClaudeLive = liveSessions.some((s) => s.paiName !== null && s.paiName !== void 0 && s.paiName !== "");
-	if (liveSessions.length > 0) renderLiveSessions(liveSessions);
+	const hasClaudeLive = liveSessions.some((s) => s.kind === "claude");
+	if (liveSessions.length > 0) renderLiveSessions(liveSessions, allTabs);
 	if (sessions.length === 0) {
 		if (!hasClaudeLive) if (includeAll) console.log(err("No sessions found in ~/.claude/projects/."));
 		else console.log(err("No named sessions found.\n\n  Named sessions appear when you have entries in ~/.claude/session.json\n  (set via /Name inside Claude Code) or resumable top-level jsonl files.\n  Run: pai session recent --all  to list all sessions including unnamed orphans."));
@@ -2577,7 +2886,7 @@ async function cmdRecent(db, opts) {
 * Returns ok=true if the session is resumable (exit 0 and no "No conversation found"
 * in stderr).  Timeout: 5 seconds.
 */
-function probeResume(uuid, cwd) {
+function probeResume$1(uuid, cwd) {
 	const result = spawnSync("claude", [
 		"--resume",
 		uuid,
@@ -2618,7 +2927,9 @@ function cmdGoto(db, query, opts) {
 	try {
 		resolved = resolveSessionByNameOrId(allSessions, query);
 	} catch (resolveErr) {
-		console.error(err(String(resolveErr).replace(/^Error: /, "")));
+		let msg = String(resolveErr).replace(/^Error: /, "");
+		if (msg.includes("No session found matching")) msg += `\n\nTip: pai find "${query}"  — search prompt history by keywords`;
+		console.error(err(msg));
 		process.exit(1);
 	}
 	const { session: matchedSession, friendlyName } = resolved;
@@ -2670,7 +2981,7 @@ function cmdGoto(db, query, opts) {
 		return;
 	}
 	if (resumableUuid) {
-		const probe = probeResume(resumableUuid, projectDir);
+		const probe = probeResume$1(resumableUuid, projectDir);
 		if (probe.ok) {
 			const result = spawnSync("claude", [
 				"--resume",
@@ -3006,7 +3317,7 @@ async function cmdPauseAll(opts) {
 		process.exitCode = 1;
 		return;
 	}
-	const claudeSessions = liveSessions.filter((s) => s.paiName !== null && s.paiName !== void 0 && s.paiName !== "");
+	const claudeSessions = liveSessions.filter((s) => s.kind === "claude");
 	const skipped = liveSessions.length - claudeSessions.length;
 	if (skipped > 0) process.stderr.write(`Skipping ${skipped} non-Claude tab${skipped === 1 ? "" : "s"} (bare shells).\n`);
 	if (claudeSessions.length === 0) {
@@ -3067,7 +3378,7 @@ async function cmdPauseAll(opts) {
 	else {
 		console.log(warn(`${succeeded}/${total} session(s) paused. `) + err(`${failed} failed.`));
 		for (const r of results.filter((r) => !r.pauseOk)) {
-			const label = r.session.paiName ?? r.session.name;
+			const label = r.session.paiName ?? r.session.name ?? r.session.sessionId.slice(0, 8);
 			console.log(err(`  ${label}: ${r.error ?? "unknown error"}`));
 		}
 	}
@@ -3081,7 +3392,7 @@ async function cmdPauseAll(opts) {
 //#endregion
 //#region src/cli/commands/session/sessions-index.ts
 function registerSessionsCommands(sessionsCmd, getDb) {
-	sessionsCmd.command("list", { isDefault: true }).description("Resumable sessions catalog — named sessions with resume status.\nShort form: pai sessions (bare, no subcommand)\nUse --all to also show unnamed orphan sessions.").option("-n <count>", "Maximum sessions to show (default: 20)", "20").option("--all", "Include unnamed orphan sessions (not in clc registry)").option("--json", "Output raw JSON instead of formatted table").action(async (opts) => {
+	sessionsCmd.command("list", { isDefault: true }).description("Resumable sessions catalog — named sessions with resume status.\nShort form: pai sessions (bare, no subcommand)\nUse --all to also show unnamed orphan sessions.").option("-n <count>", "Maximum sessions to show (default: 20)", "20").option("--all", "Include unnamed orphan sessions (not in clc registry)").option("--all-tabs", "Show all iTerm2 tabs in Live Sessions, including bare shells").option("--json", "Output raw JSON instead of formatted table").action(async (opts) => {
 		await cmdRecent(getDb(), opts);
 	});
 	sessionsCmd.command("goto <name-or-id>").description("Go to a session: resume if a resumable snapshot exists, start fresh otherwise.\nRecommended short form: pai resume <name>\nResolves by clc/registry name (case-insensitive) or UUID prefix.").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((nameOrId, opts) => {
@@ -7736,7 +8047,7 @@ function typeColor(type) {
 		default: return chalk.white(type);
 	}
 }
-function fmtTs(ts) {
+function fmtTs$2(ts) {
 	if (!ts) return dim("—");
 	try {
 		const d = new Date(ts);
@@ -7790,7 +8101,7 @@ async function cmdList$1(opts) {
 		const typeStr = typeColor(obs.type ?? "").padEnd(TYPE_W + (typeColor(obs.type ?? "").length - (obs.type ?? "").length));
 		const titleStr = trunc(obs.title ?? "", TITLE_W).padEnd(TITLE_W);
 		const projStr = trunc(obs.project_slug ?? "—", PROJ_W).padEnd(PROJ_W);
-		const tsStr = fmtTs(obs.created_at);
+		const tsStr = fmtTs$2(obs.created_at);
 		console.log(`  ${idStr}  ${typeStr}  ${titleStr}  ${projStr}  ${dim(tsStr)}`);
 	}
 	console.log();
@@ -7834,7 +8145,7 @@ async function cmdSearch(query, opts) {
 		const type = typeColor(obs.type ?? "");
 		const title = bold(obs.title ?? "(untitled)");
 		const proj = obs.project_slug ? dim(`[${obs.project_slug}]`) : dim("[—]");
-		const ts = dim(fmtTs(obs.created_at));
+		const ts = dim(fmtTs$2(obs.created_at));
 		const id = dim(`#${obs.id}`);
 		console.log(`  ${idx}  ${type.padEnd(12)}  ${title}`);
 		console.log(`           ${proj}  ${ts}  ${id}`);
@@ -7860,7 +8171,7 @@ async function cmdStats$1() {
 	console.log(header("  PAI Observation Statistics"));
 	console.log();
 	console.log(`  ${bold("Total observations:")}  ${chalk.cyan(String(stats.total ?? 0))}`);
-	if (stats.most_recent) console.log(`  ${bold("Most recent:")}         ${dim(fmtTs(stats.most_recent))}`);
+	if (stats.most_recent) console.log(`  ${bold("Most recent:")}         ${dim(fmtTs$2(stats.most_recent))}`);
 	console.log();
 	if (stats.by_type && stats.by_type.length > 0) {
 		console.log(bold("  By type:"));
@@ -9030,23 +9341,597 @@ function registerDbCommands(dbCmd) {
 	});
 }
 
+//#endregion
+//#region src/cli/commands/find.ts
+/**
+* pai find <query> [--n=20] [--json]
+*
+* Content-based search across ~/.claude/history.jsonl.
+* Finds user prompts matching the query (case-insensitive substring),
+* groups by sessionId, sorts by most-recent match, and shows a table
+* with short UUID, date, project path, and the matching prompt snippet.
+*
+* The sessionId from history.jsonl is the same UUID used by claude --resume,
+* so rows are directly resumable via: pai resume <id>
+*
+* Note: older history.jsonl entries (before Claude Code ~2.0) may lack a
+* sessionId field. These are grouped under a synthetic "no-session" bucket
+* and shown in a separate note at the bottom.
+*/
+const HISTORY_FILE$1 = join(homedir(), ".claude", "history.jsonl");
+function shortenProject$1(p, maxLen = 42) {
+	if (p.length <= maxLen) return p;
+	return "…" + p.slice(-(maxLen - 1));
+}
+function fmtTs$1(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())}`;
+}
+async function searchHistory$1(query, maxResults) {
+	if (!existsSync(HISTORY_FILE$1)) return [];
+	const queryLower = query.toLowerCase();
+	const bySession = /* @__PURE__ */ new Map();
+	const noSession = {
+		sessionId: null,
+		lastMatchTs: 0,
+		lastMatchDisplay: "",
+		project: "",
+		matchCount: 0
+	};
+	const rl = createInterface({
+		input: createReadStream(HISTORY_FILE$1, { 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) {
+			if (ts > noSession.lastMatchTs) {
+				noSession.lastMatchTs = ts;
+				noSession.lastMatchDisplay = display;
+				noSession.project = project;
+			}
+			noSession.matchCount++;
+			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);
+}
+async function cmdFind(query, opts) {
+	const maxResults = parseInt(opts.n ?? "20", 10);
+	if (!existsSync(HISTORY_FILE$1)) {
+		console.error(err(`~/.claude/history.jsonl not found.`));
+		process.exitCode = 1;
+		return;
+	}
+	const matches = await searchHistory$1(query, maxResults);
+	if (opts.json) {
+		console.log(JSON.stringify(matches, null, 2));
+		return;
+	}
+	if (matches.length === 0) {
+		console.log(warn(`No sessions found matching "${query}" in ~/.claude/history.jsonl.`));
+		console.log(dim(`  Try a shorter or different search term.`));
+		return;
+	}
+	console.log("\n" + header("Session Search Results") + "\n");
+	console.log(dim(`  Query: "${query}"  (${matches.length} session(s) with matching prompts)\n`));
+	const headers = [
+		"#",
+		"id",
+		"when",
+		"project",
+		"last matching prompt"
+	];
+	const rows = matches.map((m, idx) => {
+		const shortId = (m.sessionId ?? "no-session").slice(0, 8);
+		const when = m.lastMatchTs > 0 ? fmtTs$1(m.lastMatchTs) : dim("—");
+		const project = shortenProject$1(m.project || dim("—"));
+		const snippet = m.lastMatchDisplay.replace(/\n+/g, " ").trim().slice(0, 48);
+		const display = snippet.length < m.lastMatchDisplay.replace(/\n+/g, " ").trim().length ? `"${snippet}…"` : `"${snippet}"`;
+		return [
+			dim(String(idx + 1)),
+			chalk.cyan(shortId),
+			when,
+			dim(project),
+			chalk.dim(display)
+		];
+	});
+	console.log(renderTable(headers, rows));
+	console.log();
+	console.log(dim("  Resume: ") + chalk.white("pai resume <id>"));
+	console.log();
+}
+
+//#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/commands/main-resolver.ts
+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 };
+}
+/**
+* Launch Claude for the given session. Handles resume probe + fallback to fresh.
+* Never returns on success (process.exit inside spawnSync block).
+*/
+function launchSession(session, allSessions, dryRun) {
+	let resumableUuid;
+	let resumableSession;
+	if (session.resumable) {
+		resumableUuid = session.uuid;
+		resumableSession = session;
+	} 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) {
+			resumableSession = sameProject[0];
+			resumableUuid = resumableSession.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);
+			}
+			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);
+			}
+			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);
+		}
+		process.exit(result.status ?? 0);
+	}
+}
+/**
+* Given a SessionMatch from history search, find the corresponding ScannedSession
+* (for launch). Falls back to a minimal synthetic session using the decodedPath
+* from the history entry's project field.
+*/
+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 cmdMain(db, query, pickN, opts) {
+	const maxResults = parseInt(opts.n ?? "20", 10);
+	const allSessions = scanSessions(db, {
+		limit: 500,
+		filter: "named"
+	});
+	if (!query) {
+		let liveSessions = [];
+		try {
+			liveSessions = await fetchLiveSessions();
+		} catch {}
+		const claudeLive = liveSessions.filter((s) => s.kind !== "shell");
+		const recentDisk = allSessions.slice(0, maxResults);
+		if (claudeLive.length === 0 && recentDisk.length === 0) {
+			console.log(warn("No sessions found. Start Claude Code in a project directory first."));
+			return;
+		}
+		if (claudeLive.length > 0) {
+			console.log("\n" + header("Live Sessions") + "\n");
+			const liveHeaders = [
+				"#",
+				"id",
+				"name",
+				"at prompt"
+			];
+			const liveRows = claudeLive.map((s, i) => [
+				dim(String(i + 1)),
+				chalk.cyan(s.sessionId.slice(0, 8)),
+				s.paiName ?? s.name ?? dim("—"),
+				s.atPrompt ? chalk.green("yes") : chalk.dim("no")
+			]);
+			console.log(renderTable(liveHeaders, liveRows));
+		}
+		if (recentDisk.length > 0) {
+			console.log("\n" + header("Recent Sessions") + "\n");
+			const diskHeaders = [
+				"#",
+				"id",
+				"age",
+				"project",
+				"last prompt"
+			];
+			const diskRows = recentDisk.map((s, i) => {
+				const snippet = s.lastUserPrompt.replace(/\n+/g, " ").trim().slice(0, 40);
+				return [
+					dim(String(i + 1)),
+					chalk.cyan(s.shortId),
+					dim(fmtAge(s.mtime)),
+					dim(shortenProject(s.friendlyName ?? s.decodedPath, 30)),
+					chalk.dim(snippet ? `"${snippet}"` : "—")
+				];
+			});
+			console.log(renderTable(diskHeaders, diskRows));
+		}
+		console.log();
+		console.log(dim("  Resume a session: ") + chalk.white("pai <topic>") + dim("  or  ") + chalk.white("pai <id>"));
+		console.log();
+		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;
+		}
+	}
+	{
+		const qLower = query.toLowerCase();
+		const byExact = allSessions.filter((s) => s.friendlyName && s.friendlyName.toLowerCase() === qLower);
+		if (byExact.length >= 1) {
+			launchSession(byExact[0], allSessions, opts.dryRun ?? false);
+			return;
+		}
+		const byPartial = allSessions.filter((s) => s.friendlyName && s.friendlyName.toLowerCase().includes(qLower));
+		if (byPartial.length === 1) {
+			launchSession(byPartial[0], allSessions, opts.dryRun ?? false);
+			return;
+		}
+		if (byPartial.length > 1) {
+			console.log("\n" + header(`Sessions matching "${query}"`) + "\n");
+			const headers = [
+				"#",
+				"id",
+				"age",
+				"name",
+				"project"
+			];
+			const rows = byPartial.slice(0, maxResults).map((s, i) => [
+				dim(String(i + 1)),
+				chalk.cyan(s.shortId),
+				dim(fmtAge(s.mtime)),
+				s.friendlyName ?? dim("—"),
+				dim(shortenProject(s.decodedPath, 36))
+			]);
+			console.log(renderTable(headers, rows));
+			console.log();
+			if (pickN !== void 0) {
+				const idx = pickN - 1;
+				if (idx >= 0 && idx < byPartial.length) {
+					launchSession(byPartial[idx], allSessions, opts.dryRun ?? false);
+					return;
+				}
+				console.error(err(`Invalid choice: ${pickN}`));
+				process.exitCode = 1;
+				return;
+			}
+			if (opts.auto) {
+				launchSession(byPartial[0], allSessions, opts.dryRun ?? false);
+				return;
+			}
+			const choice = await askForChoice(Math.min(byPartial.length, maxResults));
+			if (choice !== null) launchSession(byPartial[choice - 1], allSessions, opts.dryRun ?? false);
+			return;
+		}
+	}
+	if (!existsSync(HISTORY_FILE)) {
+		console.error(err("~/.claude/history.jsonl not found."));
+		console.error(dim("  No prompt history available for search."));
+		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 recent 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();
+	if (pickN !== void 0) {
+		const idx = pickN - 1;
+		if (idx >= 0 && idx < matches.length) {
+			const session = matchToSession(matches[idx], 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);
+			return;
+		}
+		console.error(err(`Invalid choice: ${pickN}`));
+		process.exitCode = 1;
+		return;
+	}
+	if (opts.auto) {
+		const session = matchToSession(matches[0], 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);
+		return;
+	}
+	const choice = await askForChoice(matches.length);
+	if (choice !== null) {
+		const session = matchToSession(matches[choice - 1], 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);
+	}
+}
+
 //#endregion
 //#region src/cli/index.ts
 /**
-* PAI Knowledge OS — CLI entry point
+* PAI Knowledge OS — CLI entry point (v0.10.0 topic-first redesign)
 *
-* Command tree:
-*   pai sessions list|goto|pause|info|rename|...  (canonical plural namespace)
-*   pai projects list|cd|add|info|...             (canonical plural namespace)
-*   pai registry scan|migrate|stats|rebuild
-*   pai memory   index|search|status
-*   pai search   <query>   (placeholder — Phase 3)
-*   pai update
-*   pai version
+* Top-level surface:
+*   pai                    → recent sessions picker
+*   pai <topic>            → history search + candidate picker + launch
+*   pai <uuid-prefix>      → direct session resume via filesystem scan
+*   pai cd <name>          → cd to project directory (no Claude launch)
+*   pai pause [all]        → save state (or mass-pause every live session)
+*   pai end                → finalize session
 *
-* Daily verb shortcuts (top-level):
-*   pai pause / pai end / pai resume / pai cd
-*   pai sessions / pai projects / pai notes
+* Power-user namespaces (still accessible, hidden from main help):
+*   pai sessions ...       → full session management
+*   pai projects ...       → project management
+*   pai registry ...       → registry maintenance
+*   pai memory ...         → memory engine
 */
 function getVersion() {
 	try {
@@ -9068,20 +9953,23 @@ function getDb() {
 }
 const program = new Command();
 program.name("pai").description("PAI Knowledge OS — Personal AI Infrastructure CLI").version(getVersion(), "-V, --version", "Print version and exit").addHelpText("after", `
-Daily verbs (short forms):
-  pai pause               Save state + display safe-exit reminder
-  pai end                 Finalize session: pause + mark note Completed
-  pai resume <name>       Go to a session (resume or start fresh)
-  pai cd <name>           cd to a project directory
+Usage:
+  pai                     Show recent sessions (interactive picker)
+  pai <topic>             Find sessions by topic and launch the chosen one
+  pai <uuid-prefix>       Resume a specific session by UUID
+  pai cd <name>           cd to a project directory (no Claude launch)
+  pai pause [all]         Save state (or mass-pause every live session)
+  pai end                 Finalize session: save state + mark note Completed
 
-Listings:
-  pai sessions            Resumable sessions catalog
-  pai projects            Known project directories
-  pai notes               Markdown session notes
+Examples:
+  pai mdf                 Find all sessions where you worked on MDF
+  pai solar panels        Free-text search across your prompt history
+  pai 81c5c3dc            Resume session by UUID prefix
+  pai                     See the 20 most recent sessions
 
-Subcommands (power users):
-  pai sessions ...        Session management (list, goto, pause, end, ...)
-  pai projects ...        Project management (cd, list, ...)
+Power-user namespaces (run "pai sessions --help" etc. for details):
+  pai sessions ...        Full session management (list, goto, info, ...)
+  pai projects ...        Project management (cd, rebind, list, ...)
   pai registry ...        Registry maintenance (scan, ...)
   pai memory ...          Memory engine (index, search, ...)
 
@@ -9106,9 +9994,6 @@ registerDbCommands(program.command("db").description("Database inspection: query
 registerObsidianCommands(program.command("obsidian").description("Obsidian vault: sync project notes, view status, open in Obsidian"), getDb);
 registerZettelCommands(program.command("zettel").description("Zettelkasten intelligence: explore, surprise, converse, themes, health, suggest"), getDb);
 registerObservationCommands(program.command("observation").description("Observation capture: list, search, and stats"));
-program.command("go <query>").description("Jump to a project directory by slug or partial name.\nPrints the root path to stdout — use with: cd $(pai go <query>)\nExample shell function in ~/.zshrc:\n  pcd() { cd \"$(pai go \"$@\")\" }").action((query) => {
-	cmdGo(getDb(), query);
-});
 program.command("pause [target]").description("Save state and display safe-exit instructions for the current session.\nWrites a ## Continue checkpoint to the project's TODO.md.\nUse `pai pause all` to pause every live session via AIBroker.\nLong form: pai sessions pause").option("--dry-run", "Preview changes without writing them").option("--exit", "(pause all only) Also send /exit to each session after pausing").option("--wait <ms>", "(pause all only) Milliseconds to wait before /exit (default: 5000)", "5000").action(async (target, opts) => {
 	if (target === "all") await cmdPauseAll({
 		exit: opts.exit,
@@ -9127,22 +10012,50 @@ program.command("pause [target]").description("Save state and display safe-exit
 program.command("end").description("Finalize a session: save state, mark note Completed, display safe-exit instructions.\nLong form: pai sessions end").option("--dry-run", "Preview all changes without writing them").action((opts) => {
 	cmdEnd(getDb(), opts);
 });
-program.command("resume <name>").description("Go to a session by name: resume if resumable, start fresh otherwise.\nLong form: pai sessions goto <name>").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((name, opts) => {
+program.command("resume <name>").description("Go to a session by name or UUID: resume if resumable, start fresh otherwise.\nAlso: pai <name>  (shorter)  |  pai sessions goto <name>  (long form)").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((name, opts) => {
 	cmdGoto(getDb(), name, { dryRun: opts.dryRun });
 });
-program.command("cd <identifier>").description("cd to a project directory (shell wrapper handles the actual cd).\nLong form: pai projects cd <identifier>\nThe shell function installed by pai shell-init intercepts this command\nand calls builtin cd with the resolved path.").action((identifier) => {
-	const project = resolveIdentifier(getDb(), identifier);
+program.command("cd <identifier>").description("cd to a project directory (shell wrapper handles the actual cd).\nLong form: pai projects cd <identifier>\nThe shell function installed by pai shell-init intercepts this command\nand calls builtin cd with the resolved path.\nAuto-detects moved projects when the registered path no longer exists.").action((identifier) => {
+	const db = getDb();
+	const project = resolveIdentifier(db, identifier);
 	if (!project) {
 		console.error(`Project not found: ${identifier}`);
 		process.exit(1);
+		return;
+	}
+	if (existsSync(project.root_path)) {
+		process.stdout.write(project.root_path + "\n");
+		return;
 	}
-	process.stdout.write(project.root_path + "\n");
+	process.stderr.write(warn(`Path not found: ${project.root_path}\n`) + dim("  Searching for moved location...\n"));
+	const result = findMovedPath(project.root_path);
+	if (result.found) {
+		const newPath = result.found;
+		const newEncoded = encodeDir(newPath);
+		const ts = now();
+		db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(newPath, newEncoded, ts, project.id);
+		process.stderr.write(ok(`Project moved: ${shortenPath(project.root_path, 50)}\n`) + dim(`  → ${newPath}\n`) + ok("Registry updated.\n"));
+		process.stdout.write(newPath + "\n");
+		return;
+	}
+	if (result.ambiguous) {
+		process.stderr.write(warn(`Multiple directories named "${basename(project.root_path)}" found:\n`));
+		for (const candidate of result.ambiguous) process.stderr.write(dim(`  ${candidate}\n`));
+		process.stderr.write(dim(`\n  Disambiguate with: pai projects rebind ${project.slug} <path>\n`));
+		process.exitCode = 1;
+		return;
+	}
+	process.stderr.write(err(`Project "${project.slug}" root_path "${project.root_path}" does not exist on disk\n  and no folder named "${basename(project.root_path)}" was found in scan dirs.\n`) + dim(`  Fix with: pai projects rebind ${project.slug} <new-path>\n`));
+	process.exitCode = 1;
 });
 program.command("notes [project-slug]").description("Markdown session notes — list notes, optionally filtered to a project.").option("--limit <n>", "Maximum number of notes to show", "20").option("--status <status>", "Filter by status: open | completed | compacted").action((projectSlug, opts) => {
 	cmdList$2(getDb(), projectSlug, opts);
 }).command("list [project-slug]").description("List markdown session notes (same as: pai notes)").option("--limit <n>", "Maximum number of notes to show", "20").option("--status <status>", "Filter by status: open | completed | compacted").action((projectSlug, opts) => {
 	cmdList$2(getDb(), projectSlug, opts);
 });
+program.command("find <query>").description("Search prompt history for matching sessions.\nSame as: pai <query>  (the default command does history search too)").option("-n, --n <count>", "Maximum number of sessions to show", "20").option("--json", "Output as JSON array").action(async (query, opts) => {
+	await cmdFind(query, opts);
+});
 program.command("shell-init").description("Emit shell integration code. Add to ~/.zshrc:\n  eval \"$(pai shell-init)\"").action(() => {
 	process.stdout.write(`# PAI shell integration — generated by: pai shell-init
 pai() {
@@ -9170,8 +10083,12 @@ pai() {
 }
 `);
 });
-program.command("search <query>").description("Full-text search across sessions and notes (Phase 3)").option("--projects <p1,p2>", "Restrict search to these project slugs (comma-separated)").option("--limit <n>", "Maximum results to return", "10").action((query, opts) => {
-	console.log(`\n  Search is coming in Phase 3.\n\n  Query:    ${query}\n  Projects: ${opts.projects ?? "(all)"}\n  Limit:    ${opts.limit ?? 10}\n`);
+program.command("query [query] [pick]", {
+	isDefault: true,
+	hidden: true
+}).description("Find and launch a session by topic, name, or UUID.\nNo arg → recent sessions picker\nTopic  → history search → candidate list → pick #\nUUID   → direct resume via filesystem scan").option("-y, --auto", "Auto-pick #1 without prompting").option("--dry-run", "Print what would happen without launching").option("-n, --n <count>", "Max candidates for history search", "20").action(async (query, pick, opts) => {
+	const pickN = pick !== void 0 ? parseInt(pick, 10) : void 0;
+	await cmdMain(getDb(), query, pickN, opts);
 });
 program.configureOutput({ writeErr: (str) => process.stderr.write(err(str)) });
 program.exitOverride((error) => {
@@ -9181,7 +10098,6 @@ program.exitOverride((error) => {
 	process.exit(1);
 });
 program.parse(process.argv);
-if (process.argv.length <= 2) program.help();
 
 //#endregion
 export {  };