@tekmidian/pai 0.9.13 → 0.9.14

package/dist/cli/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { n as openRegistry } from "../db-BtuN768f.mjs";
-import { _ as warn, a as fmtDate, c as ok, d as scaffoldProjectDirs, f as shortenPath, i as err, l as renderTable, m as slugify, n as dim, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold, u as resolvePath } from "../utils-QSfKagcj.mjs";
-import { a as slugify$1, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "../migrate-jokLenje.mjs";
-import { n as ensurePaiMarker, t as discoverPaiMarkers } from "../pai-marker-CXQPX2P6.mjs";
+import { _ as warn, a as fmtDate, c as ok, d as scaffoldProjectDirs, f as shortenPath, h as smartDecodeDir, i as err, l as renderTable, m as slugify, n as dim, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold, u as resolvePath } from "../utils-BAxjW3j8.mjs";
+import { a as slugify$1, i as parseSessionFilename } from "../migrate-fLD6rAdO.mjs";
+import { n as ensurePaiMarker } from "../pai-marker-CXQPX2P6.mjs";
 import { n as openFederation } from "../db-CYmBWcjh.mjs";
 import "../helpers-OCVFgprQ.mjs";
 import { i as indexProject, n as indexAll, t as embedChunks } from "../sync-CdHSL9Kc.mjs";
@@ -10,12 +10,13 @@ import "../embeddings-DGRAPAYb.mjs";
 import { t as STOP_WORDS } from "../stop-words-BaMEGVeY.mjs";
 import { n as populateSlugs, r as searchMemory } from "../search-i2nlQ-JM.mjs";
 import { n as formatDetection, r as formatDetectionJson, t as detectProject } from "../detect-CdaA48EI.mjs";
-import { t as extractAndStoreTriples } from "../kg-extraction-Uvr9fTlz.mjs";
-import { t as PaiClient } from "../ipc-client-CoyUHPod.mjs";
-import { a as expandHome, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, t as CONFIG_DIR } from "../config-BuhHWyOK.mjs";
-import { t as createStorageBackend } from "../factory-BDBIfTDC.mjs";
-import { s as kgQuery } from "../kg-entity-D5v7RCDi.mjs";
-import { appendFileSync, chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { a as resolveHome, c as upsertSession, n as cmdScan, o as saveScanConfig, r as loadScanConfig, s as upsertProject, t as extractAndStoreTriples } from "../kg-extraction-r5KkTmWY.mjs";
+import "../indexer-D7MvSQPY.mjs";
+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 { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import chalk from "chalk";
@@ -1094,68 +1095,68 @@ function cmdHealth$1(db, opts) {
 }
 
 //#endregion
-//#region src/cli/commands/project/index.ts
-function registerProjectCommands(projectCmd, getDb) {
-	projectCmd.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);
-	});
-	projectCmd.command("list").description("List registered projects").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
+//#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) => {
 		cmdList$3(getDb(), opts);
 	});
-	projectCmd.command("info <slug>").description("Show full details for a project").action((slug) => {
+	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);
+		if (!project) {
+			console.error(`Project not found: ${identifier}`);
+			process.exit(1);
+		}
+		process.stdout.write(project.root_path + "\n");
+	});
+	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);
+	});
+	projectsCmd.command("info <slug>").description("Show full details for a project").action((slug) => {
 		cmdInfo$1(getDb(), slug);
 	});
-	projectCmd.command("archive <slug>").description("Archive a project").action((slug) => {
+	projectsCmd.command("archive <slug>").description("Archive a project").action((slug) => {
 		cmdArchive(getDb(), slug);
 	});
-	projectCmd.command("unarchive <slug>").description("Restore an archived project to active status").action((slug) => {
+	projectsCmd.command("unarchive <slug>").description("Restore an archived project to active status").action((slug) => {
 		cmdUnarchive(getDb(), slug);
 	});
-	projectCmd.command("move <slug> <new-path>").description("Update the root path for a project").action((slug, newPath) => {
+	projectsCmd.command("move <slug> <new-path>").description("Update the root path for a project").action((slug, newPath) => {
 		cmdMove(getDb(), slug, newPath);
 	});
-	projectCmd.command("tag <slug> <tags...>").description("Add one or more tags to a project").action((slug, tags) => {
+	projectsCmd.command("tag <slug> <tags...>").description("Add one or more tags to a project").action((slug, tags) => {
 		cmdTag$1(getDb(), slug, tags);
 	});
-	projectCmd.command("alias <slug> <alias>").description("Register an alternative slug for a project").action((slug, alias) => {
+	projectsCmd.command("alias <slug> <alias>").description("Register an alternative slug for a project").action((slug, alias) => {
 		cmdAlias(getDb(), slug, alias);
 	});
-	projectCmd.command("edit <slug>").description("Edit project metadata").option("--display-name <name>", "New display name").option("--type <type>", "New type").action((slug, opts) => {
+	projectsCmd.command("edit <slug>").description("Edit project metadata").option("--display-name <name>", "New display name").option("--type <type>", "New type").action((slug, opts) => {
 		cmdEdit(getDb(), slug, opts);
 	});
-	projectCmd.command("cd <identifier>").description("Print the root path for a project (use with: cd $(pai project cd <id>))").action((identifier) => {
-		const project = resolveIdentifier(getDb(), identifier);
-		if (!project) {
-			console.error(`Project not found: ${identifier}`);
-			process.exit(1);
-		}
-		process.stdout.write(project.root_path + "\n");
-	});
-	projectCmd.command("detect [path]").description("Detect which registered project the given path (or CWD) belongs to").option("--json", "Output raw JSON instead of human-readable text").action((pathArg, opts) => {
+	projectsCmd.command("detect [path]").description("Detect which registered project the given path (or CWD) belongs to").option("--json", "Output raw JSON instead of human-readable text").action((pathArg, opts) => {
 		cmdDetect(getDb(), pathArg, opts);
 	});
-	projectCmd.command("health").description("Audit all registered projects: check which paths still exist, find moved/dead projects").option("--fix", "Auto-remediate where possible (update moved paths, archive dead zero-session projects)").option("--json", "Output raw JSON report").option("--status <category>", "Filter output to: active | stale | dead").action((opts) => {
+	projectsCmd.command("health").description("Audit all registered projects: check which paths still exist, find moved/dead projects").option("--fix", "Auto-remediate where possible").option("--json", "Output raw JSON report").option("--status <category>", "Filter output to: active | stale | dead").action((opts) => {
 		cmdHealth$1(getDb(), opts);
 	});
-	projectCmd.command("consolidate <identifier>").description("Consolidate scattered ~/.claude/projects/.../Notes/ directories for a project into its canonical Notes/ location").option("--yes", "Perform consolidation without confirmation prompt").option("--dry-run", "Preview what would be moved without making changes").action((identifier, opts) => {
+	projectsCmd.command("consolidate <identifier>").description("Consolidate scattered ~/.claude/projects/.../Notes/ directories for a project into its canonical Notes/ location").option("--yes", "Perform consolidation without confirmation prompt").option("--dry-run", "Preview what would be moved without making changes").action((identifier, opts) => {
 		cmdConsolidate(getDb(), identifier, opts);
 	});
-	projectCmd.command("promote").description("Promote a session note into a new standalone project").requiredOption("--from-session <path>", "Path to the session note markdown file").requiredOption("--to <path>", "Directory path for the new project (must not exist)").option("--name <name>", "Display name for the new project (derived from filename if omitted)").action((opts) => {
+	projectsCmd.command("promote").description("Promote a session note into a new standalone project").requiredOption("--from-session <path>", "Path to the session note markdown file").requiredOption("--to <path>", "Directory path for the new project (must not exist)").option("--name <name>", "Display name for the new project (derived from filename if omitted)").action((opts) => {
 		cmdPromote(getDb(), opts);
 	});
-	projectCmd.command("go <query>").description("Print the root path for a project by slug, partial name, or fuzzy match.\nDesigned for shell integration: cd $(pai project go <query>)\nOr set a shell alias: alias pcd='cd $(pai project go)'").action((query) => {
+	projectsCmd.command("go <query>").description("Print the root path for a project by slug, partial name, or fuzzy match.\nDesigned for shell integration: cd $(pai projects go <query>)").action((query) => {
 		cmdGo(getDb(), query);
 	});
-	projectCmd.command("name <identifier> <shortname>").description("Give a project a short name for quick access (used by AIBroker to launch sessions)").option("--permission <level>", "Permission level: full | trusted | default (or raw CLI flags)").action((identifier, shortname, opts) => {
+	projectsCmd.command("name <identifier> <shortname>").description("Give a project a short name for quick access").option("--permission <level>", "Permission level: full | trusted | default").action((identifier, shortname, opts) => {
 		cmdName(getDb(), identifier, shortname, opts);
 	});
-	projectCmd.command("unname <shortname>").description("Remove a project's short name").action((shortname) => {
+	projectsCmd.command("unname <shortname>").description("Remove a project's short name").action((shortname) => {
 		cmdUnname(getDb(), shortname);
 	});
-	projectCmd.command("names").description("List named projects (your curated shortlist)").option("--json", "Output JSON for AIBroker consumption").action((opts) => {
+	projectsCmd.command("names").description("List named projects (your curated shortlist)").option("--json", "Output JSON for AIBroker consumption").action((opts) => {
 		cmdNames(getDb(), opts);
 	});
-	projectCmd.command("config [identifier]").description("View or modify session launch config for a project.\nUse --options to discover available keys and presets.\nUse --defaults to manage global defaults for new sessions.").option("--set <key=value...>", "Set config values (repeatable)", (v, prev) => [...prev, v], []).option("--unset <key...>", "Remove config keys (repeatable, use env.KEY for env vars)", (v, prev) => [...prev, v], []).option("--preset <name>", "Apply a permission preset: full | trusted | default").option("--defaults", "Manage global session defaults instead of a project").option("--options", "List available config keys and presets").option("--json", "Output JSON").option("--reset", "Reset config to empty (inherit global defaults)").action((identifier, opts) => {
+	projectsCmd.command("config [identifier]").description("View or modify session launch config for a project.\nUse --options to discover available keys and presets.").option("--set <key=value...>", "Set config values (repeatable)", (v, prev) => [...prev, v], []).option("--unset <key...>", "Remove config keys (repeatable, use env.KEY for env vars)", (v, prev) => [...prev, v], []).option("--preset <name>", "Apply a permission preset: full | trusted | default").option("--defaults", "Manage global session defaults instead of a project").option("--options", "List available config keys and presets").option("--json", "Output JSON").option("--reset", "Reset config to empty (inherit global defaults)").action((identifier, opts) => {
 		cmdConfig(getDb(), identifier, opts);
 	});
 }
@@ -1682,10 +1683,10 @@ function cmdActive(db, opts) {
 	], rows));
 }
 async function cmdAutoRoute(opts) {
-	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("../auto-route-DL4ViDKC.mjs");
+	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("../auto-route-D54Kv7yI.mjs");
 	const { openRegistry } = await import("../db-BtuN768f.mjs").then((n) => n.t);
-	const { createStorageBackend } = await import("../factory-BDBIfTDC.mjs").then((n) => n.n);
-	const { loadConfig } = await import("../config-BuhHWyOK.mjs").then((n) => n.r);
+	const { createStorageBackend } = await import("../factory-BufouUQ1.mjs").then((n) => n.n);
+	const { loadConfig } = await import("../config-DqBY3aT0.mjs").then((n) => n.r);
 	const config = loadConfig();
 	const registryDb = openRegistry();
 	const federation = await createStorageBackend(config);
@@ -1817,14 +1818,14 @@ function cmdCheckpoint(message, opts) {
 
 //#endregion
 //#region src/cli/commands/session/handover.ts
-const HANDOVER_TODO_LOCATIONS = [
+const HANDOVER_TODO_LOCATIONS$1 = [
 	"Notes/TODO.md",
 	".claude/Notes/TODO.md",
 	"tasks/todo.md",
 	"TODO.md"
 ];
-function findProjectTodo(rootPath) {
-	for (const rel of HANDOVER_TODO_LOCATIONS) {
+function findProjectTodo$1(rootPath) {
+	for (const rel of HANDOVER_TODO_LOCATIONS$1) {
 		const full = join(rootPath, rel);
 		if (existsSync(full)) try {
 			return {
@@ -1835,7 +1836,7 @@ function findProjectTodo(rootPath) {
 	}
 	return null;
 }
-function stripContinueSection(content) {
+function stripContinueSection$1(content) {
 	const lines = content.split("\n");
 	const startIdx = lines.findIndex((l) => l.trim() === "## Continue");
 	if (startIdx === -1) return content;
@@ -1876,7 +1877,7 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 		const num = parseInt(nol, 10);
 		if (!isNaN(num)) session = db.prepare("SELECT * FROM sessions WHERE project_id = ? AND number = ?").get(project.id, num);
 	}
-	const todo = findProjectTodo(project.root_path);
+	const todo = findProjectTodo$1(project.root_path);
 	let todoPath;
 	let existingContent;
 	if (todo) {
@@ -1910,7 +1911,7 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 		"",
 		"---",
 		""
-	].join("\n") + stripContinueSection(existingContent).trimStart();
+	].join("\n") + stripContinueSection$1(existingContent).trimStart();
 	const tmpPath = `${todoPath}.handover.tmp`;
 	try {
 		writeFileSync(tmpPath, newContent, "utf8");
@@ -1925,36 +1926,689 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 }
 
 //#endregion
-//#region src/cli/commands/session/index.ts
-function registerSessionCommands(sessionCmd, getDb) {
-	sessionCmd.command("list [project-slug]").description("List sessions, optionally filtered to a single project").option("--limit <n>", "Maximum number of sessions to show", "20").option("--status <status>", "Filter by status: open | completed | compacted").action((projectSlug, opts) => {
-		cmdList$2(getDb(), projectSlug, opts);
+//#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.
+*
+* Scan strategy:
+*   1. Walk top-level <project>/<uuid>.jsonl files (fast: ~20 files total).
+*   2. For each, check system line count to set the resumable flag.
+*   3. Join with sessions/<uuid>.jsonl (if present) for user lines, last prompt, ai-title.
+*   4. Enrich with clc name registry and PAI registry root path.
+*
+* Used by: pai session recent, pai session 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: add clc registry entries that have 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();
+	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;
+		}
+		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";
+			if (filterMode === "resumable" && !resumable) continue;
+			if (filterMode === "named" && !resumable && !inRegistry) continue;
+			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;
+			seenUuids.add(uuid);
+			results.push({
+				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 (filterMode !== "resumable") for (const [uuid, clcInfo] of clcInfoMap) {
+		if (seenUuids.has(uuid)) continue;
+		let foundEncodedDir;
+		let foundTranscriptPath;
+		if (clcInfo.directory) try {
+			const real = realpathSyncSafe(clcInfo.directory);
+			if (real) {
+				const encoded = encodeProjectDir(real);
+				const candidateTranscript = join(CLAUDE_PROJECTS_DIR, encoded, "sessions", `${uuid}.jsonl`);
+				if (existsSync(candidateTranscript)) {
+					foundEncodedDir = encoded;
+					foundTranscriptPath = candidateTranscript;
+				} else if (existsSync(join(CLAUDE_PROJECTS_DIR, encoded))) foundEncodedDir = encoded;
+			}
+		} catch {}
+		if (!foundEncodedDir) for (const encodedDir of encodedDirs) {
+			const candidateTranscript = join(CLAUDE_PROJECTS_DIR, encodedDir, "sessions", `${uuid}.jsonl`);
+			if (existsSync(candidateTranscript)) {
+				foundEncodedDir = encodedDir;
+				foundTranscriptPath = candidateTranscript;
+				break;
+			}
+		}
+		const encodedDir = foundEncodedDir ?? "";
+		const decodedPath = clcInfo.directory ?? (foundEncodedDir ? smartDecodeDir(foundEncodedDir) ?? foundEncodedDir.replace(/-/g, "/") : uuid);
+		const registryRootPath = foundEncodedDir ? rootPathMap.get(foundEncodedDir) : void 0;
+		const topLevelPath = foundEncodedDir ? join(CLAUDE_PROJECTS_DIR, foundEncodedDir, `${uuid}.jsonl`) : "";
+		const transcript = foundTranscriptPath ? parseTranscript(foundTranscriptPath) : {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime: 0
+		};
+		const mtime = transcript.mtime;
+		seenUuids.add(uuid);
+		results.push({
+			uuid,
+			shortId: uuid.slice(0, 8),
+			encodedDir,
+			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,
+			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`;
+}
+/**
+* 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
+*/
+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.`);
+	}
+	throw new Error(`No resumable session found matching "${query}".\n\nRun: pai session recent          to list resumable sessions.\nRun: pai session recent --all    to include transcript-only sessions.`);
+}
+
+//#endregion
+//#region src/cli/commands/session/recent.ts
+function fmtSize(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1048576) return `${Math.round(bytes / 1024)}K`;
+	return `${(bytes / 1048576).toFixed(1)}M`;
+}
+function fmtStatus(status) {
+	switch (status) {
+		case "resumable": return chalk.green("resumable");
+		case "stub": return chalk.yellow("stub");
+		case "transcript-only": return chalk.yellow("transcript-only");
+		case "orphan": return chalk.dim("orphan");
+	}
+}
+function cmdRecent(db, opts) {
+	const limit = parseInt(opts.n ?? "20", 10);
+	const includeAll = opts.all === true;
+	const sessions = scanSessions(db, {
+		limit,
+		filter: includeAll ? "all" : "named"
+	});
+	if (sessions.length === 0) {
+		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."));
+		return;
+	}
+	if (opts.json) {
+		const output = sessions.map((s, idx) => ({
+			idx: idx + 1,
+			uuid: s.uuid,
+			shortId: s.shortId,
+			resumable: s.resumable,
+			sessionStatus: s.sessionStatus,
+			age: fmtAge(s.mtime),
+			mtime: s.mtime,
+			name: s.friendlyName,
+			lastUserPrompt: s.lastUserPrompt,
+			userLines: s.userLines,
+			msgCount: s.msgCount,
+			topLevelSize: s.topLevelSize,
+			decodedPath: s.decodedPath
+		}));
+		console.log(JSON.stringify(output, null, 2));
+		return;
+	}
+	const title = includeAll ? "All Sessions (named + orphans)" : "Named Sessions";
+	console.log("\n" + header(title) + "\n");
+	const headers = [
+		"#",
+		"id",
+		"age",
+		"name / project",
+		"last prompt",
+		"msgs",
+		"size",
+		"status"
+	];
+	const rows = sessions.map((s, idx) => {
+		const name = s.friendlyName ?? s.decodedPath;
+		const prompt = s.lastUserPrompt ? chalk.dim(s.lastUserPrompt.length > 40 ? s.lastUserPrompt.slice(0, 39) + "…" : s.lastUserPrompt) : dim("—");
+		return [
+			chalk.dim(String(idx + 1)),
+			chalk.cyan(s.shortId),
+			dim(fmtAge(s.mtime)),
+			name.length > 26 ? name.slice(0, 25) + "…" : name,
+			prompt,
+			s.userLines > 0 ? String(s.userLines) : dim("—"),
+			dim(fmtSize(s.topLevelSize)),
+			fmtStatus(s.sessionStatus)
+		];
+	});
+	console.log(renderTable(headers, rows));
+	console.log("\n" + dim("Go to a session:   ") + chalk.white("pai resume <name>") + "\n" + (includeAll ? "" : dim("Show all sessions: ") + chalk.white("pai sessions --all") + "\n"));
+}
+
+//#endregion
+//#region src/cli/commands/session/goto.ts
+function cmdGoto(db, query, opts) {
+	const allSessions = scanSessions(db, {
+		limit: 500,
+		filter: "named"
+	});
+	let resolved;
+	try {
+		resolved = resolveSessionByNameOrId(allSessions, query);
+	} catch (resolveErr) {
+		console.error(err(String(resolveErr).replace(/^Error: /, "")));
+		process.exit(1);
+	}
+	const { session: matchedSession, friendlyName } = resolved;
+	let resumableUuid;
+	let resumableSession;
+	if (matchedSession.resumable) {
+		resumableUuid = matchedSession.uuid;
+		resumableSession = matchedSession;
+	} else if (matchedSession.encodedDir) {
+		const sameProject = allSessions.filter((s) => s.encodedDir === matchedSession.encodedDir && s.resumable);
+		sameProject.sort((a, b) => b.mtime - a.mtime);
+		if (sameProject.length > 0) {
+			resumableSession = sameProject[0];
+			resumableUuid = resumableSession.uuid;
+		}
+	}
+	const rawDir = matchedSession.clcDirectory ?? matchedSession.registryRootPath ?? matchedSession.decodedPath;
+	let projectDir;
+	try {
+		projectDir = realpathSync(rawDir);
+	} catch {
+		console.error(err(`session "${query}": directory does not exist or cannot be resolved.\n  Registry says: ${rawDir}\n  The directory may have moved or been deleted.`));
+		process.exit(1);
+	}
+	const useName = !opts.noName && !!friendlyName;
+	const useGo = !opts.noGo;
+	let promptArg = null;
+	if (useName && friendlyName) promptArg = useGo ? `/Name ${friendlyName}\ngo` : `/Name ${friendlyName}`;
+	else if (useGo) promptArg = "go";
+	const fullArgv = resumableUuid ? [
+		"claude",
+		"--resume",
+		resumableUuid,
+		...promptArg ? [promptArg] : []
+	] : ["claude", ...promptArg ? [promptArg] : []];
+	if (opts.dryRun) {
+		const mode = resumableUuid ? "RESUME" : "FRESH";
+		console.log("\n" + chalk.bold(`Dry run — would execute (${mode}):`) + "\n");
+		console.log(`  cwd:            ${chalk.cyan(projectDir)}`);
+		const argDisplay = fullArgv.map((a) => a.includes("\n") ? `"${a.replace(/\n/g, "\\n")}"` : a.startsWith("/Name") ? `"${a}"` : a).join(" ");
+		console.log(`  argv:           ${chalk.white(argDisplay)}`);
+		if (useName && friendlyName) console.log(`  name:           ${chalk.green(friendlyName)}`);
+		if (resumableSession) {
+			console.log(`\n  session:        ${resumableSession.uuid}`);
+			console.log(`  age:            ${fmtAge(resumableSession.mtime)}`);
+			console.log(`  system lines:   ${resumableSession.topLevelSystemLines}`);
+			console.log(`  user msgs:      ${resumableSession.userLines > 0 ? resumableSession.userLines : "—"}`);
+		} else console.log(`\n  mode:           ${chalk.yellow("fresh session (no resumable snapshot)")}`);
+		console.log(`  project path:   ${matchedSession.decodedPath}`);
+		console.log();
+		return;
+	}
+	const result = spawnSync(fullArgv[0], fullArgv.slice(1), {
+		cwd: projectDir,
+		stdio: "inherit",
+		env: process.env
 	});
-	sessionCmd.command("info <project-slug> <number>").description("Show full details for a specific session").action((projectSlug, number) => {
+	if (result.error) {
+		console.error(err(`Failed to launch claude: ${result.error.message}`));
+		process.exit(1);
+	}
+	process.exit(result.status ?? 0);
+}
+
+//#endregion
+//#region src/cli/commands/session/pause.ts
+const HANDOVER_TODO_LOCATIONS = [
+	"Notes/TODO.md",
+	".claude/Notes/TODO.md",
+	"tasks/todo.md",
+	"TODO.md"
+];
+function findProjectTodo(rootPath) {
+	for (const rel of HANDOVER_TODO_LOCATIONS) {
+		const full = join(rootPath, rel);
+		if (existsSync(full)) try {
+			return {
+				path: full,
+				content: readFileSync(full, "utf8")
+			};
+		} catch {}
+	}
+	return null;
+}
+function stripContinueSection(content) {
+	const lines = content.split("\n");
+	const startIdx = lines.findIndex((l) => l.trim() === "## Continue");
+	if (startIdx === -1) return content;
+	let endIdx = lines.length;
+	for (let i = startIdx + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed === "---" || trimmed.startsWith("##") && trimmed !== "## Continue") {
+			endIdx = i;
+			break;
+		}
+	}
+	let trailingEnd = endIdx;
+	if (trailingEnd < lines.length && lines[trailingEnd].trim() === "---") trailingEnd += 1;
+	const before = lines.slice(0, startIdx);
+	const after = lines.slice(trailingEnd);
+	while (after.length > 0 && after[0].trim() === "") after.shift();
+	return [...before, ...after].join("\n");
+}
+function cmdPause(db, opts) {
+	const cwd = process.cwd();
+	const project = db.prepare(`SELECT id, slug, display_name, root_path, encoded_dir
+         FROM projects
+        WHERE ? LIKE root_path || '%'
+        ORDER BY length(root_path) DESC
+        LIMIT 1`).get(cwd);
+	if (!project) {
+		console.error(chalk.red("pai session pause: ") + `Current directory is not within a registered PAI project.
+  cwd: ${cwd}`);
+		process.exit(1);
+	}
+	const session = db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(project.id);
+	const todo = findProjectTodo(project.root_path);
+	let todoPath;
+	let existingContent;
+	if (todo) {
+		todoPath = todo.path;
+		existingContent = todo.content;
+	} else {
+		const notesDir = join(project.root_path, "Notes");
+		if (!opts.dryRun) try {
+			if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
+		} catch (mkdirErr) {
+			console.error(chalk.red("pai session pause: ") + `Could not create Notes directory: ${String(mkdirErr)}`);
+			process.exit(1);
+		}
+		todoPath = join(notesDir, "TODO.md");
+		existingContent = "";
+	}
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	let sessionLine;
+	if (session) {
+		const num = String(session.number).padStart(4, "0");
+		const titlePart = session.title || session.slug || "Session";
+		sessionLine = `${num} - ${session.date} - ${titlePart}`;
+	} else sessionLine = "Unknown session";
+	const continueBlock = [
+		"## Continue",
+		"",
+		`> **Last session:** ${sessionLine}`,
+		`> **Paused at:** ${timestamp}`,
+		">",
+		`> Working directory: ${cwd}. Check the latest session note for details.`,
+		"",
+		"---",
+		""
+	].join("\n");
+	const newContent = continueBlock + stripContinueSection(existingContent).trimStart();
+	if (opts.dryRun) {
+		console.log("\n" + chalk.bold("Dry run — would write to:") + " " + chalk.cyan(todoPath));
+		console.log(chalk.dim("─".repeat(60)));
+		console.log(chalk.dim(continueBlock));
+		console.log(chalk.dim("─".repeat(60)));
+	} else {
+		const tmpPath = `${todoPath}.pause.tmp`;
+		try {
+			writeFileSync(tmpPath, newContent, "utf8");
+			renameSync(tmpPath, todoPath);
+		} catch (writeErr) {
+			try {
+				if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+			} catch {}
+			console.error(chalk.red("pai session pause: ") + `Failed to write TODO.md: ${String(writeErr)}`);
+			process.exit(1);
+		}
+		console.log(chalk.green("  ## Continue written to: ") + chalk.cyan(todoPath));
+	}
+	const box = [
+		"",
+		chalk.bgRed.white.bold("  IMPORTANT: How to exit safely                               "),
+		"",
+		chalk.yellow("  Inside the Claude Code session, type:  " + chalk.white.bold("/exit") + chalk.yellow("  (then press Enter)")),
+		"",
+		chalk.red.bold("  DO NOT press Ctrl+C."),
+		"",
+		chalk.dim("  Ctrl+C bypasses PAI's stop-hook, which means:"),
+		chalk.dim("    - No project snapshot is written to the top-level jsonl"),
+		chalk.dim("    - The session becomes orphaned (cannot --resume next time)"),
+		chalk.dim("    - pai session goto will launch a fresh session instead of resuming"),
+		"",
+		chalk.dim("  The ## Continue checkpoint in TODO.md is already saved."),
+		chalk.dim("  Use /exit to preserve full session resumability."),
+		""
+	].join("\n");
+	console.log(box);
+}
+
+//#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((opts) => {
+		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("--skip-name", "Do not prepend /Name to restore the session name").option("--skip-go", "Do not append \\ngo to trigger PAI auto-resume").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((nameOrId, opts) => {
+		cmdGoto(getDb(), nameOrId, {
+			noName: opts.skipName,
+			noGo: opts.skipGo,
+			dryRun: opts.dryRun
+		});
+	});
+	sessionsCmd.command("pause").description("Write a ## Continue checkpoint to the project's TODO.md.\nRecommended short form: pai pause\nUse /exit inside Claude Code to preserve full session resumability.").option("--dry-run", "Preview the ## Continue block without writing it").action((opts) => {
+		cmdPause(getDb(), opts);
+	});
+	sessionsCmd.command("recent").description("[Deprecated] Use `pai sessions list` instead.").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((opts) => {
+		process.stderr.write("Deprecated: `pai sessions recent` — use `pai sessions list` instead.\n");
+		cmdRecent(getDb(), opts);
+	});
+	sessionsCmd.command("info <project-slug> <number>").description("Show full details for a specific session").action((projectSlug, number) => {
 		cmdInfo(getDb(), projectSlug, number);
 	});
-	sessionCmd.command("rename <project-slug> <number> <new-slug>").description("Rename a session note — updates file on disk, H1 title, and registry").action((projectSlug, number, newSlug) => {
+	sessionsCmd.command("rename <project-slug> <number> <new-slug>").description("Rename a session note — updates file on disk, H1 title, and registry").action((projectSlug, number, newSlug) => {
 		cmdRename(getDb(), projectSlug, number, newSlug);
 	});
-	sessionCmd.command("slug <project-slug> <number>").description("Generate a descriptive slug from the session JSONL transcript").option("--apply", "Rename the session note using the generated slug").action((projectSlug, number, opts) => {
+	sessionsCmd.command("slug <project-slug> <number>").description("Generate a descriptive slug from the session JSONL transcript").option("--apply", "Rename the session note using the generated slug").action((projectSlug, number, opts) => {
 		cmdSlug(getDb(), projectSlug, number, opts);
 	});
-	sessionCmd.command("tag <project-slug> <number> [tags...]").description("Set or show tags on a session. Tags can be space-separated or comma-separated.").action((projectSlug, number, tags) => {
+	sessionsCmd.command("tag <project-slug> <number> [tags...]").description("Set or show tags on a session.").action((projectSlug, number, tags) => {
 		cmdTag(getDb(), projectSlug, number, tags);
 	});
-	sessionCmd.command("route <project-slug> <number> <target-project>").description("Create a cross-reference link from a session to a target project").option("--type <type>", "Link type: related | follow-up | reference", "related").action((projectSlug, number, targetProject, opts) => {
+	sessionsCmd.command("route <project-slug> <number> <target-project>").description("Create a cross-reference link from a session to a target project").option("--type <type>", "Link type: related | follow-up | reference", "related").action((projectSlug, number, targetProject, opts) => {
 		cmdRoute(getDb(), projectSlug, number, targetProject, opts);
 	});
-	sessionCmd.command("handover [project-slug] [session-id]").description("Write a ## Continue section to the project's TODO.md.\nCalled automatically from session-stop and pre-compact hooks.\nRecords the last session identifier, timestamp, and working directory\nso the next session can resume from the correct context.").action((projectSlug, sessionId) => {
+	sessionsCmd.command("handover [project-slug] [session-id]").description("Write a ## Continue section to the project's TODO.md.\nCalled automatically from session-stop and pre-compact hooks.").action((projectSlug, sessionId) => {
 		cmdHandover(getDb(), projectSlug, sessionId);
 	});
-	sessionCmd.command("checkpoint <message>").description("Append a timestamped checkpoint to the active session note.\nDesigned for hooks (PostToolUse, UserPromptSubmit) — fast and silent.\nRate-limited: skips silently if last checkpoint was < --min-gap seconds ago.").option("--min-gap <seconds>", "Minimum seconds between checkpoints (default: 300 = 5 minutes)", "300").action((message, opts) => {
+	sessionsCmd.command("checkpoint <message>").description("Append a timestamped checkpoint to the active session note.\nRate-limited: skips silently if last checkpoint was < --min-gap seconds ago.").option("--min-gap <seconds>", "Minimum seconds between checkpoints (default: 300 = 5 minutes)", "300").action((message, opts) => {
 		cmdCheckpoint(message, opts);
 	});
-	sessionCmd.command("active").description("Show currently active Claude Code sessions.\nDetects live sessions by checking which JSONL transcript files\nwere recently modified in ~/.claude/projects/.").option("--minutes <n>", "Consider sessions active if modified within N minutes (default: 60)", "60").option("--json", "Output raw JSON instead of formatted display").action((opts) => {
+	sessionsCmd.command("active").description("Show currently active Claude Code sessions.\nDetects live sessions by checking which JSONL transcript files\nwere recently modified in ~/.claude/projects/.").option("--minutes <n>", "Consider sessions active if modified within N minutes (default: 60)", "60").option("--json", "Output raw JSON instead of formatted display").action((opts) => {
 		cmdActive(getDb(), opts);
 	});
-	sessionCmd.command("auto-route").description("Auto-detect which project this session belongs to.\nTries: (1) path match in registry, (2) Notes/PAI.md marker walk, (3) topic detection.\nDesigned for use in CLAUDE.md session-start hooks.").option("--cwd <path>", "Working directory to detect from (default: process.cwd())").option("--context <text>", "Conversation context for topic-based fallback routing").option("--json", "Output raw JSON instead of formatted display").action(async (opts) => {
+	sessionsCmd.command("auto-route").description("Auto-detect which project this session belongs to.\nTries: (1) path match in registry, (2) Notes/PAI.md marker walk, (3) topic detection.").option("--cwd <path>", "Working directory to detect from (default: process.cwd())").option("--context <text>", "Conversation context for topic-based fallback routing").option("--json", "Output raw JSON instead of formatted display").action(async (opts) => {
 		await cmdAutoRoute(opts);
 	});
 }
@@ -2302,8 +2956,8 @@ function analyzeProject(db, project) {
 async function countVectorDbPaths(oldPaths) {
 	if (oldPaths.length === 0) return 0;
 	try {
-		const { loadConfig } = await import("../config-BuhHWyOK.mjs").then((n) => n.r);
-		const { PostgresBackend } = await import("../postgres-BGERehmX.mjs");
+		const { loadConfig } = await import("../config-DqBY3aT0.mjs").then((n) => n.r);
+		const { PostgresBackend } = await import("../postgres-Cp25xZes.mjs");
 		const config = loadConfig();
 		if (config.storageBackend !== "postgres") return 0;
 		const pgBackend = new PostgresBackend(config.postgres ?? {});
@@ -2323,8 +2977,8 @@ async function countVectorDbPaths(oldPaths) {
 async function updateVectorDbPaths(moves) {
 	if (moves.length === 0) return 0;
 	try {
-		const { loadConfig } = await import("../config-BuhHWyOK.mjs").then((n) => n.r);
-		const { PostgresBackend } = await import("../postgres-BGERehmX.mjs");
+		const { loadConfig } = await import("../config-DqBY3aT0.mjs").then((n) => n.r);
+		const { PostgresBackend } = await import("../postgres-Cp25xZes.mjs");
 		const config = loadConfig();
 		if (config.storageBackend !== "postgres") return 0;
 		const pgBackend = new PostgresBackend(config.postgres ?? {});
@@ -2647,269 +3301,6 @@ function registerSessionCleanupCommand(sessionCmd, getDb) {
 	});
 }
 
-//#endregion
-//#region src/cli/commands/registry/utils.ts
-/**
-* Upsert a project row. Returns { id, isNew }.
-*
-* Matching priority:
-*  1. root_path  — most reliable; handles slug collisions
-*  2. encoded_dir — Claude project dirs are canonical
-*  3. Insert with suffix-deduplication on slug collision
-*/
-function upsertProject(db, slug, rootPath, encodedDir) {
-	const ts = now();
-	const byPath = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
-	if (byPath) {
-		const encodedOwner = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir);
-		if (!encodedOwner || encodedOwner.id === byPath.id) db.prepare("UPDATE projects SET encoded_dir = ?, updated_at = ? WHERE id = ?").run(encodedDir, ts, byPath.id);
-		return {
-			id: byPath.id,
-			isNew: false
-		};
-	}
-	const byEncoded = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir);
-	if (byEncoded) {
-		const pathOwner = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
-		if (!pathOwner || pathOwner.id === byEncoded.id) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(rootPath, ts, byEncoded.id);
-		return {
-			id: byEncoded.id,
-			isNew: false
-		};
-	}
-	let finalSlug = slug;
-	let attempt = 0;
-	while (true) {
-		if (!db.prepare("SELECT id FROM projects WHERE slug = ?").get(finalSlug)) break;
-		attempt++;
-		finalSlug = `${slug}-${attempt}`;
-	}
-	const result = db.prepare(`INSERT OR IGNORE INTO projects
-         (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 'local', 'active', ?, ?)`).run(finalSlug, finalSlug, rootPath, encodedDir, ts, ts);
-	if (result.changes === 0) {
-		const fallback = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir) ?? db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
-		if (fallback) return {
-			id: fallback.id,
-			isNew: false
-		};
-		throw new Error(`upsertProject: INSERT OR IGNORE was suppressed but no matching row found for root_path=${rootPath} encoded_dir=${encodedDir}`);
-	}
-	return {
-		id: result.lastInsertRowid,
-		isNew: true
-	};
-}
-/** Upsert a session note. Returns true if newly inserted. */
-function upsertSession(db, projectId, number, date, slug, title, filename) {
-	if (db.prepare("SELECT id FROM sessions WHERE project_id = ? AND number = ?").get(projectId, number)) return false;
-	const ts = now();
-	db.prepare(`INSERT INTO sessions
-       (project_id, number, date, slug, title, filename, status, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, 'completed', ?)`).run(projectId, number, date, slug, title, filename, ts);
-	return true;
-}
-
-//#endregion
-//#region src/cli/commands/registry/scan.ts
-/** Registry scan command: walk ~/.claude/projects/ and populate the registry. */
-const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
-const PAI_CONFIG_DIR = join(homedir(), ".pai");
-const PAI_CONFIG_FILE = join(PAI_CONFIG_DIR, "config.json");
-function loadScanConfig() {
-	if (!existsSync(PAI_CONFIG_FILE)) return { scan_dirs: [] };
-	try {
-		return JSON.parse(readFileSync(PAI_CONFIG_FILE, "utf8"));
-	} catch {
-		return { scan_dirs: [] };
-	}
-}
-function saveScanConfig(config) {
-	mkdirSync(PAI_CONFIG_DIR, { recursive: true });
-	writeFileSync(PAI_CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf8");
-}
-function resolveHome(p) {
-	if (p.startsWith("~/")) return join(homedir(), p.slice(2));
-	return resolve(p);
-}
-/**
-* Recursively find all .md files in a directory, including YYYY/MM subdirectories.
-* Returns filenames (basename only).
-*/
-function findNoteFiles(dir) {
-	const results = [];
-	if (!existsSync(dir)) return results;
-	for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isFile() && entry.name.endsWith(".md")) results.push(entry.name);
-	else if (entry.isDirectory() && /^\d{4}$/.test(entry.name)) {
-		const yearDir = join(dir, entry.name);
-		for (const monthEntry of readdirSync(yearDir, { withFileTypes: true })) if (monthEntry.isDirectory() && /^\d{2}$/.test(monthEntry.name)) {
-			const monthDir = join(yearDir, monthEntry.name);
-			for (const noteEntry of readdirSync(monthDir, { withFileTypes: true })) if (noteEntry.isFile() && noteEntry.name.endsWith(".md")) results.push(noteEntry.name);
-		}
-	}
-	return results;
-}
-function performScan(db) {
-	const result = {
-		projectsScanned: 0,
-		projectsNew: 0,
-		projectsUpdated: 0,
-		sessionsScanned: 0,
-		sessionsNew: 0,
-		skipped: []
-	};
-	if (!existsSync(CLAUDE_PROJECTS_DIR)) throw new Error(`Claude projects directory not found: ${CLAUDE_PROJECTS_DIR}`);
-	const entries = readdirSync(CLAUDE_PROJECTS_DIR).filter((name) => {
-		return statSync(join(CLAUDE_PROJECTS_DIR, name)).isDirectory();
-	});
-	const lookupMap = buildEncodedDirMap();
-	for (const encodedDir of entries) {
-		const rootPath = decodeEncodedDir(encodedDir, lookupMap);
-		if (!existsSync(rootPath)) {
-			result.skipped.push(`${encodedDir} (decoded: ${rootPath} — path not found on disk)`);
-			result.projectsScanned++;
-			continue;
-		}
-		const slug = slugify$1(basename(rootPath) || encodedDir);
-		const { id, isNew } = upsertProject(db, slug, rootPath, encodedDir);
-		result.projectsScanned++;
-		if (isNew) result.projectsNew++;
-		else result.projectsUpdated++;
-		try {
-			ensurePaiMarker(rootPath, slug);
-		} catch {}
-		const claudeNotesDir = join(CLAUDE_PROJECTS_DIR, encodedDir, "Notes");
-		if (existsSync(claudeNotesDir)) {
-			if (claudeNotesDir !== join(rootPath, "Notes")) db.prepare("UPDATE projects SET claude_notes_dir = ?, updated_at = ? WHERE id = ?").run(claudeNotesDir, Date.now(), id);
-		}
-		if (!existsSync(claudeNotesDir)) continue;
-		const noteFiles = findNoteFiles(claudeNotesDir);
-		for (const filename of noteFiles) {
-			const parsed = parseSessionFilename(filename);
-			if (!parsed) continue;
-			result.sessionsScanned++;
-			if (upsertSession(db, id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
-		}
-	}
-	{
-		const activeProjects = db.prepare("SELECT id, slug, root_path FROM projects WHERE status = 'active'").all();
-		for (const project of activeProjects) {
-			const notesDir = join(project.root_path, "Notes");
-			if (!existsSync(notesDir)) continue;
-			let files;
-			try {
-				files = findNoteFiles(notesDir);
-			} catch {
-				continue;
-			}
-			for (const filename of files) {
-				const parsed = parseSessionFilename(filename);
-				if (!parsed) continue;
-				result.sessionsScanned++;
-				if (upsertSession(db, project.id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
-			}
-		}
-	}
-	const config = loadScanConfig();
-	if (config.scan_dirs.length) for (const rawDir of config.scan_dirs) {
-		const scanDir = resolveHome(rawDir);
-		if (!existsSync(scanDir)) {
-			result.skipped.push(`${rawDir} (configured scan_dir not found)`);
-			continue;
-		}
-		const children = readdirSync(scanDir).filter((name) => {
-			if (name.startsWith(".")) return false;
-			const full = join(scanDir, name);
-			try {
-				return statSync(full).isDirectory();
-			} catch {
-				return false;
-			}
-		});
-		for (const child of children) {
-			const childPath = join(scanDir, child);
-			const childSlug = slugify$1(child);
-			const childEncoded = encodeDir(childPath);
-			const existing = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(childPath);
-			if (existing) {
-				result.projectsScanned++;
-				result.projectsUpdated++;
-				try {
-					ensurePaiMarker(childPath, childSlug);
-				} catch {}
-				const notesDir = join(childPath, "Notes");
-				if (existsSync(notesDir)) {
-					const noteFiles = readdirSync(notesDir).filter((f) => f.endsWith(".md"));
-					for (const filename of noteFiles) {
-						const parsed = parseSessionFilename(filename);
-						if (!parsed) continue;
-						result.sessionsScanned++;
-						if (upsertSession(db, existing.id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
-					}
-				}
-				continue;
-			}
-			const { id, isNew } = upsertProject(db, childSlug, childPath, childEncoded);
-			result.projectsScanned++;
-			if (isNew) result.projectsNew++;
-			else result.projectsUpdated++;
-			try {
-				ensurePaiMarker(childPath, childSlug);
-			} catch {}
-			const notesDir = join(childPath, "Notes");
-			if (existsSync(notesDir)) {
-				const noteFiles = readdirSync(notesDir).filter((f) => f.endsWith(".md"));
-				for (const filename of noteFiles) {
-					const parsed = parseSessionFilename(filename);
-					if (!parsed) continue;
-					result.sessionsScanned++;
-					if (upsertSession(db, id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
-				}
-			}
-		}
-	}
-	if (config.scan_dirs.length) {
-		const markers = discoverPaiMarkers(config.scan_dirs.map(resolveHome).filter(existsSync));
-		for (const marker of markers) {
-			const registeredRow = db.prepare("SELECT id, root_path, slug FROM projects WHERE slug = ?").get(marker.slug);
-			if (!registeredRow) continue;
-			if (registeredRow.root_path !== marker.projectRoot) {
-				const newEncoded = encodeDir(marker.projectRoot);
-				const now4 = Date.now();
-				const encodedOwner = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(newEncoded);
-				const pathOwner = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(marker.projectRoot);
-				const encodedSafe = !encodedOwner || encodedOwner.id === registeredRow.id;
-				const pathSafe = !pathOwner || pathOwner.id === registeredRow.id;
-				if (encodedSafe && pathSafe) db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(marker.projectRoot, newEncoded, now4, registeredRow.id);
-				else if (pathSafe) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(marker.projectRoot, now4, registeredRow.id);
-			}
-		}
-	}
-	return result;
-}
-function cmdScan(db) {
-	const config = loadScanConfig();
-	console.log(dim("Scanning ~/.claude/projects/ ..."));
-	if (config.scan_dirs.length) console.log(dim(`Scanning ${config.scan_dirs.length} extra dir(s): ${config.scan_dirs.join(", ")}`));
-	console.log(dim("Scanning project-root Notes/ directories ..."));
-	let result;
-	try {
-		result = performScan(db);
-	} catch (e) {
-		console.error(err(String(e)));
-		process.exit(1);
-	}
-	console.log(ok(`Scanned ${bold(String(result.projectsScanned))} projects, ${bold(String(result.sessionsScanned))} session notes.`));
-	console.log(dim(`  Projects: ${result.projectsNew} new, ${result.projectsUpdated} updated`));
-	console.log(dim(`  Sessions: ${result.sessionsNew} new`));
-	if (result.skipped.length) {
-		console.log();
-		console.log(warn(`  ${result.skipped.length} project(s) skipped (path not found on disk):`));
-		for (const s of result.skipped.slice(0, 10)) console.log(dim(`    ${s}`));
-		if (result.skipped.length > 10) console.log(dim(`    ... and ${result.skipped.length - 10} more`));
-	}
-}
-
 //#endregion
 //#region src/cli/commands/registry/migrate.ts
 /** Registry migrate command: import data from ~/.claude/session-registry.json. */
@@ -3015,7 +3406,7 @@ function cmdLookup(db, fsPath) {
 	process.stdout.write(row.slug + "\n");
 }
 function registerRegistryCommands(registryCmd, getDb) {
-	registryCmd.command("scan").description("Walk ~/.claude/projects/ and configured scan_dirs, upsert all projects").option("--add-dir <path>", "Add a directory to scan_dirs config").option("--remove-dir <path>", "Remove a directory from scan_dirs config").option("--show-dirs", "Show currently configured scan directories").action((opts) => {
+	registryCmd.command("scan").description("Walk ~/.claude/projects/ and configured scan_dirs, upsert all projects").option("--add-dir <path>", "Add a directory to scan_dirs config").option("--remove-dir <path>", "Remove a directory from scan_dirs config").option("--show-dirs", "Show currently configured scan directories").option("--quick", "Minimal output mode (used by hooks and daemon)").action((opts) => {
 		if (opts.showDirs) {
 			const config = loadScanConfig();
 			if (!config.scan_dirs.length) {
@@ -3053,7 +3444,7 @@ function registerRegistryCommands(registryCmd, getDb) {
 				console.log(ok(`Removed scan directory: ${bold(display)}`));
 			} else console.log(warn(`Not found in config: ${display}`));
 		}
-		if (!opts.addDir && !opts.removeDir) cmdScan(getDb());
+		if (!opts.addDir && !opts.removeDir) cmdScan(getDb(), { quick: opts.quick });
 	});
 	registryCmd.command("migrate").description("Import data from ~/.claude/session-registry.json").action(() => {
 		cmdMigrate$1(getDb());
@@ -3794,8 +4185,8 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("../daemon-w2fE3UMz.mjs").then((n) => n.t);
-		const { loadConfig: lc, ensureConfigDir } = await import("../config-BuhHWyOK.mjs").then((n) => n.r);
+		const { serve } = await import("../daemon-BryEC3as.mjs").then((n) => n.t);
+		const { loadConfig: lc, ensureConfigDir } = await import("../config-DqBY3aT0.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());
 	});
@@ -6416,7 +6807,7 @@ async function cmdExplore(note, opts) {
 	const depth = parseInt(opts.depth ?? "3", 10);
 	const direction = opts.direction ?? "both";
 	const mode = opts.mode ?? "all";
-	const { zettelExplore } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelExplore } = await import("../zettelkasten-B-94vghH.mjs");
 	const result = zettelExplore(getFedDb(), {
 		startNote: note,
 		depth,
@@ -6480,7 +6871,7 @@ async function cmdHealth(opts) {
 	const projectPath = opts.project;
 	const recentDays = parseInt(opts.days ?? "30", 10);
 	const includeTypes = opts.include ? opts.include.split(",").map((s) => s.trim()) : void 0;
-	const { zettelHealth } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelHealth } = await import("../zettelkasten-B-94vghH.mjs");
 	const result = zettelHealth(getFedDb(), {
 		scope,
 		projectPath,
@@ -6549,7 +6940,7 @@ async function cmdSurprise(note, opts) {
 	const limit = parseInt(opts.limit ?? "10", 10);
 	const minSimilarity = parseFloat(opts.minSimilarity ?? "0.3");
 	const minGraphDistance = parseInt(opts.minDistance ?? "3", 10);
-	const { zettelSurprise } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelSurprise } = await import("../zettelkasten-B-94vghH.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Surprise"));
@@ -6602,7 +6993,7 @@ async function cmdSuggest(note, opts) {
 	const vaultProjectId = parseInt(opts.vaultProjectId, 10);
 	const limit = parseInt(opts.limit ?? "5", 10);
 	const excludeLinked = opts.excludeLinked !== false;
-	const { zettelSuggest } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelSuggest } = await import("../zettelkasten-B-94vghH.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Suggest"));
@@ -6653,7 +7044,7 @@ async function cmdConverse(question, opts) {
 	const vaultProjectId = parseInt(opts.vaultProjectId, 10);
 	const depth = parseInt(opts.depth ?? "2", 10);
 	const limit = parseInt(opts.limit ?? "15", 10);
-	const { zettelConverse } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelConverse } = await import("../zettelkasten-B-94vghH.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Converse"));
@@ -6714,7 +7105,7 @@ async function cmdThemes(opts) {
 	const minClusterSize = parseInt(opts.minSize ?? "3", 10);
 	const maxThemes = parseInt(opts.maxThemes ?? "10", 10);
 	const similarityThreshold = parseFloat(opts.threshold ?? "0.65");
-	const { zettelThemes } = await import("../zettelkasten-BdaMzTGQ.mjs");
+	const { zettelThemes } = await import("../zettelkasten-B-94vghH.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Themes"));
@@ -8129,13 +8520,17 @@ function registerDbCommands(dbCmd) {
 * PAI Knowledge OS — CLI entry point
 *
 * Command tree:
-*   pai project add|list|info|archive|unarchive|move|tag|alias|edit
-*   pai session  list|info
+*   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
+*
+* Daily verb shortcuts (top-level):
+*   pai pause / pai resume / pai cd
+*   pai sessions / pai projects / pai notes
 */
 function getVersion() {
 	try {
@@ -8156,11 +8551,29 @@ function getDb() {
 	return _db;
 }
 const program = new Command();
-program.name("pai").description("PAI Knowledge OS — Personal AI Infrastructure CLI").version(getVersion(), "-V, --version", "Print version and exit");
-registerProjectCommands(program.command("project").description("Manage registered projects"), getDb);
-const sessionCmd = program.command("session").description("Browse session notes");
-registerSessionCommands(sessionCmd, getDb);
-registerSessionCleanupCommand(sessionCmd, getDb);
+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 resume <name>       Go to a session (resume or start fresh)
+  pai cd <name>           cd to a project directory
+
+Listings:
+  pai sessions            Resumable sessions catalog
+  pai projects            Known project directories
+  pai notes               Markdown session notes
+
+Subcommands (power users):
+  pai sessions ...        Session management (list, goto, pause, ...)
+  pai projects ...        Project management (cd, list, ...)
+  pai registry ...        Registry maintenance (scan, ...)
+  pai memory ...          Memory engine (index, search, ...)
+
+Shell integration:
+  eval "$(pai shell-init)"    # Add to ~/.zshrc for pai cd to work`);
+registerProjectsCommands(program.command("projects").description("Manage registered projects (list, cd, add, info, ...)"), getDb);
+const sessionsCmd = program.command("sessions").description("Session management (list, goto, pause, ...)");
+registerSessionsCommands(sessionsCmd, getDb);
+registerSessionCleanupCommand(sessionsCmd, getDb);
 registerRegistryCommands(program.command("registry").description("Registry maintenance: scan, migrate, stats, rebuild"), getDb);
 registerMemoryCommands(program.command("memory").description("Memory engine: index, search, and status"), getDb);
 registerMcpCommands(program.command("mcp").description("MCP server management: install and status"));
@@ -8179,6 +8592,56 @@ registerObservationCommands(program.command("observation").description("Observat
 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").description("Save state and display safe-exit instructions for the current session.\nWrites a ## Continue checkpoint to the project's TODO.md.\nLong form: pai sessions pause").option("--dry-run", "Preview the ## Continue block without writing it").action((opts) => {
+	cmdPause(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("--skip-name", "Do not prepend /Name to restore the session name").option("--skip-go", "Do not append \\ngo to trigger PAI auto-resume").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((name, opts) => {
+	cmdGoto(getDb(), name, {
+		noName: opts.skipName,
+		noGo: opts.skipGo,
+		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);
+	if (!project) {
+		console.error(`Project not found: ${identifier}`);
+		process.exit(1);
+	}
+	process.stdout.write(project.root_path + "\n");
+});
+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("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() {
+  if [[ "$1" == "cd" ]]; then
+    local dir=$(command pai cd "$2" 2>/dev/null)
+    if [[ -n "$dir" && -d "$dir" ]]; then
+      builtin cd "$dir"
+      echo "-> $dir"
+    else
+      echo "Project not found: $2" >&2
+      return 1
+    fi
+  elif [[ "$1" == "projects" && "$2" == "cd" ]]; then
+    local dir=$(command pai projects cd "$3" 2>/dev/null)
+    if [[ -n "$dir" && -d "$dir" ]]; then
+      builtin cd "$dir"
+      echo "-> $dir"
+    else
+      echo "Project not found: $3" >&2
+      return 1
+    fi
+  else
+    command pai "$@"
+  fi
+}
+`);
+});
 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`);
 });