@tekmidian/pai 0.9.14 → 0.9.15

package/dist/cli/index.mjs

@@ -20,8 +20,10 @@ import { appendFileSync, chmodSync, copyFileSync, existsSync, lstatSync, mkdirSy
 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";
@@ -1942,13 +1944,26 @@ function cmdHandover(db, projectSlug, numberOrLatest) {
 *   line of type "system". Sessions that only have a sessions/ counterpart cannot be
 *   resumed by Claude Code regardless of how much transcript content they have.
 *
-* Scan strategy:
-*   1. Walk top-level <project>/<uuid>.jsonl files (fast: ~20 files total).
-*   2. For each, check system line count to set the resumable flag.
-*   3. Join with sessions/<uuid>.jsonl (if present) for user lines, last prompt, ai-title.
-*   4. Enrich with clc name registry and PAI registry root path.
+* 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.
 *
-* Used by: pai session recent, pai session resume
+* 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. */
@@ -2082,7 +2097,11 @@ function resolveFilter(opts) {
 * Scan ~/.claude/projects/ for all Claude Code sessions.
 *
 * Pass 1: walk top-level <project>/<uuid>.jsonl files (the resumability source).
-* Pass 2: add clc registry entries that have no top-level jsonl (transcript-only).
+* 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)
@@ -2099,12 +2118,14 @@ function scanSessions(db, opts = {}) {
 	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 {
@@ -2131,8 +2152,7 @@ function scanSessions(db, opts = {}) {
 			const clcInfo = clcInfoMap.get(uuid);
 			const inRegistry = !!clcInfo;
 			const sessionStatus = resumable ? "resumable" : inRegistry ? "stub" : "orphan";
-			if (filterMode === "resumable" && !resumable) continue;
-			if (filterMode === "named" && !resumable && !inRegistry) continue;
+			const 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) : {
@@ -2143,8 +2163,7 @@ function scanSessions(db, opts = {}) {
 			};
 			const mtime = topInfo.mtime || transcript.mtime;
 			const friendlyName = clcInfo?.name ?? transcript.aiTitle ?? projectBasename ?? void 0;
-			seenUuids.add(uuid);
-			results.push({
+			const session = {
 				uuid,
 				shortId: uuid.slice(0, 8),
 				encodedDir,
@@ -2163,48 +2182,90 @@ function scanSessions(db, opts = {}) {
 				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 [uuid, clcInfo] of clcInfoMap) {
-		if (seenUuids.has(uuid)) continue;
+	if (filterMode !== "resumable") for (const [cachedUuid, clcInfo] of clcInfoMap) {
+		if (attachedClcUuids.has(cachedUuid)) continue;
 		let foundEncodedDir;
-		let foundTranscriptPath;
-		if (clcInfo.directory) try {
+		if (clcInfo.directory) {
 			const real = realpathSyncSafe(clcInfo.directory);
 			if (real) {
 				const encoded = encodeProjectDir(real);
-				const candidateTranscript = join(CLAUDE_PROJECTS_DIR, encoded, "sessions", `${uuid}.jsonl`);
-				if (existsSync(candidateTranscript)) {
-					foundEncodedDir = encoded;
-					foundTranscriptPath = candidateTranscript;
-				} else if (existsSync(join(CLAUDE_PROJECTS_DIR, encoded))) foundEncodedDir = encoded;
+				if (existsSync(join(CLAUDE_PROJECTS_DIR, encoded))) foundEncodedDir = encoded;
 			}
-		} catch {}
-		if (!foundEncodedDir) for (const encodedDir of encodedDirs) {
-			const candidateTranscript = join(CLAUDE_PROJECTS_DIR, encodedDir, "sessions", `${uuid}.jsonl`);
-			if (existsSync(candidateTranscript)) {
+		}
+		if (!foundEncodedDir) {
+			for (const encodedDir of encodedDirs) if (existsSync(join(CLAUDE_PROJECTS_DIR, encodedDir, "sessions", `${cachedUuid}.jsonl`))) {
 				foundEncodedDir = encodedDir;
-				foundTranscriptPath = candidateTranscript;
 				break;
 			}
 		}
-		const encodedDir = foundEncodedDir ?? "";
-		const decodedPath = clcInfo.directory ?? (foundEncodedDir ? smartDecodeDir(foundEncodedDir) ?? foundEncodedDir.replace(/-/g, "/") : uuid);
-		const registryRootPath = foundEncodedDir ? rootPathMap.get(foundEncodedDir) : void 0;
-		const topLevelPath = foundEncodedDir ? join(CLAUDE_PROJECTS_DIR, foundEncodedDir, `${uuid}.jsonl`) : "";
+		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
 		};
-		const mtime = transcript.mtime;
-		seenUuids.add(uuid);
+		seenUuids.add(cachedUuid);
 		results.push({
-			uuid,
-			shortId: uuid.slice(0, 8),
-			encodedDir,
+			uuid: cachedUuid,
+			shortId: cachedUuid.slice(0, 8),
+			encodedDir: foundEncodedDir,
 			decodedPath,
 			topLevelPath,
 			topLevelSystemLines: 0,
@@ -2216,7 +2277,7 @@ function scanSessions(db, opts = {}) {
 			lastUserPrompt: transcript.lastUserPrompt,
 			msgCount: transcript.msgCount,
 			aiTitle: transcript.aiTitle,
-			mtime,
+			mtime: transcript.mtime,
 			friendlyName: clcInfo.name,
 			clcDirectory: clcInfo.directory,
 			registryRootPath
@@ -2282,7 +2343,116 @@ function resolveSessionByNameOrId(sessions, query) {
 		const candidates = byUuid.slice(0, 5).map((s, i) => `  ${i + 1}. ${s.shortId}  ${s.friendlyName ?? s.decodedPath}  (${fmtAge(s.mtime)} ago)`).join("\n");
 		throw new Error(`UUID prefix "${query}" is ambiguous — ${byUuid.length} matches:\n${candidates}\n\nProvide more characters.`);
 	}
-	throw new Error(`No resumable session found matching "${query}".\n\nRun: pai session recent          to list resumable sessions.\nRun: pai session recent --all    to include transcript-only sessions.`);
+	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
@@ -2300,38 +2470,73 @@ function fmtStatus(status) {
 		case "orphan": return chalk.dim("orphan");
 	}
 }
-function cmdRecent(db, opts) {
+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 (sessions.length === 0) {
-		if (includeAll) console.log(err("No sessions found in ~/.claude/projects/."));
-		else console.log(err("No named sessions found.\n\n  Named sessions appear when you have entries in ~/.claude/session.json\n  (set via /Name inside Claude Code) or resumable top-level jsonl files.\n  Run: pai session recent --all  to list all sessions including unnamed orphans."));
-		return;
-	}
 	if (opts.json) {
-		const output = sessions.map((s, idx) => ({
-			idx: idx + 1,
-			uuid: s.uuid,
-			shortId: s.shortId,
-			resumable: s.resumable,
-			sessionStatus: s.sessionStatus,
-			age: fmtAge(s.mtime),
-			mtime: s.mtime,
-			name: s.friendlyName,
-			lastUserPrompt: s.lastUserPrompt,
-			userLines: s.userLines,
-			msgCount: s.msgCount,
-			topLevelSize: s.topLevelSize,
-			decodedPath: s.decodedPath
-		}));
+		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;
 	}
-	const title = includeAll ? "All Sessions (named + orphans)" : "Named Sessions";
+	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 = [
 		"#",
@@ -2358,11 +2563,48 @@ function cmdRecent(db, opts) {
 		];
 	});
 	console.log(renderTable(headers, rows));
-	console.log("\n" + dim("Go to a session:   ") + chalk.white("pai resume <name>") + "\n" + (includeAll ? "" : dim("Show all sessions: ") + chalk.white("pai sessions --all") + "\n"));
+	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,
@@ -2397,44 +2639,84 @@ function cmdGoto(db, query, opts) {
 		console.error(err(`session "${query}": directory does not exist or cannot be resolved.\n  Registry says: ${rawDir}\n  The directory may have moved or been deleted.`));
 		process.exit(1);
 	}
-	const useName = !opts.noName && !!friendlyName;
-	const useGo = !opts.noGo;
-	let promptArg = null;
-	if (useName && friendlyName) promptArg = useGo ? `/Name ${friendlyName}\ngo` : `/Name ${friendlyName}`;
-	else if (useGo) promptArg = "go";
-	const fullArgv = resumableUuid ? [
-		"claude",
-		"--resume",
-		resumableUuid,
-		...promptArg ? [promptArg] : []
-	] : ["claude", ...promptArg ? [promptArg] : []];
+	const name = friendlyName ?? query;
+	const promptArg = `/Name ${name}\ngo`;
 	if (opts.dryRun) {
-		const mode = resumableUuid ? "RESUME" : "FRESH";
-		console.log("\n" + chalk.bold(`Dry run — would execute (${mode}):`) + "\n");
-		console.log(`  cwd:            ${chalk.cyan(projectDir)}`);
-		const argDisplay = fullArgv.map((a) => a.includes("\n") ? `"${a.replace(/\n/g, "\\n")}"` : a.startsWith("/Name") ? `"${a}"` : a).join(" ");
-		console.log(`  argv:           ${chalk.white(argDisplay)}`);
-		if (useName && friendlyName) console.log(`  name:           ${chalk.green(friendlyName)}`);
-		if (resumableSession) {
-			console.log(`\n  session:        ${resumableSession.uuid}`);
-			console.log(`  age:            ${fmtAge(resumableSession.mtime)}`);
-			console.log(`  system lines:   ${resumableSession.topLevelSystemLines}`);
-			console.log(`  user msgs:      ${resumableSession.userLines > 0 ? resumableSession.userLines : "—"}`);
-		} else console.log(`\n  mode:           ${chalk.yellow("fresh session (no resumable snapshot)")}`);
-		console.log(`  project path:   ${matchedSession.decodedPath}`);
+		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;
 	}
-	const result = spawnSync(fullArgv[0], fullArgv.slice(1), {
-		cwd: projectDir,
-		stdio: "inherit",
-		env: process.env
-	});
-	if (result.error) {
-		console.error(err(`Failed to launch claude: ${result.error.message}`));
-		process.exit(1);
+	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);
 	}
-	process.exit(result.status ?? 0);
 }
 
 //#endregion
@@ -2564,25 +2846,255 @@ function cmdPause(db, opts) {
 	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/sessions-index.ts
 function registerSessionsCommands(sessionsCmd, getDb) {
-	sessionsCmd.command("list", { isDefault: true }).description("Resumable sessions catalog — named sessions with resume status.\nShort form: pai sessions (bare, no subcommand)\nUse --all to also show unnamed orphan sessions.").option("-n <count>", "Maximum sessions to show (default: 20)", "20").option("--all", "Include unnamed orphan sessions (not in clc registry)").option("--json", "Output raw JSON instead of formatted table").action((opts) => {
-		cmdRecent(getDb(), opts);
+	sessionsCmd.command("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);
 	});
-	sessionsCmd.command("goto <name-or-id>").description("Go to a session: resume if a resumable snapshot exists, start fresh otherwise.\nRecommended short form: pai resume <name>\nResolves by clc/registry name (case-insensitive) or UUID prefix.").option("--skip-name", "Do not prepend /Name to restore the session name").option("--skip-go", "Do not append \\ngo to trigger PAI auto-resume").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((nameOrId, opts) => {
-		cmdGoto(getDb(), nameOrId, {
-			noName: opts.skipName,
-			noGo: opts.skipGo,
-			dryRun: opts.dryRun
-		});
+	sessionsCmd.command("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("recent").description("[Deprecated] Use `pai sessions list` instead.").option("-n <count>", "Maximum sessions to show (default: 20)", "20").option("--all", "Include unnamed orphan sessions (not in clc registry)").option("--json", "Output raw JSON instead of formatted table").action((opts) => {
-		process.stderr.write("Deprecated: `pai sessions recent` — use `pai sessions list` instead.\n");
-		cmdRecent(getDb(), opts);
+	sessionsCmd.command("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);
@@ -4185,7 +4697,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("../daemon-BryEC3as.mjs").then((n) => n.t);
+		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());
@@ -8529,7 +9041,7 @@ function registerDbCommands(dbCmd) {
 *   pai version
 *
 * Daily verb shortcuts (top-level):
-*   pai pause / pai resume / pai cd
+*   pai pause / pai end / pai resume / pai cd
 *   pai sessions / pai projects / pai notes
 */
 function getVersion() {
@@ -8554,6 +9066,7 @@ const program = new Command();
 program.name("pai").description("PAI Knowledge OS — Personal AI Infrastructure CLI").version(getVersion(), "-V, --version", "Print version and exit").addHelpText("after", `
 Daily verbs (short forms):
   pai pause               Save state + display safe-exit reminder
+  pai end                 Finalize session: pause + mark note Completed
   pai resume <name>       Go to a session (resume or start fresh)
   pai cd <name>           cd to a project directory
 
@@ -8563,7 +9076,7 @@ Listings:
   pai notes               Markdown session notes
 
 Subcommands (power users):
-  pai sessions ...        Session management (list, goto, pause, ...)
+  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, ...)
@@ -8592,15 +9105,26 @@ registerObservationCommands(program.command("observation").description("Observat
 program.command("go <query>").description("Jump to a project directory by slug or partial name.\nPrints the root path to stdout — use with: cd $(pai go <query>)\nExample shell function in ~/.zshrc:\n  pcd() { cd \"$(pai go \"$@\")\" }").action((query) => {
 	cmdGo(getDb(), query);
 });
-program.command("pause").description("Save state and display safe-exit instructions for the current session.\nWrites a ## Continue checkpoint to the project's TODO.md.\nLong form: pai sessions pause").option("--dry-run", "Preview the ## Continue block without writing it").action((opts) => {
-	cmdPause(getDb(), opts);
-});
-program.command("resume <name>").description("Go to a session by name: resume if resumable, start fresh otherwise.\nLong form: pai sessions goto <name>").option("--skip-name", "Do not prepend /Name to restore the session name").option("--skip-go", "Do not append \\ngo to trigger PAI auto-resume").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((name, opts) => {
-	cmdGoto(getDb(), name, {
-		noName: opts.skipName,
-		noGo: opts.skipGo,
-		dryRun: opts.dryRun
+program.command("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);