@tekmidian/pai 0.9.13 → 0.9.15

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,17 +10,20 @@ 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";
+import { randomUUID } from "node:crypto";
 import { Command } from "commander";
 import { fileURLToPath } from "node:url";
+import { connect } from "node:net";
 import { execSync, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { createConnection } from "net";
@@ -1094,68 +1097,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 +1685,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);
@@ -1811,12 +1814,913 @@ function cmdCheckpoint(message, opts) {
 		} catch {}
 		process.exit(0);
 	}
-	touchCheckpointSentinel(notesDir);
-	process.exit(0);
+	touchCheckpointSentinel(notesDir);
+	process.exit(0);
+}
+
+//#endregion
+//#region src/cli/commands/session/handover.ts
+const HANDOVER_TODO_LOCATIONS$1 = [
+	"Notes/TODO.md",
+	".claude/Notes/TODO.md",
+	"tasks/todo.md",
+	"TODO.md"
+];
+function findProjectTodo$1(rootPath) {
+	for (const rel of HANDOVER_TODO_LOCATIONS$1) {
+		const full = join(rootPath, rel);
+		if (existsSync(full)) try {
+			return {
+				path: full,
+				content: readFileSync(full, "utf8")
+			};
+		} catch {}
+	}
+	return null;
+}
+function stripContinueSection$1(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 cmdHandover(db, projectSlug, numberOrLatest) {
+	let project;
+	if (projectSlug) {
+		project = db.prepare("SELECT id, slug, display_name, root_path, encoded_dir FROM projects WHERE slug = ?").get(projectSlug);
+		if (!project) process.exit(0);
+	} else {
+		const cwd = process.cwd();
+		const row = 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 (!row) process.exit(0);
+		project = row;
+	}
+	let session;
+	const nol = numberOrLatest ?? "latest";
+	if (nol === "latest") session = db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(project.id);
+	else {
+		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$1(project.root_path);
+	let todoPath;
+	let existingContent;
+	if (todo) {
+		todoPath = todo.path;
+		existingContent = todo.content;
+	} else {
+		const notesDir = join(project.root_path, "Notes");
+		try {
+			if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
+		} catch {
+			process.exit(0);
+		}
+		todoPath = join(notesDir, "TODO.md");
+		existingContent = "";
+	}
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const cwd = process.cwd();
+	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 newContent = [
+		"## Continue",
+		"",
+		`> **Last session:** ${sessionLine}`,
+		`> **Paused at:** ${timestamp}`,
+		">",
+		`> Working directory: ${cwd}. Check the latest session note for details.`,
+		"",
+		"---",
+		""
+	].join("\n") + stripContinueSection$1(existingContent).trimStart();
+	const tmpPath = `${todoPath}.handover.tmp`;
+	try {
+		writeFileSync(tmpPath, newContent, "utf8");
+		renameSync(tmpPath, todoPath);
+	} catch {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+		} catch {}
+		process.exit(0);
+	}
+	process.exit(0);
+}
+
+//#endregion
+//#region src/cli/lib/session-scan.ts
+/**
+* Shared scanner for Claude Code sessions stored in ~/.claude/projects/ .
+*
+* Storage layout (Claude Code v2.1.143+):
+*
+*   <project>/<uuid>.jsonl          — top-level: metadata, system snapshots, hook events.
+*                                     REQUIRED for claude --resume to work.
+*   <project>/sessions/<uuid>.jsonl — full transcript: user/assistant/attachment lines.
+*                                     3000+ files, almost none resumable on their own.
+*
+* Resumability rule (empirically verified):
+*   A session is resumable iff the TOP-LEVEL jsonl exists AND contains at least one
+*   line of type "system". Sessions that only have a sessions/ counterpart cannot be
+*   resumed by Claude Code regardless of how much transcript content they have.
+*
+* Stale-UUID problem (fixed in this version):
+*   The clc session.json registry stores ONE uuid per named session — the uuid Claude Code
+*   had when the user last named the session. If the user resumes and the session gets a
+*   new uuid (or they Ctrl+C and start fresh), the registry entry still points to the OLD
+*   uuid. The scanner now resolves names to the MOST RECENT top-level jsonl in the project
+*   directory, not the clc-cached uuid.
+*
+* Resolution strategy:
+*   1. Walk top-level <project>/<uuid>.jsonl files (Pass 1).
+*   2. For each, attach the clc name if the uuid matches (exact hit).
+*   3. After Pass 1, for every clc registry entry:
+*      a. If the cached uuid was found → already handled.
+*      b. Find the encodedDir for this entry's directory.
+*      c. Check ALL sessions in that encodedDir (already in our Pass-1 results).
+*      d. Pick the MOST RECENT resumable session in that dir and attach the name to it.
+*         If no resumable session, fall through to transcript-only pass.
+*   4. This means the displayed uuid for "Jobs Matthias" is always today's active session,
+*      not the stale cached one.
+*
+* Used by: pai sessions, pai resume
+*/
+const CLC_SESSIONS_FILE = join(homedir(), ".claude", "session.json");
+/** Load clc's session registry → uuid → ClcInfo map. Verbatim, never slugified. */
+function buildClcInfoMap() {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const raw = readFileSync(CLC_SESSIONS_FILE, "utf8");
+		const data = JSON.parse(raw);
+		for (const entry of data.sessions ?? []) {
+			const name = entry.name?.trim();
+			const uuid = (entry.resume ?? entry.session ?? "").trim();
+			if (name && uuid) map.set(uuid, {
+				name,
+				directory: entry.directory?.trim() || void 0
+			});
+		}
+	} catch {}
+	return map;
+}
+/** Build encoded_dir → root_path map from PAI registry (authoritative cwd). */
+function buildRegistryRootPathMap(db) {
+	try {
+		const rows = db.prepare(`SELECT root_path, encoded_dir FROM projects
+         WHERE encoded_dir IS NOT NULL AND encoded_dir != ''`).all();
+		const map = /* @__PURE__ */ new Map();
+		for (const row of rows) map.set(row.encoded_dir, row.root_path);
+		return map;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function parseTopLevel(filePath) {
+	let systemLines = 0;
+	let size = 0;
+	let mtime = 0;
+	try {
+		const st = statSync(filePath);
+		size = st.size;
+		mtime = st.mtimeMs;
+		const content = readFileSync(filePath, "utf8");
+		for (const line of content.split("\n")) {
+			const t = line.trim();
+			if (!t) continue;
+			if (t.includes("\"type\":\"system\"") || t.includes("\"type\": \"system\"")) systemLines++;
+		}
+	} catch {}
+	return {
+		systemLines,
+		size,
+		mtime
+	};
+}
+function parseTranscript(filePath) {
+	let userLines = 0;
+	let lastUserPrompt = "";
+	let msgCount = 0;
+	let aiTitle;
+	let mtime = 0;
+	try {
+		mtime = statSync(filePath).mtimeMs;
+	} catch {
+		return {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime: 0
+		};
+	}
+	let content;
+	try {
+		content = readFileSync(filePath, "utf8");
+	} catch {
+		return {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime
+		};
+	}
+	for (const line of content.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		msgCount++;
+		const hasUser = t.includes("\"type\":\"user\"") || t.includes("\"type\": \"user\"");
+		const hasTitle = t.includes("\"type\":\"ai-title\"") || t.includes("\"type\": \"ai-title\"");
+		if (!hasUser && !hasTitle) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(t);
+		} catch {
+			continue;
+		}
+		if (parsed.type === "ai-title") {
+			const v = parsed.title ?? parsed.name;
+			if (typeof v === "string" && v.trim()) aiTitle = v.trim();
+			continue;
+		}
+		if (parsed.type !== "user") continue;
+		userLines++;
+		const msg = parsed.message;
+		if (!msg) continue;
+		const c = msg.content;
+		let text = "";
+		if (typeof c === "string") text = c;
+		else if (Array.isArray(c) && c.length > 0) {
+			const first = c[0];
+			if (typeof first.text === "string") text = first.text;
+		}
+		if (text) lastUserPrompt = text.slice(0, 80).replace(/\n/g, " ");
+	}
+	return {
+		userLines,
+		lastUserPrompt,
+		msgCount,
+		aiTitle,
+		mtime
+	};
+}
+const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Compute the effective filter mode, resolving the legacy resumableOnly flag.
+*/
+function resolveFilter(opts) {
+	if (opts.filter) return opts.filter;
+	if (opts.resumableOnly === true) return "resumable";
+	if (opts.resumableOnly === false) return "all";
+	return "named";
+}
+/**
+* Scan ~/.claude/projects/ for all Claude Code sessions.
+*
+* Pass 1: walk top-level <project>/<uuid>.jsonl files (the resumability source).
+* Pass 2: handle clc registry entries whose cached UUID was not found in Pass 1.
+*         For each such entry, scan the entry's project dir for the FRESHEST session
+*         and attach the registry name to it. This fixes the stale-UUID bug where
+*         clc's session.json points to an old uuid after a fresh start.
+* Pass 3: any remaining clc entries with truly no top-level jsonl → transcript-only.
+*
+* Filter modes:
+*   "named"     — resumable + registry-known stubs + transcript-only (default)
+*   "all"       — all of the above + unnamed orphans from sessions/ subdirs
+*   "resumable" — only sessions claude --resume accepts
+*
+* Returns results sorted by mtime descending.
+*/
+function scanSessions(db, opts = {}) {
+	const limit = opts.limit ?? 200;
+	const filterMode = resolveFilter(opts);
+	if (!existsSync(CLAUDE_PROJECTS_DIR)) return [];
+	const clcInfoMap = buildClcInfoMap();
+	const rootPathMap = buildRegistryRootPathMap(db);
+	const results = [];
+	const seenUuids = /* @__PURE__ */ new Set();
+	const attachedClcUuids = /* @__PURE__ */ new Set();
+	let encodedDirs;
+	try {
+		encodedDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+	} catch {
+		return [];
+	}
+	const sessionsByEncodedDir = /* @__PURE__ */ new Map();
+	for (const encodedDir of encodedDirs) {
+		const projectDir = join(CLAUDE_PROJECTS_DIR, encodedDir);
+		try {
+			if (!statSync(projectDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let files;
+		try {
+			files = readdirSync(projectDir);
+		} catch {
+			continue;
+		}
+		const decodedPath = smartDecodeDir(encodedDir) ?? encodedDir.replace(/-/g, "/");
+		const registryRootPath = rootPathMap.get(encodedDir);
+		const projectBasename = basename(decodedPath);
+		for (const file of files) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			const topLevelPath = join(projectDir, file);
+			const topInfo = parseTopLevel(topLevelPath);
+			const resumable = topInfo.systemLines > 0;
+			const clcInfo = clcInfoMap.get(uuid);
+			const inRegistry = !!clcInfo;
+			const sessionStatus = resumable ? "resumable" : inRegistry ? "stub" : "orphan";
+			const passesFilter = filterMode === "resumable" ? resumable : filterMode === "named" ? resumable || inRegistry : true;
+			const sessionJsonlPath = join(projectDir, "sessions", `${uuid}.jsonl`);
+			const hasTranscript = existsSync(sessionJsonlPath);
+			const transcript = hasTranscript ? parseTranscript(sessionJsonlPath) : {
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime: 0
+			};
+			const mtime = topInfo.mtime || transcript.mtime;
+			const friendlyName = clcInfo?.name ?? transcript.aiTitle ?? projectBasename ?? void 0;
+			const session = {
+				uuid,
+				shortId: uuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath,
+				topLevelSystemLines: topInfo.systemLines,
+				topLevelSize: topInfo.size,
+				resumable,
+				sessionStatus,
+				sessionJsonlPath: hasTranscript ? sessionJsonlPath : void 0,
+				userLines: transcript.userLines,
+				lastUserPrompt: transcript.lastUserPrompt,
+				msgCount: transcript.msgCount,
+				aiTitle: transcript.aiTitle,
+				mtime,
+				friendlyName,
+				clcDirectory: clcInfo?.directory,
+				registryRootPath
+			};
+			if (!sessionsByEncodedDir.has(encodedDir)) sessionsByEncodedDir.set(encodedDir, []);
+			sessionsByEncodedDir.get(encodedDir).push(session);
+			seenUuids.add(uuid);
+			if (inRegistry) attachedClcUuids.add(uuid);
+			if (passesFilter) results.push(session);
+		}
+	}
+	if (filterMode !== "resumable") for (const [cachedUuid, clcInfo] of clcInfoMap) {
+		if (attachedClcUuids.has(cachedUuid)) continue;
+		let foundEncodedDir;
+		if (clcInfo.directory) {
+			const real = realpathSyncSafe(clcInfo.directory);
+			if (real) {
+				const encoded = encodeProjectDir(real);
+				if (existsSync(join(CLAUDE_PROJECTS_DIR, encoded))) foundEncodedDir = encoded;
+			}
+		}
+		if (!foundEncodedDir) {
+			for (const encodedDir of encodedDirs) if (existsSync(join(CLAUDE_PROJECTS_DIR, encodedDir, "sessions", `${cachedUuid}.jsonl`))) {
+				foundEncodedDir = encodedDir;
+				break;
+			}
+		}
+		if (foundEncodedDir) {
+			const freshestResumable = (sessionsByEncodedDir.get(foundEncodedDir) ?? []).filter((s) => s.resumable && !s.friendlyName).sort((a, b) => b.mtime - a.mtime)[0];
+			if (freshestResumable) {
+				freshestResumable.friendlyName = clcInfo.name;
+				freshestResumable.clcDirectory = freshestResumable.clcDirectory ?? clcInfo.directory;
+				freshestResumable.sessionStatus = "resumable";
+				attachedClcUuids.add(freshestResumable.uuid);
+				if (!seenUuids.has(freshestResumable.uuid) || !results.includes(freshestResumable)) {
+					if (!results.includes(freshestResumable)) results.push(freshestResumable);
+				}
+				continue;
+			}
+		}
+		if (!foundEncodedDir) {
+			const encodedDir = "";
+			const decodedPath = clcInfo.directory ?? cachedUuid;
+			const registryRootPath = void 0;
+			const mtime = {
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime: 0
+			}.mtime;
+			seenUuids.add(cachedUuid);
+			results.push({
+				uuid: cachedUuid,
+				shortId: cachedUuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath: "",
+				topLevelSystemLines: 0,
+				topLevelSize: 0,
+				resumable: false,
+				sessionStatus: "transcript-only",
+				sessionJsonlPath: void 0,
+				userLines: 0,
+				lastUserPrompt: "",
+				msgCount: 0,
+				mtime,
+				friendlyName: clcInfo.name,
+				clcDirectory: clcInfo.directory,
+				registryRootPath
+			});
+			continue;
+		}
+		const foundTranscriptPath = existsSync(join(CLAUDE_PROJECTS_DIR, foundEncodedDir, "sessions", `${cachedUuid}.jsonl`)) ? join(CLAUDE_PROJECTS_DIR, foundEncodedDir, "sessions", `${cachedUuid}.jsonl`) : void 0;
+		const decodedPath = clcInfo.directory ?? smartDecodeDir(foundEncodedDir) ?? foundEncodedDir.replace(/-/g, "/");
+		const registryRootPath = rootPathMap.get(foundEncodedDir);
+		const topLevelPath = join(CLAUDE_PROJECTS_DIR, foundEncodedDir, `${cachedUuid}.jsonl`);
+		const transcript = foundTranscriptPath ? parseTranscript(foundTranscriptPath) : {
+			userLines: 0,
+			lastUserPrompt: "",
+			msgCount: 0,
+			mtime: 0
+		};
+		seenUuids.add(cachedUuid);
+		results.push({
+			uuid: cachedUuid,
+			shortId: cachedUuid.slice(0, 8),
+			encodedDir: foundEncodedDir,
+			decodedPath,
+			topLevelPath,
+			topLevelSystemLines: 0,
+			topLevelSize: 0,
+			resumable: false,
+			sessionStatus: "transcript-only",
+			sessionJsonlPath: foundTranscriptPath,
+			userLines: transcript.userLines,
+			lastUserPrompt: transcript.lastUserPrompt,
+			msgCount: transcript.msgCount,
+			aiTitle: transcript.aiTitle,
+			mtime: transcript.mtime,
+			friendlyName: clcInfo.name,
+			clcDirectory: clcInfo.directory,
+			registryRootPath
+		});
+	}
+	results.sort((a, b) => b.mtime - a.mtime);
+	return results.slice(0, limit);
+}
+/** Claude Code's project-dir encoding: replace /  .  -  (space) with - */
+function encodeProjectDir(realPath) {
+	return realPath.replace(/[/.\- ]/g, "-");
+}
+/** realpathSync that returns null instead of throwing */
+function realpathSyncSafe(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+function fmtAge(mtime) {
+	const diffMs = Date.now() - mtime;
+	const diffMin = Math.floor(diffMs / 6e4);
+	const diffHr = Math.floor(diffMs / 36e5);
+	const diffDay = Math.floor(diffMs / 864e5);
+	if (diffMin < 60) return `${diffMin}m`;
+	if (diffHr < 24) return `${diffHr}h`;
+	if (diffDay < 30) return `${diffDay}d`;
+	return `${Math.floor(diffDay / 30)}mo`;
+}
+/**
+* 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 session found matching "${query}".\n\nRun: pai sessions          to list sessions.\nRun: pai sessions --all    to include transcript-only sessions.`);
+}
+
+//#endregion
+//#region src/cli/lib/aibroker-client.ts
+/**
+* aibroker-client.ts — Lightweight IPC client for AIBroker daemon.
+*
+* Connects to the AIBroker Unix Domain Socket, sends a JSON-RPC request,
+* and reads a single newline-terminated JSON response. No class needed —
+* just a thin async function matching the WatcherClient protocol.
+*
+* Socket path: /tmp/aibroker.sock (default; override via AIBROKER_SOCKET env).
+*/
+const DEFAULT_SOCKET = process.env.AIBROKER_SOCKET ?? "/tmp/aibroker.sock";
+/**
+* Call an AIBroker IPC method and return the result.
+*
+* Resolves with the `result` field of a successful response.
+* Rejects if the socket is not available, the call times out, or the
+* daemon returns an error.
+*
+* @param method   IPC method name (e.g. "session_content", "send_to_session")
+* @param params   Method parameters object
+* @param timeoutMs  Connection + response timeout in milliseconds (default: 8 000)
+*/
+function callAiBroker(method, params = {}, timeoutMs = 8e3) {
+	return new Promise((resolve, reject) => {
+		const socketPath = DEFAULT_SOCKET;
+		let done = false;
+		let buffer = "";
+		let timer = null;
+		function finish(err, value) {
+			if (done) return;
+			done = true;
+			if (timer !== null) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			try {
+				socket.destroy();
+			} catch {}
+			if (err) reject(err);
+			else resolve(value);
+		}
+		const socket = connect(socketPath, () => {
+			const request = {
+				id: randomUUID(),
+				sessionId: process.env.TERM_SESSION_ID ?? "pai-cli",
+				method,
+				params
+			};
+			const itermId = process.env.ITERM_SESSION_ID;
+			if (itermId) Object.assign(request, { itermSessionId: itermId });
+			socket.write(JSON.stringify(request) + "\n");
+		});
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString("utf8");
+			const nl = buffer.indexOf("\n");
+			if (nl === -1) return;
+			const line = buffer.slice(0, nl);
+			let response;
+			try {
+				response = JSON.parse(line);
+			} catch {
+				finish(/* @__PURE__ */ new Error(`AIBroker IPC parse error: ${line.slice(0, 120)}`));
+				return;
+			}
+			if (!response.ok) finish(new Error(response.error ?? "AIBroker IPC call failed"));
+			else finish(null, response.result ?? {});
+		});
+		socket.on("error", (e) => {
+			if (e.code === "ENOENT" || e.code === "ECONNREFUSED") finish(/* @__PURE__ */ new Error("AIBroker not running (socket not found)."));
+			else finish(e);
+		});
+		socket.on("end", () => {
+			if (!done) finish(/* @__PURE__ */ new Error("AIBroker IPC connection closed before response."));
+		});
+		timer = setTimeout(() => finish(/* @__PURE__ */ new Error("AIBroker IPC call timed out.")), timeoutMs);
+	});
+}
+/**
+* Fetch all live iTerm2 sessions from AIBroker.
+* Returns an empty array if AIBroker is not running.
+*/
+async function fetchLiveSessions() {
+	try {
+		const sessions = (await callAiBroker("session_content", { lineCount: 0 })).sessions;
+		if (!Array.isArray(sessions)) return [];
+		return sessions;
+	} catch {
+		return [];
+	}
+}
+/**
+* Send text to a specific AIBroker session by its iTerm2 sessionId.
+*/
+async function sendToSession(sessionId, text) {
+	try {
+		await callAiBroker("send_to_session", {
+			sessionId,
+			text
+		});
+		return { ok: true };
+	} catch (e) {
+		return {
+			ok: false,
+			error: String(e)
+		};
+	}
+}
+
+//#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 renderLiveSessions(liveSessions) {
+	if (liveSessions.length === 0) return;
+	console.log("\n" + header("Live Sessions") + "\n");
+	const liveHeaders = [
+		"#",
+		"iTerm2 id",
+		"name",
+		"at prompt",
+		"paiName"
+	];
+	const liveRows = liveSessions.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 ? s.paiName.length > 20 ? s.paiName.slice(0, 19) + "…" : s.paiName : dim("—");
+		const atPrompt = s.atPrompt ? chalk.green("yes") : chalk.yellow("busy");
+		return [
+			chalk.dim(String(idx + 1)),
+			chalk.cyan(shortId),
+			name,
+			atPrompt,
+			paiName
+		];
+	});
+	console.log(renderTable(liveHeaders, liveRows));
+}
+async function cmdRecent(db, opts) {
+	const limit = parseInt(opts.n ?? "20", 10);
+	const includeAll = opts.all === true;
+	const liveSessions = await fetchLiveSessions();
+	const sessions = scanSessions(db, {
+		limit,
+		filter: includeAll ? "all" : "named"
+	});
+	if (opts.json) {
+		const output = {
+			live: liveSessions.map((s) => ({
+				sessionId: s.sessionId,
+				name: s.name,
+				paiName: s.paiName ?? null,
+				atPrompt: s.atPrompt
+			})),
+			paused: 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;
+	}
+	if (liveSessions.length > 0) renderLiveSessions(liveSessions);
+	if (sessions.length === 0) {
+		if (liveSessions.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;
+	}
+	const title = includeAll ? "Paused / All Sessions (named + orphans)" : "Paused / Resumable 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" + (liveSessions.length > 0 ? dim("Pause all live:    ") + chalk.white("pai pause all") + "\n" : "") + (includeAll ? "" : dim("Show all sessions: ") + chalk.white("pai sessions --all") + "\n"));
+}
+
+//#endregion
+//#region src/cli/commands/session/goto.ts
+/**
+* Run  claude --resume <uuid> --print --output-format=json "_"  in the given cwd.
+* Returns ok=true if the session is resumable (exit 0 and no "No conversation found"
+* in stderr).  Timeout: 5 seconds.
+*/
+function probeResume(uuid, cwd) {
+	const result = spawnSync("claude", [
+		"--resume",
+		uuid,
+		"--print",
+		"--output-format=json",
+		"_"
+	], {
+		cwd,
+		timeout: 5e3,
+		env: process.env,
+		stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		]
+	});
+	if (result.error) return {
+		ok: false,
+		reason: `spawn error: ${result.error.message}`
+	};
+	const stderr = result.stderr?.toString("utf8") ?? "";
+	if (stderr.toLowerCase().includes("no conversation found") || stderr.toLowerCase().includes("session not found")) return {
+		ok: false,
+		reason: "No conversation found for this UUID"
+	};
+	if (result.status !== 0) return {
+		ok: false,
+		reason: `claude exited ${result.status ?? "signal"}${stderr ? `: ${stderr.slice(0, 120).trim()}` : ""}`
+	};
+	return { ok: true };
+}
+function 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 name = friendlyName ?? query;
+	const promptArg = `/Name ${name}\ngo`;
+	if (opts.dryRun) {
+		if (resumableUuid) {
+			const argvResume = `claude --resume ${resumableUuid} --name "${name}" "/Name ${name}\\ngo"`;
+			const argvFresh = `claude --name "${name}" "/Name ${name}\\ngo"`;
+			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:     ${chalk.white(argvResume)}`);
+			console.log(`  fallback: ${chalk.yellow(argvFresh)}`);
+			if (resumableSession) {
+				console.log(`\n  uuid:     ${resumableSession.uuid}`);
+				console.log(`  age:      ${fmtAge(resumableSession.mtime)}`);
+				console.log(`  status:   ${resumableSession.sessionStatus}`);
+				console.log(`  sys:      ${resumableSession.topLevelSystemLines} system lines`);
+			}
+		} else {
+			const argvFresh = `claude --name "${name}" "/Name ${name}\\ngo"`;
+			console.log("\n" + chalk.bold("Dry run — would exec (FRESH path, no resumable UUID):") + "\n");
+			console.log(`  cwd:   ${chalk.cyan(projectDir)}`);
+			console.log(`  argv:  ${chalk.white(argvFresh)}`);
+		}
+		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);
+	}
 }
 
 //#endregion
-//#region src/cli/commands/session/handover.ts
+//#region src/cli/commands/session/pause.ts
 const HANDOVER_TODO_LOCATIONS = [
 	"Notes/TODO.md",
 	".claude/Notes/TODO.md",
@@ -1854,28 +2758,19 @@ function stripContinueSection(content) {
 	while (after.length > 0 && after[0].trim() === "") after.shift();
 	return [...before, ...after].join("\n");
 }
-function cmdHandover(db, projectSlug, numberOrLatest) {
-	let project;
-	if (projectSlug) {
-		project = db.prepare("SELECT id, slug, display_name, root_path, encoded_dir FROM projects WHERE slug = ?").get(projectSlug);
-		if (!project) process.exit(0);
-	} else {
-		const cwd = process.cwd();
-		const row = 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 (!row) process.exit(0);
-		project = row;
-	}
-	let session;
-	const nol = numberOrLatest ?? "latest";
-	if (nol === "latest") session = db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(project.id);
-	else {
-		const num = parseInt(nol, 10);
-		if (!isNaN(num)) session = db.prepare("SELECT * FROM sessions WHERE project_id = ? AND number = ?").get(project.id, num);
+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;
@@ -1884,23 +2779,23 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 		existingContent = todo.content;
 	} else {
 		const notesDir = join(project.root_path, "Notes");
-		try {
+		if (!opts.dryRun) try {
 			if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
-		} catch {
-			process.exit(0);
+		} 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();
-	const cwd = process.cwd();
 	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 newContent = [
+	const continueBlock = [
 		"## Continue",
 		"",
 		`> **Last session:** ${sessionLine}`,
@@ -1910,51 +2805,322 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 		"",
 		"---",
 		""
-	].join("\n") + stripContinueSection(existingContent).trimStart();
-	const tmpPath = `${todoPath}.handover.tmp`;
-	try {
-		writeFileSync(tmpPath, newContent, "utf8");
-		renameSync(tmpPath, todoPath);
-	} catch {
+	].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 {
-			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
-		} catch {}
-		process.exit(0);
+			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));
 	}
-	process.exit(0);
+	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/end.ts
+/** PAI_DIR — mirrors pai-paths.ts resolution. */
+function getPaiDir() {
+	const envDir = process.env.PAI_DIR;
+	if (envDir) try {
+		return realpathSync(envDir);
+	} catch {
+		return envDir;
+	}
+	return join(homedir(), ".claude");
+}
+/**
+* Find the notes directory for a project — checks local first, then central.
+* Returns null if neither exists (dry-run safe: don't create).
+*/
+function findNotesDir$1(rootPath, encodedDir) {
+	for (const rel of [
+		"Notes",
+		"notes",
+		".claude/Notes"
+	]) {
+		const p = join(rootPath, rel);
+		if (existsSync(p)) return p;
+	}
+	const central = join(getPaiDir(), "projects", encodedDir, "Notes");
+	if (existsSync(central)) return central;
+	return null;
+}
+/**
+* Find the current (latest) session note inside notesDir.
+* Searches YYYY/MM subdirectory (current month, then previous month),
+* then flat notesDir as legacy fallback.
+*/
+function findLatestNote(notesDir) {
+	const findIn = (dir) => {
+		if (!existsSync(dir)) return null;
+		const files = readdirSync(dir).filter((f) => /^\d{3,4}[\s_-].*\.md$/.test(f)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] ?? "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] ?? "0", 10);
+		});
+		return files.length > 0 ? join(dir, files[files.length - 1]) : null;
+	};
+	const now = /* @__PURE__ */ new Date();
+	const current = findIn(join(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (current) return current;
+	const prev = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findIn(join(notesDir, String(prev.getFullYear()), String(prev.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findIn(notesDir);
+}
+function finalizeNote(notePath) {
+	const content = readFileSync(notePath, "utf-8");
+	if (content.includes("**Status:** Completed")) return {
+		finalized: false,
+		path: notePath
+	};
+	let updated = content.replace("**Status:** In Progress", "**Status:** Completed");
+	if (!updated.includes("**Completed:**")) {
+		const completionTime = (/* @__PURE__ */ new Date()).toISOString();
+		updated = updated.replace("---\n\n## Work Done", `**Completed:** ${completionTime}\n\n---\n\n## Work Done`);
+	}
+	const tmp = `${notePath}.end.tmp`;
+	writeFileSync(tmp, updated, "utf-8");
+	renameSync(tmp, notePath);
+	return {
+		finalized: true,
+		path: notePath
+	};
+}
+function cmdEnd(db, opts) {
+	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) return;
+	const notesDir = findNotesDir$1(project.root_path, project.encoded_dir ?? "");
+	if (!notesDir) {
+		console.log(chalk.dim("  (No session note found — notes directory does not exist yet.)"));
+		printEndBox(opts.dryRun);
+		return;
+	}
+	const notePath = findLatestNote(notesDir);
+	if (!notePath) {
+		console.log(chalk.dim("  (No session note found in notes directory.)"));
+		printEndBox(opts.dryRun);
+		return;
+	}
+	if (opts.dryRun) {
+		console.log("\n" + chalk.bold("Dry run — would finalize session note:") + " " + chalk.cyan(notePath));
+		console.log(chalk.dim("  Would replace: **Status:** In Progress\n            with: **Status:** Completed"));
+		console.log(chalk.dim("  Would add: **Completed:** <timestamp>"));
+	} else {
+		const { finalized, path } = finalizeNote(notePath);
+		if (finalized) console.log(chalk.green("  Session note finalized: ") + chalk.cyan(basename(path)));
+		else console.log(chalk.dim(`  Session note already marked Completed: ${basename(notePath)}`));
+	}
+	printEndBox(opts.dryRun);
+}
+function printEndBox(dryRun) {
+	const label = dryRun ? " (dry-run)" : "";
+	const box = [
+		"",
+		chalk.bgRed.white.bold(`  SESSION ENDING${label}: 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("    - The session note is NOT written to by the stop-hook"),
+		chalk.dim("    - The session becomes orphaned (cannot --resume next time)"),
+		chalk.dim("    - The final session summary is never generated"),
+		"",
+		chalk.dim("  ## Continue checkpoint and session note status are already saved."),
+		chalk.dim("  Use /exit to let PAI's stop-hook finalize the session fully."),
+		""
+	].join("\n");
+	console.log(box);
+}
+
+//#endregion
+//#region src/cli/commands/session/pause-all.ts
+/**
+* pai pause all [--exit] [--dry-run]
+*
+* Pause every live Claude Code session that AIBroker knows about.
+*
+* For each live session returned by AIBroker's session_content IPC method:
+*   1. Send "pause session" to the iTerm2 pane via send_to_session.
+*   2. Optionally send "\n/exit\n" after a short delay (--exit flag).
+*   3. Print a summary of what was sent and to which sessions.
+*
+* If AIBroker is not running, prints a clear error and exits.
+* If no live sessions are found, reports "nothing to pause".
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sessionLabel(s) {
+	const name = s.paiName ?? s.name;
+	return `${chalk.cyan(s.sessionId.slice(0, 8))} ${chalk.bold(name)}`;
+}
+async function cmdPauseAll(opts) {
+	const waitMs = opts.wait ?? 5e3;
+	let liveSessions;
+	try {
+		liveSessions = await fetchLiveSessions();
+	} catch (e) {
+		console.error(err("AIBroker is not running. Cannot list live sessions."));
+		console.error(dim("  Start AIBroker or run `pai pause` from each session manually."));
+		process.exitCode = 1;
+		return;
+	}
+	const claudeSessions = liveSessions.filter((s) => s.paiName !== null && s.paiName !== void 0 && s.paiName !== "");
+	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) {
+		console.log(warn("No live Claude sessions found via AIBroker. Nothing to pause."));
+		return;
+	}
+	if (opts.dryRun) {
+		console.log("\n" + header("Dry Run — Would Pause These Sessions") + "\n");
+		for (const s of claudeSessions) {
+			console.log("  " + sessionLabel(s));
+			console.log(dim("    → send: \"pause session\""));
+			if (opts.exit) console.log(dim(`    → wait ${waitMs}ms then send: "/exit"`));
+		}
+		console.log();
+		return;
+	}
+	console.log("\n" + header("Pausing All Live Sessions") + "\n" + dim(`  ${claudeSessions.length} Claude session(s) via AIBroker`) + "\n");
+	const results = [];
+	for (const s of claudeSessions) {
+		process.stdout.write("  " + sessionLabel(s) + " … ");
+		const pauseResult = await sendToSession(s.sessionId, "pause session\n");
+		if (!pauseResult.ok) {
+			console.log(err("FAILED: " + (pauseResult.error ?? "unknown error")));
+			results.push({
+				session: s,
+				pauseOk: false,
+				error: pauseResult.error
+			});
+			continue;
+		}
+		console.log(ok("paused"));
+		results.push({
+			session: s,
+			pauseOk: true
+		});
+	}
+	if (opts.exit) {
+		const pausedSessions = results.filter((r) => r.pauseOk).map((r) => r.session);
+		if (pausedSessions.length > 0) {
+			console.log("\n" + dim(`  Waiting ${waitMs / 1e3}s for sessions to save state…`));
+			await sleep(waitMs);
+			console.log();
+			for (const s of pausedSessions) {
+				process.stdout.write("  " + sessionLabel(s) + " exiting … ");
+				const exitResult = await sendToSession(s.sessionId, "/exit\n");
+				const rec = results.find((r) => r.session.sessionId === s.sessionId);
+				rec.exitOk = exitResult.ok;
+				if (!exitResult.ok) console.log(warn("exit failed: " + (exitResult.error ?? "unknown")));
+				else console.log(ok("exited"));
+			}
+		}
+	}
+	const total = results.length;
+	const succeeded = results.filter((r) => r.pauseOk).length;
+	const failed = total - succeeded;
+	console.log();
+	if (failed === 0) console.log(ok(`All ${total} session(s) paused successfully.`));
+	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;
+			console.log(err(`  ${label}: ${r.error ?? "unknown error"}`));
+		}
+	}
+	if (opts.exit) {
+		const exitOk = results.filter((r) => r.exitOk).length;
+		console.log(dim(`  /exit sent to ${exitOk} session(s).`));
+	}
+	console.log();
 }
 
 //#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/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) => {
+		await cmdRecent(getDb(), opts);
 	});
-	sessionCmd.command("info <project-slug> <number>").description("Show full details for a specific session").action((projectSlug, number) => {
+	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) => {
+		cmdGoto(getDb(), nameOrId, { 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("pause-all").description("Pause every live Claude Code session via AIBroker.\nRequires AIBroker to be running. Sends 'pause session' to each live iTerm2 pane.\nTop-level short form: pai pause all").option("--exit", "Also send /exit to each session after it has saved state").option("--wait <ms>", "Milliseconds to wait before /exit (default: 5000)", "5000").option("--dry-run", "Show what would be sent without actually sending").action(async (opts) => {
+		await cmdPauseAll({
+			exit: opts.exit,
+			dryRun: opts.dryRun,
+			wait: opts.wait !== void 0 ? parseInt(opts.wait, 10) : void 0
+		});
+	});
+	sessionsCmd.command("end").description("Finalize a session: write ## Continue checkpoint + mark session note Completed.\nRecommended short form: pai end\nUse /exit inside Claude Code after running this command.").option("--dry-run", "Preview all changes without writing them").action((opts) => {
+		cmdEnd(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 +3468,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 +3489,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 +3813,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 +3918,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 +3956,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 +4697,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-B-vBWU1i.mjs").then((n) => n.t);
+		const { loadConfig: lc, ensureConfigDir } = await import("../config-DqBY3aT0.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());
 	});
@@ -6416,7 +7319,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 +7383,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 +7452,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 +7505,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 +7556,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 +7617,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 +9032,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 end / pai resume / pai cd
+*   pai sessions / pai projects / pai notes
 */
 function getVersion() {
 	try {
@@ -8156,11 +9063,30 @@ 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 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
+
+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, end, ...)
+  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 +9105,67 @@ 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 [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,
+		dryRun: opts.dryRun,
+		wait: opts.wait !== void 0 ? parseInt(opts.wait, 10) : void 0
+	});
+	else {
+		if (target !== void 0) {
+			console.error(`Unknown target: ${target}. Did you mean 'pai pause all'?`);
+			process.exitCode = 1;
+			return;
+		}
+		cmdPause(getDb(), { dryRun: opts.dryRun });
+	}
+});
+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) => {
+	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);
+	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`);
 });