@tekmidian/pai 0.14.2 → 0.16.0

package/dist/{pick-gne3kOJG.mjs → pick-B3zEYjin.mjs}

@@ -1,18 +1,20 @@
-import { a as openRegistry, i as indexProject, n as indexAll, t as embedChunks } from "./sync-uPR4g438.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$1, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold$1, u as resolvePath } from "./utils-CqqgB0dH.mjs";
-import { a as slugify$1, i as parseSessionFilename } from "./migrate-B02wDDgS.mjs";
-import { n as ensurePaiMarker } from "./pai-marker-HVBwwBW-.mjs";
-import { n as openFederation } from "./db-CmYbAVCD.mjs";
-import { n as populateSlugs, r as searchMemory } from "./search-HcdKtMla.mjs";
-import { n as formatDetection, r as formatDetectionJson, t as detectProject } from "./detect-KjycLtXM.mjs";
-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-C8DEUHTS.mjs";
-import { t as createStorageBackend } from "./factory-Q88X1bAN.mjs";
-import { t as PaiClient } from "./ipc-client-CoyUHPod.mjs";
-import { a as expandHome, c as UNROUTED, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, s as OWNER_LABEL_PREFIX, t as CONFIG_DIR } from "./config-C8m-tPhP.mjs";
-import { s as kgQuery } from "./kg-entity-LXblD7LZ.mjs";
-import { a as renderDedupedSessions, c as revealItermSession, d as fmtAge, f as resolveSessionByNameOrId, i as normalizeName, l as sendToSession, o as callAiBroker, p as scanSessions, r as buildDeduped, s as fetchLiveSessions, u as printExitDir } from "./main-resolver-uFxNiDy7.mjs";
+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$1, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold$1, 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-B20KqhA8.mjs";
+import { n as openFederation } from "./db-CYmBWcjh.mjs";
+import { i as indexProject, n as indexAll, t as embedChunks } from "./sync-CmBKOL3K.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-Bf2z-oKB.mjs";
+import { a as readBodyFile, c as loadScanConfig, d as saveScanConfig, f as upsertProject, i as findNotesDir$1, n as applyContinue, o as extractAndStoreTriples, p as upsertSession, r as findLatestNote, s as cmdScan, t as appendCheckpointToNote, u as resolveHome } from "./checkpoint-block-Bl0HD3U2.mjs";
+import { t as PaiClient } from "./ipc-client-vO2GV325.mjs";
+import { a as expandHome, c as UNROUTED, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, s as OWNER_LABEL_PREFIX, t as CONFIG_DIR } from "./config-DGOfoGfm.mjs";
+import { t as createStorageBackend } from "./factory-HcQsQqh0.mjs";
+import { s as kgQuery } from "./kg-entity-DbOMPdF9.mjs";
+import { a as renderDedupedSessions, c as fetchLiveSessions, d as fmtAge, f as resolveSessionByNameOrId, i as normalizeName$1, l as revealItermSession, o as printExitDir, p as scanSessions, r as buildDeduped, s as callAiBroker, u as sendToSession } from "./main-resolver-DimnS2qP.mjs";
 import { appendFileSync, chmodSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
+import { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import chalk from "chalk";
 import { fileURLToPath } from "node:url";
@@ -120,7 +122,7 @@ function cmdPromote(db, opts) {
 
 //#endregion
 //#region src/cli/commands/project/helpers.ts
-function getProject$1(db, slug) {
+function getProject$2(db, slug) {
 	const direct = db.prepare("SELECT * FROM projects WHERE slug = ?").get(slug);
 	if (direct) return direct;
 	return db.prepare(`SELECT p.* FROM projects p
@@ -128,7 +130,7 @@ function getProject$1(db, slug) {
        WHERE a.alias = ?`).get(slug);
 }
 function requireProject(db, slug) {
-	const project = getProject$1(db, slug);
+	const project = getProject$2(db, slug);
 	if (!project) {
 		console.error(err(`Project not found: ${slug}`));
 		process.exit(1);
@@ -144,7 +146,7 @@ function resolveIdentifier(db, identifier) {
 		const rows = db.prepare("SELECT * FROM projects ORDER BY status ASC, updated_at DESC").all();
 		if (num <= rows.length) return rows[num - 1];
 	}
-	return getProject$1(db, identifier);
+	return getProject$2(db, identifier);
 }
 function getProjectTags(db, projectId) {
 	return db.prepare(`SELECT t.name FROM tags t
@@ -163,7 +165,7 @@ function getLastSessionDate(db, projectId) {
        ORDER BY created_at DESC LIMIT 1`).get(projectId);
 	return row ? row.created_at : null;
 }
-function upsertTag(db, tagName) {
+function upsertTag$1(db, tagName) {
 	db.prepare("INSERT OR IGNORE INTO tags (name) VALUES (?)").run(tagName);
 	return db.prepare("SELECT id FROM tags WHERE name = ?").get(tagName).id;
 }
@@ -419,7 +421,7 @@ function cmdList$3(db, opts) {
 	if (!opts.all && !opts.status && hiddenCount > 0) console.log(dim$1(`  ${rows.length} active project(s)  (${hiddenCount} archived — use --all to show)`));
 	else console.log(dim$1(`  ${rows.length} project(s)`));
 }
-function cmdInfo(db, identifier) {
+function cmdInfo$1(db, identifier) {
 	const project = resolveIdentifier(db, identifier) ?? requireProject(db, identifier);
 	const tags = getProjectTags(db, project.id);
 	const aliases = getProjectAliases(db, project.id);
@@ -489,12 +491,12 @@ function cmdMove(db, slug, newPath) {
 	console.log(dim$1(`  Old path: ${project.root_path}`));
 	console.log(dim$1(`  New path: ${resolvedNew}`));
 }
-function cmdTag(db, slug, tags) {
+function cmdTag$1(db, slug, tags) {
 	const project = requireProject(db, slug);
 	const added = [];
 	const skipped = [];
 	for (const tagName of tags) {
-		const tagId = upsertTag(db, tagName);
+		const tagId = upsertTag$1(db, tagName);
 		if (db.prepare("SELECT 1 FROM project_tags WHERE project_id = ? AND tag_id = ?").get(project.id, tagId)) skipped.push(tagName);
 		else {
 			db.prepare("INSERT INTO project_tags (project_id, tag_id) VALUES (?, ?)").run(project.id, tagId);
@@ -510,7 +512,7 @@ function cmdAlias(db, slug, alias) {
 		console.error(err(`"${alias}" is already a project slug — cannot use as alias.`));
 		process.exit(1);
 	}
-	const project = getProject$1(db, slug);
+	const project = getProject$2(db, slug);
 	try {
 		db.prepare("INSERT INTO aliases (alias, project_id) VALUES (?, ?)").run(alias, project.id);
 		console.log(ok(`Alias added: ${bold$1(alias)} → ${slug}`));
@@ -658,7 +660,7 @@ function cmdGo(db, query) {
 		process.exit(1);
 	}
 	const q = query.trim().toLowerCase();
-	const exact = getProject$1(db, query);
+	const exact = getProject$2(db, query);
 	if (exact) {
 		if (!existsSync(exact.root_path)) {
 			const recovered = tryRecoverMovedProject(db, exact);
@@ -1280,7 +1282,7 @@ function cmdHealth$1(db, opts) {
 //#region src/cli/commands/project/projects-index.ts
 function registerProjectsCommands(projectsCmd, getDb) {
 	projectsCmd.command("list", { isDefault: true }).description("Show the unified deduped listing (same as `pai`).\nUse --all to include cold / zero-session / archived projects.").option("--all", "Show all entries including cold / zero-session / archived projects").option("-n, --n <count>", "Max rows to show", "20").action(async (opts) => {
-		const { cmdMain } = await import("./main-resolver-uFxNiDy7.mjs").then((n) => n.n);
+		const { cmdMain } = await import("./main-resolver-DimnS2qP.mjs").then((n) => n.n);
 		await cmdMain(getDb(), void 0, void 0, opts);
 	});
 	projectsCmd.command("list-raw").description("Raw registry listing with slug, path, status, last_active columns").option("--all", "Include archived projects (default: active only)").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
@@ -1323,7 +1325,7 @@ function registerProjectsCommands(projectsCmd, getDb) {
 		cmdAdd(getDb(), rawPath, opts);
 	});
 	projectsCmd.command("info <slug>").description("Show full details for a project").action((slug) => {
-		cmdInfo(getDb(), slug);
+		cmdInfo$1(getDb(), slug);
 	});
 	projectsCmd.command("archive <slug>").description("Archive a project").action((slug) => {
 		cmdArchive(getDb(), slug);
@@ -1338,7 +1340,7 @@ function registerProjectsCommands(projectsCmd, getDb) {
 		cmdRebind(getDb(), slug, newPath);
 	});
 	projectsCmd.command("tag <slug> <tags...>").description("Add one or more tags to a project").action((slug, tags) => {
-		cmdTag(getDb(), slug, tags);
+		cmdTag$1(getDb(), slug, tags);
 	});
 	projectsCmd.command("alias <slug> <alias>").description("Register an alternative slug for a project").action((slug, alias) => {
 		cmdAlias(getDb(), slug, alias);
@@ -1435,6 +1437,360 @@ function cmdMigrate$1(db) {
 	}
 }
 
+//#endregion
+//#region src/cli/commands/registry/dedupe.ts
+/** Resolve a path to its canonical form, or null when it no longer exists. */
+function safeRealPath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+function countRefs(db, projectId) {
+	const one = (sql) => db.prepare(sql).get(projectId).n;
+	return {
+		sessions: one("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?"),
+		compaction: one("SELECT COUNT(*) AS n FROM compaction_log WHERE project_id = ?"),
+		aliases: one("SELECT COUNT(*) AS n FROM aliases WHERE project_id = ?"),
+		links: one("SELECT COUNT(*) AS n FROM links WHERE target_project_id = ?"),
+		tags: one("SELECT COUNT(*) AS n FROM project_tags WHERE project_id = ?"),
+		children: one("SELECT COUNT(*) AS n FROM projects WHERE parent_id = ?")
+	};
+}
+/**
+* Choose which row survives.
+*
+* The row whose stored path already IS the canonical filesystem path wins:
+* keeping it means `root_path` ends up correct without rewriting it, and any
+* external reference to that path keeps resolving. Failing that, the row with
+* the most sessions wins, then the oldest.
+*/
+function pickCanonical(rows, realPath, db) {
+	const exact = rows.filter((r) => r.root_path === realPath);
+	return [...exact.length > 0 ? exact : rows].sort((a, b) => {
+		const sa = countRefs(db, a.id).sessions;
+		const sb = countRefs(db, b.id).sessions;
+		if (sa !== sb) return sb - sa;
+		return a.created_at - b.created_at;
+	})[0];
+}
+function analyzeDuplicates(db) {
+	const rows = db.prepare(`SELECT id, slug, display_name, root_path, encoded_dir, status,
+              claude_notes_dir, session_config, created_at
+         FROM projects ORDER BY id`).all();
+	const byRealPath = /* @__PURE__ */ new Map();
+	const stalePaths = [];
+	for (const row of rows) {
+		const rp = safeRealPath(row.root_path);
+		if (!rp) {
+			stalePaths.push(row);
+			continue;
+		}
+		const bucket = byRealPath.get(rp);
+		if (bucket) bucket.push(row);
+		else byRealPath.set(rp, [row]);
+	}
+	const groups = [];
+	for (const [realPath, members] of byRealPath) {
+		if (members.length < 2) continue;
+		const canonical = pickCanonical(members, realPath, db);
+		groups.push({
+			realPath,
+			canonical,
+			duplicates: members.filter((m) => m.id !== canonical.id)
+		});
+	}
+	return {
+		groups,
+		stalePaths
+	};
+}
+/**
+* Fold a duplicate session row into the one the canonical project already has
+* for the same note file.
+*
+* Both rows describe one file on disk — the double registration produced two
+* registry rows for it, often identical and created milliseconds apart. Moving
+* both would leave the merged project with two entries per note and force one
+* of them to a number that no longer matches its own filename.
+*
+* Nothing is discarded: tags and links are repointed at the surviving row, and
+* any field the survivor is missing is backfilled from the duplicate before it
+* is deleted.
+*/
+function foldSession(db, keepId, dropId) {
+	const tags = db.prepare("SELECT tag_id FROM session_tags WHERE session_id = ?").all(dropId);
+	for (const t of tags) if (db.prepare("SELECT 1 FROM session_tags WHERE session_id = ? AND tag_id = ? LIMIT 1").get(keepId, t.tag_id)) db.prepare("DELETE FROM session_tags WHERE session_id = ? AND tag_id = ?").run(dropId, t.tag_id);
+	else db.prepare("UPDATE session_tags SET session_id = ? WHERE session_id = ? AND tag_id = ?").run(keepId, dropId, t.tag_id);
+	const links = db.prepare("SELECT id, target_project_id FROM links WHERE session_id = ?").all(dropId);
+	for (const l of links) if (db.prepare("SELECT 1 FROM links WHERE session_id = ? AND target_project_id = ? LIMIT 1").get(keepId, l.target_project_id)) db.prepare("DELETE FROM links WHERE id = ?").run(l.id);
+	else db.prepare("UPDATE links SET session_id = ? WHERE id = ?").run(keepId, l.id);
+	db.prepare("UPDATE compaction_log SET session_id = ? WHERE session_id = ?").run(keepId, dropId);
+	db.prepare(`UPDATE sessions SET
+       claude_session_id = COALESCE(claude_session_id,
+                                    (SELECT claude_session_id FROM sessions WHERE id = ?)),
+       token_count       = COALESCE(token_count,
+                                    (SELECT token_count FROM sessions WHERE id = ?)),
+       closed_at         = COALESCE(closed_at,
+                                    (SELECT closed_at FROM sessions WHERE id = ?)),
+       status            = CASE WHEN status = 'open'
+                                 AND (SELECT status FROM sessions WHERE id = ?) != 'open'
+                                THEN (SELECT status FROM sessions WHERE id = ?)
+                                ELSE status END
+     WHERE id = ?`).run(dropId, dropId, dropId, dropId, dropId, keepId);
+	db.prepare("DELETE FROM sessions WHERE id = ?").run(dropId);
+}
+function mergeGroup(db, group) {
+	const report = {
+		movedSessions: 0,
+		foldedSessions: 0,
+		renumbered: [],
+		movedCompaction: 0,
+		movedAliases: 0,
+		movedLinks: 0,
+		movedTags: 0,
+		movedChildren: 0,
+		deletedRows: 0,
+		reclaimedSlugs: []
+	};
+	const canonicalId = group.canonical.id;
+	let nextNumber = (db.prepare("SELECT MAX(number) AS n FROM sessions WHERE project_id = ?").get(canonicalId).n ?? 0) + 1;
+	for (const dup of group.duplicates) {
+		const sessions = db.prepare("SELECT id, number, title, filename FROM sessions WHERE project_id = ? ORDER BY number").all(dup.id);
+		for (const s of sessions) {
+			const twin = db.prepare("SELECT id FROM sessions WHERE project_id = ? AND filename = ? LIMIT 1").get(canonicalId, s.filename);
+			if (twin) {
+				foldSession(db, twin.id, s.id);
+				report.foldedSessions++;
+				continue;
+			}
+			if (db.prepare("SELECT 1 FROM sessions WHERE project_id = ? AND number = ? LIMIT 1").get(canonicalId, s.number)) {
+				const assigned = nextNumber++;
+				db.prepare("UPDATE sessions SET project_id = ?, number = ? WHERE id = ?").run(canonicalId, assigned, s.id);
+				report.renumbered.push({
+					from: s.number,
+					to: assigned,
+					title: s.title
+				});
+			} else {
+				db.prepare("UPDATE sessions SET project_id = ? WHERE id = ?").run(canonicalId, s.id);
+				if (s.number >= nextNumber) nextNumber = s.number + 1;
+			}
+			report.movedSessions++;
+		}
+		report.movedCompaction += db.prepare("UPDATE compaction_log SET project_id = ? WHERE project_id = ?").run(canonicalId, dup.id).changes;
+		const dupAliases = db.prepare("SELECT alias FROM aliases WHERE project_id = ?").all(dup.id);
+		for (const a of dupAliases) {
+			const existing = db.prepare("SELECT project_id FROM aliases WHERE alias = ?").get(a.alias);
+			if (existing && existing.project_id === canonicalId) continue;
+			db.prepare("UPDATE aliases SET project_id = ? WHERE alias = ?").run(canonicalId, a.alias);
+			report.movedAliases++;
+		}
+		const dupLinks = db.prepare("SELECT id, session_id FROM links WHERE target_project_id = ?").all(dup.id);
+		for (const l of dupLinks) {
+			if (db.prepare("SELECT 1 FROM links WHERE session_id = ? AND target_project_id = ? LIMIT 1").get(l.session_id, canonicalId)) {
+				db.prepare("DELETE FROM links WHERE id = ?").run(l.id);
+				continue;
+			}
+			db.prepare("UPDATE links SET target_project_id = ? WHERE id = ?").run(canonicalId, l.id);
+			report.movedLinks++;
+		}
+		const dupTags = db.prepare("SELECT tag_id FROM project_tags WHERE project_id = ?").all(dup.id);
+		for (const t of dupTags) {
+			if (db.prepare("SELECT 1 FROM project_tags WHERE project_id = ? AND tag_id = ? LIMIT 1").get(canonicalId, t.tag_id)) {
+				db.prepare("DELETE FROM project_tags WHERE project_id = ? AND tag_id = ?").run(dup.id, t.tag_id);
+				continue;
+			}
+			db.prepare("UPDATE project_tags SET project_id = ? WHERE project_id = ? AND tag_id = ?").run(canonicalId, dup.id, t.tag_id);
+			report.movedTags++;
+		}
+		report.movedChildren += db.prepare("UPDATE projects SET parent_id = ? WHERE parent_id = ?").run(canonicalId, dup.id).changes;
+		if (!group.canonical.claude_notes_dir && dup.claude_notes_dir) db.prepare("UPDATE projects SET claude_notes_dir = ? WHERE id = ?").run(dup.claude_notes_dir, canonicalId);
+		if (!group.canonical.session_config && dup.session_config) db.prepare("UPDATE projects SET session_config = ? WHERE id = ?").run(dup.session_config, canonicalId);
+		db.prepare("DELETE FROM projects WHERE id = ?").run(dup.id);
+		report.deletedRows++;
+	}
+	if ((group.canonical.status === "active" || group.duplicates.some((d) => d.status === "active")) && group.canonical.status !== "active") db.prepare("UPDATE projects SET status = 'active' WHERE id = ?").run(canonicalId);
+	const suffixed = /^(.*)-\d+$/.exec(group.canonical.slug);
+	if (suffixed) {
+		const candidates = [suffixed[1], ...group.duplicates.map((d) => d.slug).filter((s) => !/-\d+$/.test(s))];
+		for (const candidate of candidates) {
+			if (db.prepare("SELECT 1 FROM projects WHERE slug = ? LIMIT 1").get(candidate)) continue;
+			db.prepare("UPDATE projects SET slug = ?, updated_at = ? WHERE id = ?").run(candidate, Date.now(), canonicalId);
+			report.reclaimedSlugs.push({
+				from: group.canonical.slug,
+				to: candidate
+			});
+			break;
+		}
+	}
+	if (group.canonical.root_path !== group.realPath) {
+		if (!db.prepare("SELECT id FROM projects WHERE root_path = ? AND id != ?").get(group.realPath, canonicalId)) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(group.realPath, Date.now(), canonicalId);
+	}
+	return report;
+}
+/**
+* Rewrite any remaining root_path that is not already its canonical form.
+*
+* Merging fixes the rows that already split. This stops the rest from
+* splitting later: a project registered only as `~/dev/ai/PAILot` still has a
+* non-canonical path, so the first session started from the other spelling
+* would create a second row and the whole problem recurs.
+*
+* Only rows whose canonical path is free are touched — a collision would mean
+* a duplicate, and those have already been merged.
+*/
+function canonicalizePaths(db, dryRun) {
+	const rows = db.prepare("SELECT id, slug, root_path FROM projects").all();
+	const changed = [];
+	for (const row of rows) {
+		const rp = safeRealPath(row.root_path);
+		if (!rp || rp === row.root_path) continue;
+		if (db.prepare("SELECT 1 FROM projects WHERE root_path = ? AND id != ? LIMIT 1").get(rp, row.id)) continue;
+		changed.push({
+			slug: row.slug,
+			from: row.root_path,
+			to: rp
+		});
+		if (!dryRun) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(rp, Date.now(), row.id);
+	}
+	return changed;
+}
+function backupDb(dbPath) {
+	if (!existsSync(dbPath)) return null;
+	const dest = `${dbPath}.bak-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+	try {
+		copyFileSync(dbPath, dest);
+		for (const suffix of ["-wal", "-shm"]) if (existsSync(dbPath + suffix)) copyFileSync(dbPath + suffix, dest + suffix);
+		return dest;
+	} catch {
+		return null;
+	}
+}
+function cmdDedupe(db, opts) {
+	const { groups, stalePaths } = analyzeDuplicates(db);
+	console.log();
+	console.log(bold$1(opts.execute ? "  pai registry dedupe" : "  pai registry dedupe — DRY RUN (no changes will be made)"));
+	console.log();
+	if (groups.length === 0) console.log(ok("No duplicate projects found — every root_path resolves uniquely."));
+	for (const g of groups) {
+		console.log(`  ${bold$1(g.realPath)}`);
+		const cCounts = countRefs(db, g.canonical.id);
+		console.log(`    ${ok("keep")}  #${g.canonical.id} ${bold$1(g.canonical.slug)} ` + dim$1(`(${g.canonical.root_path}) — ${cCounts.sessions} sessions, ${g.canonical.status}`));
+		for (const d of g.duplicates) {
+			const dc = countRefs(db, d.id);
+			const moving = [
+				dc.sessions ? `${dc.sessions} sessions` : null,
+				dc.compaction ? `${dc.compaction} compaction rows` : null,
+				dc.aliases ? `${dc.aliases} aliases` : null,
+				dc.links ? `${dc.links} links` : null,
+				dc.tags ? `${dc.tags} tags` : null,
+				dc.children ? `${dc.children} child projects` : null
+			].filter(Boolean).join(", ");
+			console.log(`    ${warn("merge")} #${d.id} ${bold$1(d.slug)} ` + dim$1(`(${d.root_path}) — ${moving || "nothing to move"}`));
+		}
+		console.log();
+	}
+	if (stalePaths.length > 0) {
+		console.log(dim$1(`  ${stalePaths.length} project(s) point at a path that no longer exists.`));
+		console.log(dim$1("  These are never merged automatically — a missing directory cannot be"));
+		console.log(dim$1("  proven identical to anything else. Listed for review:"));
+		for (const s of stalePaths) {
+			const sc = countRefs(db, s.id);
+			if (sc.sessions === 0 && sc.compaction === 0) continue;
+			console.log(dim$1(`    #${s.id} ${s.slug} (${s.root_path}) — ${sc.sessions} sessions, ${sc.compaction} compaction rows`));
+		}
+		console.log();
+	}
+	const pathFixes = canonicalizePaths(db, true);
+	if (pathFixes.length > 0) {
+		console.log(dim$1(`  ${pathFixes.length} project(s) stored under a non-canonical path — these would`));
+		console.log(dim$1("  split into a second row the first time a session runs from the other"));
+		console.log(dim$1("  spelling. They will be rewritten to their resolved path:"));
+		for (const p of pathFixes.slice(0, 8)) console.log(dim$1(`    ${p.slug}: ${p.from} -> ${p.to}`));
+		if (pathFixes.length > 8) console.log(dim$1(`    ... and ${pathFixes.length - 8} more`));
+		console.log();
+	}
+	if (!opts.execute) {
+		if (groups.length > 0 || pathFixes.length > 0) {
+			console.log(dim$1("  Re-run with --execute to apply. The registry is backed up first."));
+			console.log();
+		}
+		return;
+	}
+	if (groups.length === 0 && pathFixes.length === 0) return;
+	const dbPath = opts.dbPath;
+	if (dbPath) {
+		const backup = backupDb(dbPath);
+		if (backup) console.log(ok(`Registry backed up to ${bold$1(backup)}`));
+		else {
+			console.error(err("Could not back up the registry — refusing to merge without one."));
+			process.exit(1);
+		}
+	}
+	const totals = {
+		movedSessions: 0,
+		foldedSessions: 0,
+		renumbered: [],
+		movedCompaction: 0,
+		movedAliases: 0,
+		movedLinks: 0,
+		movedTags: 0,
+		movedChildren: 0,
+		deletedRows: 0,
+		reclaimedSlugs: []
+	};
+	let canonicalized = 0;
+	const run = db.transaction(() => {
+		for (const g of groups) {
+			const r = mergeGroup(db, g);
+			totals.movedSessions += r.movedSessions;
+			totals.foldedSessions += r.foldedSessions;
+			totals.renumbered.push(...r.renumbered);
+			totals.movedCompaction += r.movedCompaction;
+			totals.movedAliases += r.movedAliases;
+			totals.movedLinks += r.movedLinks;
+			totals.movedTags += r.movedTags;
+			totals.movedChildren += r.movedChildren;
+			totals.deletedRows += r.deletedRows;
+			totals.reclaimedSlugs.push(...r.reclaimedSlugs);
+		}
+		canonicalized = canonicalizePaths(db, false).length;
+	});
+	try {
+		run();
+	} catch (e) {
+		console.error(err(`Merge failed and was rolled back: ${String(e)}`));
+		process.exit(1);
+	}
+	console.log();
+	console.log(ok(`Merged ${totals.deletedRows} duplicate row(s).`));
+	console.log(`    sessions moved:        ${totals.movedSessions}`);
+	console.log(`    sessions folded:       ${totals.foldedSessions} ` + dim$1("(same note file registered twice)"));
+	console.log(`    compaction rows moved: ${totals.movedCompaction}`);
+	console.log(`    aliases moved:         ${totals.movedAliases}`);
+	console.log(`    links moved:           ${totals.movedLinks}`);
+	console.log(`    tags moved:            ${totals.movedTags}`);
+	console.log(`    child projects moved:  ${totals.movedChildren}`);
+	console.log(`    paths canonicalized:   ${canonicalized}`);
+	if (totals.reclaimedSlugs.length > 0) {
+		console.log();
+		console.log(ok("Slugs reclaimed from the merged rows:"));
+		for (const s of totals.reclaimedSlugs) console.log(dim$1(`    ${s.from} -> ${s.to}`));
+	}
+	if (totals.renumbered.length > 0) {
+		console.log();
+		console.log(warn(`${totals.renumbered.length} session(s) renumbered to avoid collisions:`));
+		for (const r of totals.renumbered) console.log(dim$1(`    ${r.from} -> ${r.to}  ${r.title}`));
+		console.log(dim$1("    Session note filenames on disk are unchanged — only the registry number moved."));
+		console.log();
+		console.log(warn("    A renumbered session's registry number no longer matches the number in its"));
+		console.log(dim$1("    filename. The scanner keys sessions by (project, number), so a note whose\n    number is now occupied cannot be re-registered until numbering is reconciled.\n    Run `pai session cleanup <slug> --execute` on the affected projects to renumber\n    notes and registry together."));
+	}
+	console.log();
+}
+
 //#endregion
 //#region src/cli/commands/registry/index.ts
 function cmdStats$2(db) {
@@ -1529,6 +1885,12 @@ function registerRegistryCommands(registryCmd, getDb) {
 	registryCmd.command("rebuild").description("Erase all registry data and rebuild from the filesystem (destructive)").action(() => {
 		cmdRebuild(getDb());
 	});
+	registryCmd.command("dedupe").description("Merge registry rows that describe the same project.\nTwo spellings of one directory (e.g. via a symlinked path prefix) register\nas separate projects and split session history between them. Rows are grouped\nby resolved path, so a merge only happens when the paths are provably identical.\nDry-run by default; --execute backs up the registry first and merges in one transaction.").option("--execute", "Actually perform the merge (default is dry-run)").action((opts) => {
+		cmdDedupe(getDb(), {
+			execute: opts.execute,
+			dbPath: join(homedir(), ".pai", "registry.db")
+		});
+	});
 	registryCmd.command("lookup").description("Find the project slug for a filesystem path (for use in scripts)").requiredOption("--path <path>", "Filesystem path to look up").action((opts) => {
 		cmdLookup(getDb(), opts.path);
 	});
@@ -1655,7 +2017,7 @@ function registerSearchCommand(memoryCmd, getDb) {
 		else if (mode === "semantic" || mode === "hybrid") {
 			const backend = await createStorageBackend(config);
 			try {
-				const { generateEmbedding } = await import("./embeddings-BJPOcbik.mjs").then((n) => n.i);
+				const { generateEmbedding } = await import("./embeddings-DGRAPAYb.mjs").then((n) => n.i);
 				console.log(dim$1("Generating query embedding..."));
 				const queryEmbedding = await generateEmbedding(query, true);
 				if (mode === "semantic") results = await backend.searchSemantic(queryEmbedding, searchOpts);
@@ -1704,13 +2066,13 @@ function registerSearchCommand(memoryCmd, getDb) {
 			return;
 		}
 		if (opts.rerank !== false) {
-			const { rerankResults } = await import("./reranker-C08R99zn.mjs").then((n) => n.r);
+			const { rerankResults } = await import("./reranker-CMNZcfVx.mjs").then((n) => n.r);
 			console.log(dim$1("Reranking with cross-encoder..."));
 			results = await rerankResults(query, results, { topK: maxResults });
 		}
 		const recencyDays = parseInt(opts.recency ?? String(searchConfig.recencyBoostDays), 10);
 		if (recencyDays > 0) {
-			const { applyRecencyBoost } = await import("./search-HcdKtMla.mjs").then((n) => n.o);
+			const { applyRecencyBoost } = await import("./search-i2nlQ-JM.mjs").then((n) => n.o);
 			console.log(dim$1(`Applying recency boost (half-life: ${recencyDays} days)...`));
 			results = applyRecencyBoost(results, recencyDays);
 		}
@@ -2305,8 +2667,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-COSvHTNu.mjs").then((n) => n.t);
-		const { loadConfig: lc, ensureConfigDir } = await import("./config-C8m-tPhP.mjs").then((n) => n.r);
+		const { serve } = await import("./daemon-1rKbN-fd.mjs").then((n) => n.t);
+		const { loadConfig: lc, ensureConfigDir } = await import("./config-DGOfoGfm.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());
 	});
@@ -4219,6 +4581,10 @@ async function listProjects(token) {
 		name: p.name
 	}));
 }
+/** Strip emoji and case so "Whazaa 🐝" and "whazaa" compare equal. */
+function normalizeName(raw) {
+	return raw.replace(/[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{FE0F}\u{200D}]/gu, "").trim().toLowerCase();
+}
 /** Todoist priority is inverted: 4 is urgent, 1 is lowest. */
 function toPriority(wire) {
 	switch (wire) {
@@ -4301,13 +4667,14 @@ var TodoistProvider = class {
 		if (!token || !this.config.rootProjectId) throw new Error("Todoist provider is not configured — run `pai setup`.");
 		const labels = [...task.labels ?? []];
 		if (task.owner && !labels.some((l) => l.toLowerCase() === `pai:${task.owner.toLowerCase()}`)) labels.push(`pai:${task.owner}`);
-		const sectionId = task.owner ? void 0 : this.config.findingsSectionId;
+		const sectionId = task.owner || task.into ? void 0 : this.config.findingsSectionId;
+		const projectId = task.into ? (await this.findOrCreateSubProject(task.into)).id : this.config.rootProjectId;
 		const created = await call(token, "/tasks", {
 			method: "POST",
 			body: {
 				content: task.title,
 				description: task.body,
-				project_id: this.config.rootProjectId,
+				project_id: projectId,
 				...sectionId ? { section_id: sectionId } : {},
 				labels,
 				priority: fromPriority(task.priority),
@@ -4343,6 +4710,42 @@ var TodoistProvider = class {
 			body: { labels }
 		});
 	}
+	/**
+	* Find the sub-project named `name` under the bus root, creating it if absent.
+	*
+	* Per-project sub-projects are the filing convention: a flat pile in the root
+	* buries findings across projects. This exists so the convention can be
+	* executed rather than re-derived — a session that has to infer structure
+	* from the existing project list will sometimes infer cautiously and file
+	* flat, which is the mess the convention prevents.
+	*
+	* Matching is case-insensitive and ignores decoration, so "Whazaa" finds an
+	* existing "Whazaa 🐝" rather than creating a near-duplicate.
+	*/
+	async findOrCreateSubProject(name) {
+		const token = this.token();
+		if (!token || !this.config.rootProjectId) throw new Error("Todoist provider is not configured — run `pai task config`.");
+		const root = this.config.rootProjectId;
+		const projects = await collect(token, "/projects");
+		const want = normalizeName(name);
+		for (const p of projects) {
+			if (p.is_archived || p.is_deleted) continue;
+			if (p.parent_id === root && normalizeName(p.name) === want) return {
+				id: p.id,
+				created: false
+			};
+		}
+		return {
+			id: (await call(token, "/projects", {
+				method: "POST",
+				body: {
+					name,
+					parent_id: root
+				}
+			})).id,
+			created: true
+		};
+	}
 	/** Append a comment — used to keep run history on the task itself. */
 	async comment(id, content) {
 		const token = this.token();
@@ -4505,7 +4908,7 @@ function registerSetupCommand(program) {
 //#region src/obsidian/sync/symlinks.ts
 /** Symlink management: create, validate, migrate, and clean vault project symlinks. */
 /** Find the project-root Notes directory for a project. */
-function findNotesDir$1(rootPath) {
+function findNotesDir(rootPath) {
 	const canonical = join(rootPath, "Notes");
 	if (existsSync(canonical)) return canonical;
 	const alt = join(rootPath, ".claude", "Notes");
@@ -4516,7 +4919,7 @@ function findNotesDir$1(rootPath) {
 * Find the Claude Code session notes directory from the registry-stored value.
 * Returns null if not set, missing on disk, or identical to notesDir.
 */
-function findClaudeNotesDir(claudeNotesDirFromRegistry, notesDir) {
+function findClaudeNotesDir$1(claudeNotesDirFromRegistry, notesDir) {
 	if (!claudeNotesDirFromRegistry) return null;
 	if (!existsSync(claudeNotesDirFromRegistry)) return null;
 	if (notesDir && claudeNotesDirFromRegistry === notesDir) return null;
@@ -4629,8 +5032,8 @@ function syncVault(vaultPath, db) {
        ORDER BY status ASC, slug ASC`).all();
 	const takenSlugs = /* @__PURE__ */ new Set();
 	for (const project of projects) if (project.status === "active") {
-		const notesDir = findNotesDir$1(project.root_path);
-		const claudeNotesDir = findClaudeNotesDir(project.claude_notes_dir, notesDir);
+		const notesDir = findNotesDir(project.root_path);
+		const claudeNotesDir = findClaudeNotesDir$1(project.claude_notes_dir, notesDir);
 		if (!notesDir && !claudeNotesDir) continue;
 		const slug = uniqueSlug(project.slug, takenSlugs);
 		takenSlugs.add(slug);
@@ -4708,8 +5111,8 @@ function generateIndex(vaultPath, db) {
 	for (const row of active) {
 		const tags = getTagsForProject.all(row.id).map((t) => `\`${t.name}\``).join(" ");
 		const lastActive = fmtDate(row.last_active);
-		const notesDir = findNotesDir$1(row.root_path);
-		const claudeNotesDir = findClaudeNotesDir(row.claude_notes_dir, notesDir);
+		const notesDir = findNotesDir(row.root_path);
+		const claudeNotesDir = findClaudeNotesDir$1(row.claude_notes_dir, notesDir);
 		const sources = [];
 		if (notesDir) sources.push("notes");
 		if (claudeNotesDir) sources.push("sessions");
@@ -5393,7 +5796,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-NwBD1NsT.mjs");
+	const { zettelExplore } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const result = zettelExplore(getFedDb(), {
 		startNote: note,
 		depth,
@@ -5457,7 +5860,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-NwBD1NsT.mjs");
+	const { zettelHealth } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const result = zettelHealth(getFedDb(), {
 		scope,
 		projectPath,
@@ -5526,7 +5929,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-NwBD1NsT.mjs");
+	const { zettelSurprise } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Surprise"));
@@ -5579,7 +5982,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-NwBD1NsT.mjs");
+	const { zettelSuggest } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Suggest"));
@@ -5630,7 +6033,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-NwBD1NsT.mjs");
+	const { zettelConverse } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Converse"));
@@ -5691,7 +6094,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-NwBD1NsT.mjs");
+	const { zettelThemes } = await import("./zettelkasten-CTlt1dGv.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Themes"));
@@ -7387,7 +7790,7 @@ function registerTaskCommands(taskCmd) {
 			limit: opts.limit
 		}));
 	});
-	taskCmd.command("add <title>").description("File a task onto the bus").option("--owner <project>", "PAI project that owns this (adds a pai: label)").option("--body <text>", "Full procedure and reasoning — not just a restatement of the title").option("--due <date>", "Due date (ISO or natural language)").option("--priority <p>", "p1 (highest) … p4 (default)").option("--url <url>", "Reference — prefer a hook:// URL over a file path").action(async (title, opts) => {
+	taskCmd.command("add <title>").description("File a task onto the bus").option("--owner <project>", "PAI project that owns this (adds a pai: label)").option("--body <text>", "Full procedure and reasoning — not just a restatement of the title").option("--due <date>", "Due date (ISO or natural language)").option("--priority <p>", "p1 (highest) … p4 (default)").option("--url <url>", "Reference — prefer a hook:// URL over a file path").option("--into <sub-project>", "File into this sub-project under the bus root, creating it if absent").action(async (title, opts) => {
 		const provider = buildProvider();
 		if (!provider) return reportUnconfigured();
 		if (!opts.body) {
@@ -7400,7 +7803,8 @@ function registerTaskCommands(taskCmd) {
 			owner: opts.owner ?? null,
 			due: opts.due,
 			priority: opts.priority,
-			sourceUrl: opts.url
+			sourceUrl: opts.url,
+			into: opts.into
 		});
 		console.log(chalk.green(`  Filed: ${created.title}`));
 		console.log(`    ${renderOwner(created)} ${dim("· " + created.id)}`);
@@ -8277,211 +8681,1888 @@ function registerHelpCommand(program) {
 }
 
 //#endregion
-//#region src/cli/commands/session/pause.ts
-const HANDOVER_TODO_LOCATIONS = [
-	"Notes/TODO.md",
-	".claude/Notes/TODO.md",
-	"tasks/todo.md",
-	"TODO.md"
-];
-function findProjectTodo(rootPath) {
-	for (const rel of HANDOVER_TODO_LOCATIONS) {
-		const full = join(rootPath, rel);
-		if (existsSync(full)) try {
-			return {
-				path: full,
-				content: readFileSync(full, "utf8")
-			};
-		} catch {}
-	}
+//#region src/session/slug-generator.ts
+/**
+* Slug generator for PAI session notes.
+*
+* Extracts a 1-3 word descriptive slug from Claude Code JSONL transcripts
+* using keyword frequency analysis — no LLM required.
+*
+* JSONL format (one JSON object per line):
+*   - type "user":      { type: "user",      message: { role: "user",      content: string | [{ type, text }] } }
+*   - type "assistant": { type: "assistant", message: { role: "assistant", content: [{ type, text }] } }
+*/
+/**
+* Extract plain text from a parsed JSONL message object.
+*/
+function extractText(obj) {
+	const msg = obj.message;
+	if (!msg) return null;
+	const content = msg.content;
+	if (Array.isArray(content)) {
+		const texts = [];
+		for (const block of content) {
+			const b = block;
+			if (b.type === "text" && typeof b.text === "string") texts.push(b.text);
+		}
+		return texts.join(" ") || null;
+	}
+	if (typeof content === "string") return content || null;
 	return null;
 }
-function stripContinueSection(content) {
-	const lines = content.split("\n");
-	const startIdx = lines.findIndex((l) => l.trim() === "## Continue");
-	if (startIdx === -1) return content;
-	let endIdx = lines.length;
-	for (let i = startIdx + 1; i < lines.length; i++) {
-		const trimmed = lines[i].trim();
-		if (trimmed === "---" || trimmed.startsWith("##") && trimmed !== "## Continue") {
-			endIdx = i;
-			break;
-		}
-	}
-	let trailingEnd = endIdx;
-	if (trailingEnd < lines.length && lines[trailingEnd].trim() === "---") trailingEnd += 1;
-	const before = lines.slice(0, startIdx);
-	const after = lines.slice(trailingEnd);
-	while (after.length > 0 && after[0].trim() === "") after.shift();
-	return [...before, ...after].join("\n");
+/**
+* Tokenize a string into lowercase words, filtering stop words and short tokens.
+*/
+function tokenize$1(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((w) => {
+		if (w.length < 3) return false;
+		if (/^\d+$/.test(w)) return false;
+		if (STOP_WORDS.has(w)) return false;
+		return true;
+	});
 }
-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);
+/**
+* Find the latest JSONL transcript for a project's Claude encoded directory.
+*
+* @param encodedDir  Claude-encoded project directory name,
+*                    e.g. "-Users-alice-dev-ai-PAI"
+* @returns  Absolute path to the most recently modified .jsonl file, or null.
+*/
+function findLatestTranscript(encodedDir) {
+	const sessionsDir = join(homedir(), ".claude", "projects", encodedDir, "sessions");
+	if (!existsSync(sessionsDir)) return null;
+	let entries;
+	try {
+		entries = readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+	} catch {
+		return null;
 	}
-	const session = db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(project.id);
-	const todo = findProjectTodo(project.root_path);
-	let todoPath;
-	let existingContent;
-	if (todo) {
-		todoPath = todo.path;
-		existingContent = todo.content;
-	} else {
-		const notesDir = join(project.root_path, "Notes");
-		if (!opts.dryRun) try {
-			if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
-		} catch (mkdirErr) {
-			console.error(chalk.red("pai session pause: ") + `Could not create Notes directory: ${String(mkdirErr)}`);
-			process.exit(1);
+	if (!entries.length) return null;
+	return entries.map((f) => {
+		const fullPath = join(sessionsDir, f);
+		try {
+			return {
+				path: fullPath,
+				mtime: statSync(fullPath).mtimeMs
+			};
+		} catch {
+			return {
+				path: fullPath,
+				mtime: 0
+			};
 		}
-		todoPath = join(notesDir, "TODO.md");
-		existingContent = "";
+	}).sort((a, b) => b.mtime - a.mtime)[0].path;
+}
+/**
+* Read the last `count` human/assistant message pairs from a JSONL file.
+*
+* Synchronous — reads the whole file in memory.  JSONL transcripts are
+* bounded by context window size so this is safe even for large sessions.
+*
+* @param jsonlPath  Absolute path to a Claude Code .jsonl transcript file.
+* @param count      Number of conversation pairs to read (default: 15).
+* @returns  Array of plain-text message strings (up to count*2 entries).
+*/
+function readLastMessages(jsonlPath, count = 15) {
+	if (!existsSync(jsonlPath)) return [];
+	let raw;
+	try {
+		raw = readFileSync(jsonlPath, "utf8");
+	} catch {
+		return [];
 	}
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	let sessionLine;
-	if (session) {
-		const num = String(session.number).padStart(4, "0");
-		const titlePart = session.title || session.slug || "Session";
-		sessionLine = `${num} - ${session.date} - ${titlePart}`;
-	} else sessionLine = "Unknown session";
-	const continueBlock = [
-		"## Continue",
-		"",
-		`> **Last session:** ${sessionLine}`,
-		`> **Paused at:** ${timestamp}`,
-		">",
-		`> Working directory: ${cwd}. Check the latest session note for details.`,
-		"",
-		"---",
-		""
-	].join("\n");
-	const newContent = continueBlock + stripContinueSection(existingContent).trimStart();
-	if (opts.dryRun) {
-		console.log("\n" + chalk.bold("Dry run — would write to:") + " " + chalk.cyan(todoPath));
-		console.log(chalk.dim("─".repeat(60)));
-		console.log(chalk.dim(continueBlock));
-		console.log(chalk.dim("─".repeat(60)));
-	} else {
-		const tmpPath = `${todoPath}.pause.tmp`;
+	const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+	const messages = [];
+	const limit = count * 2;
+	for (let i = lines.length - 1; i >= 0 && messages.length < limit; i--) {
+		let obj;
 		try {
-			writeFileSync(tmpPath, newContent, "utf8");
-			renameSync(tmpPath, todoPath);
-		} catch (writeErr) {
-			try {
-				if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
-			} catch {}
-			console.error(chalk.red("pai session pause: ") + `Failed to write TODO.md: ${String(writeErr)}`);
-			process.exit(1);
+			obj = JSON.parse(lines[i]);
+		} catch {
+			continue;
 		}
-		console.log(chalk.green("  ## Continue written to: ") + chalk.cyan(todoPath));
+		const type = obj.type;
+		if (type !== "assistant" && type !== "user") continue;
+		const text = extractText(obj);
+		if (text && text.trim().length > 0) messages.unshift(text);
 	}
-	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);
+	return messages;
+}
+/**
+* Generate a descriptive 1-3 word slug from conversation message strings.
+*
+* Algorithm:
+*  1. Tokenize all messages, remove stop words and short tokens
+*  2. Count word frequency
+*  3. Pick the top `maxWords` most frequent tokens
+*  4. Join with hyphen, lowercase
+*
+* @param messages  Array of plain-text conversation messages.
+* @param opts      Optional slug configuration.
+* @returns  A lowercase hyphen-joined slug, e.g. "memory-engine-refactor",
+*           or "unnamed-session" if no meaningful words are found.
+*/
+function generateSlug(messages, opts) {
+	const maxWords = opts?.maxWords ?? 3;
+	const maxLength = opts?.maxLength ?? 30;
+	if (!messages.length) return "unnamed-session";
+	const freq = /* @__PURE__ */ new Map();
+	for (const msg of messages) for (const token of tokenize$1(msg)) freq.set(token, (freq.get(token) ?? 0) + 1);
+	if (!freq.size) return "unnamed-session";
+	const topWords = Array.from(freq.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxWords).map(([word]) => word);
+	if (!topWords.length) return "unnamed-session";
+	let slug = topWords.join("-");
+	if (slug.length > maxLength) slug = slug.slice(0, maxLength).replace(/-[^-]*$/, "");
+	return slug || "unnamed-session";
 }
 
 //#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;
+//#region src/cli/commands/session/helpers.ts
+function getProject$1(db, slug) {
+	return db.prepare("SELECT id, slug, display_name, root_path, encoded_dir FROM projects WHERE slug = ?").get(slug);
+}
+function statusColor(status) {
+	switch (status) {
+		case "completed": return chalk.green(status);
+		case "compacted": return chalk.blue(status);
+		default: return chalk.yellow(status);
 	}
-	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(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;
+/** Convert a slug to title-cased display name: "memory-engine" → "Memory Engine" */
+function toTitleCase$1(slug) {
+	return slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
-/**
-* 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);
+/** Notes directory for a project: ~/.claude/projects/<encoded_dir>/Notes/ */
+function getNotesDir(project) {
+	return join(homedir(), ".claude", "projects", project.encoded_dir, "Notes");
 }
-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`);
+/** Format a session filename: number=27, date="2026-02-23" → "0027 - 2026-02-23 - Title.md" */
+function formatFilename(number, date, titleSlug) {
+	return `${String(number).padStart(4, "0")} - ${date} - ${titleSlug}.md`;
+}
+/** Resolve a session by project + number or "latest". Exits on failure. */
+function resolveSession(db, project, numberOrLatest) {
+	let session;
+	if (numberOrLatest === "latest") session = db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(project.id);
+	else {
+		const num = parseInt(numberOrLatest, 10);
+		if (isNaN(num)) {
+			console.error(err(`Invalid session number: ${numberOrLatest}`));
+			process.exit(1);
+		}
+		session = db.prepare("SELECT * FROM sessions WHERE project_id = ? AND number = ?").get(project.id, num);
 	}
-	const tmp = `${notePath}.end.tmp`;
-	writeFileSync(tmp, updated, "utf-8");
-	renameSync(tmp, notePath);
-	return {
-		finalized: true,
-		path: notePath
-	};
+	if (!session) {
+		console.error(err(`Session ${numberOrLatest} not found in project ${project.slug}`));
+		process.exit(1);
+	}
+	return session;
 }
-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
+function upsertTag(db, tagName) {
+	db.prepare("INSERT OR IGNORE INTO tags (name) VALUES (?)").run(tagName);
+	return db.prepare("SELECT id FROM tags WHERE name = ?").get(tagName).id;
+}
+function getSessionTags(db, sessionId) {
+	return db.prepare(`SELECT t.name FROM tags t
+       JOIN session_tags st ON st.tag_id = t.id
+       WHERE st.session_id = ?
+       ORDER BY t.name`).all(sessionId).map((r) => r.name);
+}
+
+//#endregion
+//#region src/cli/commands/session/commands.ts
+function cmdList(db, projectSlug, opts) {
+	const limit = parseInt(opts.limit ?? "20", 10);
+	const params = [];
+	let query = `
+    SELECT s.*, p.slug AS project_slug, p.display_name AS project_name
+    FROM sessions s
+    JOIN projects p ON p.id = s.project_id
+  `;
+	const where = [];
+	if (projectSlug) {
+		const project = getProject$1(db, projectSlug);
+		if (!project) {
+			console.error(err(`Project not found: ${projectSlug}`));
+			process.exit(1);
+		}
+		where.push("s.project_id = ?");
+		params.push(project.id);
+	}
+	if (opts.status) {
+		where.push("s.status = ?");
+		params.push(opts.status);
+	}
+	if (where.length) query += " WHERE " + where.join(" AND ");
+	query += " ORDER BY s.date DESC, s.number DESC";
+	query += ` LIMIT ${limit}`;
+	const rows = db.prepare(query).all(...params);
+	if (!rows.length) {
+		console.log(warn("No sessions found."));
+		return;
+	}
+	const showProject = !projectSlug;
+	const headers = showProject ? [
+		"#",
+		"Project",
+		"Date",
+		"Title",
+		"Status",
+		"Tokens"
+	] : [
+		"#",
+		"Date",
+		"Title",
+		"Status",
+		"Tokens"
+	];
+	const tableRows = rows.map((r) => {
+		const title = r.title.length > 45 ? r.title.slice(0, 42) + "..." : r.title;
+		const tokens = r.token_count != null ? dim$1(r.token_count.toLocaleString()) : dim$1("—");
+		if (showProject) return [
+			dim$1(`#${r.number}`),
+			r.project_slug,
+			r.date,
+			title,
+			statusColor(r.status),
+			tokens
+		];
+		return [
+			dim$1(`#${r.number}`),
+			r.date,
+			title,
+			statusColor(r.status),
+			tokens
+		];
+	});
+	console.log();
+	if (projectSlug) {
+		const project = getProject$1(db, projectSlug);
+		console.log(`  ${bold$1(project.display_name)} sessions:`);
+		console.log();
+	}
+	console.log(renderTable(headers, tableRows));
+	console.log();
+	console.log(dim$1(`  ${rows.length} session(s) shown (limit: ${limit})`));
+}
+function cmdInfo(db, projectSlug, sessionNumber) {
+	const project = getProject$1(db, projectSlug);
+	if (!project) {
+		console.error(err(`Project not found: ${projectSlug}`));
+		process.exit(1);
+	}
+	const session = resolveSession(db, project, sessionNumber);
+	console.log();
+	console.log(header(`  Session #${session.number}: ${session.title}`));
+	console.log();
+	console.log(`  ${bold$1("Project:")}     ${project.display_name} (${project.slug})`);
+	console.log(`  ${bold$1("Date:")}        ${session.date}`);
+	console.log(`  ${bold$1("Status:")}      ${statusColor(session.status)}`);
+	console.log(`  ${bold$1("Filename:")}    ${session.filename}`);
+	console.log(`  ${bold$1("Slug:")}        ${session.slug}`);
+	if (session.claude_session_id) console.log(`  ${bold$1("Claude ID:")}   ${dim$1(session.claude_session_id)}`);
+	if (session.token_count != null) console.log(`  ${bold$1("Tokens:")}      ${session.token_count.toLocaleString()}`);
+	console.log(`  ${bold$1("Created:")}     ${fmtDate(session.created_at)}`);
+	if (session.closed_at) console.log(`  ${bold$1("Closed:")}      ${fmtDate(session.closed_at)}`);
+	console.log();
+}
+function cmdRename(db, projectSlug, numberOrLatest, newSlug) {
+	const project = getProject$1(db, projectSlug);
+	if (!project) {
+		console.error(err(`Project not found: ${projectSlug}`));
+		process.exit(1);
+	}
+	const session = resolveSession(db, project, numberOrLatest);
+	const notesDir = getNotesDir(project);
+	if (!existsSync(notesDir)) {
+		console.error(err(`Notes directory not found: ${notesDir}`));
+		process.exit(1);
+	}
+	const titleSlug = toTitleCase$1(newSlug);
+	const newFilename = formatFilename(session.number, session.date, titleSlug);
+	const oldPath = join(notesDir, session.filename);
+	const newPath = join(notesDir, newFilename);
+	if (existsSync(oldPath)) {
+		if (oldPath !== newPath) try {
+			renameSync(oldPath, newPath);
+		} catch (e) {
+			console.error(err(`Failed to rename file: ${e}`));
+			process.exit(1);
+		}
+	} else {
+		console.log(warn(`  Note: file not found at expected path: ${session.filename}`));
+		console.log(warn(`  Skipping disk rename. Database will still be updated.`));
+	}
+	if (existsSync(newPath)) try {
+		const lines = readFileSync(newPath, "utf8").split("\n");
+		let h1Updated = false;
+		const updated = lines.map((line) => {
+			if (!h1Updated && line.startsWith("# ")) {
+				h1Updated = true;
+				return `# ${titleSlug}`;
+			}
+			return line;
+		});
+		if (!h1Updated) updated.unshift(`# ${titleSlug}`, "");
+		writeFileSync(newPath, updated.join("\n"), "utf8");
+	} catch (e) {
+		console.error(err(`Failed to update H1 in file: ${e}`));
+	}
+	const normalizedSlug = newSlug.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	db.prepare("UPDATE sessions SET slug = ?, title = ?, filename = ? WHERE id = ?").run(normalizedSlug, titleSlug, newFilename, session.id);
+	console.log();
+	console.log(ok(`  Session #${session.number} renamed.`));
+	console.log(`  ${bold$1("Old:")}   ${session.filename}`);
+	console.log(`  ${bold$1("New:")}   ${newFilename}`);
+	console.log(`  ${bold$1("Slug:")}  ${normalizedSlug}`);
+	console.log(`  ${bold$1("Title:")} ${titleSlug}`);
+	console.log();
+}
+function cmdSlug(db, projectSlug, numberOrLatest, opts) {
+	const project = getProject$1(db, projectSlug);
+	if (!project) {
+		console.error(err(`Project not found: ${projectSlug}`));
+		process.exit(1);
+	}
+	const session = resolveSession(db, project, numberOrLatest);
+	const transcriptPath = findLatestTranscript(project.encoded_dir);
+	if (!transcriptPath) {
+		console.log(warn(`  No JSONL transcripts found for project ${projectSlug}`));
+		console.log("unnamed-session");
+		return;
+	}
+	const messages = readLastMessages(transcriptPath);
+	if (messages.length < 2) {
+		console.log(warn(`  Too few messages found (${messages.length}) in transcript`));
+		console.log("unnamed-session");
+		return;
+	}
+	const generatedSlug = generateSlug(messages);
+	console.log(generatedSlug);
+	if (opts.apply) {
+		console.log();
+		console.log(dim$1(`  Applying slug to session #${session.number}...`));
+		cmdRename(db, projectSlug, String(session.number), generatedSlug);
+	}
+}
+function cmdTag(db, projectSlug, sessionNumber, rawTags) {
+	const project = getProject$1(db, projectSlug);
+	if (!project) {
+		console.error(err(`Project not found: ${projectSlug}`));
+		process.exit(1);
+	}
+	const session = resolveSession(db, project, sessionNumber);
+	if (rawTags.length === 0) {
+		const current = getSessionTags(db, session.id);
+		console.log();
+		if (current.length === 0) console.log(dim$1(`  Session #${session.number} has no tags.`));
+		else console.log(`  ${bold$1(`Session #${session.number}`)} tags: ${current.map((t) => chalk.cyan(t)).join(", ")}`);
+		console.log();
+		return;
+	}
+	const tags = rawTags.flatMap((t) => t.split(",")).map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0);
+	if (tags.length === 0) {
+		console.log(warn("No valid tags provided."));
+		return;
+	}
+	const added = [];
+	const skipped = [];
+	for (const tagName of tags) {
+		const tagId = upsertTag(db, tagName);
+		if (db.prepare("SELECT 1 FROM session_tags WHERE session_id = ? AND tag_id = ?").get(session.id, tagId)) skipped.push(tagName);
+		else {
+			db.prepare("INSERT INTO session_tags (session_id, tag_id) VALUES (?, ?)").run(session.id, tagId);
+			added.push(tagName);
+		}
+	}
+	console.log();
+	if (added.length) console.log(ok(`  Tagged session #${session.number}: ${added.map((t) => chalk.cyan(t)).join(", ")}`));
+	if (skipped.length) console.log(dim$1(`  Already present: ${skipped.join(", ")}`));
+	const allTags = getSessionTags(db, session.id);
+	console.log(`  ${bold$1("All tags:")} ${allTags.map((t) => chalk.cyan(t)).join(", ")}`);
+	console.log();
+}
+function cmdRoute(db, projectSlug, sessionNumber, targetProjectSlug, opts) {
+	const project = getProject$1(db, projectSlug);
+	if (!project) {
+		console.error(err(`Project not found: ${projectSlug}`));
+		process.exit(1);
+	}
+	const session = resolveSession(db, project, sessionNumber);
+	const targetProject = db.prepare("SELECT id, slug, display_name FROM projects WHERE slug = ?").get(targetProjectSlug);
+	if (!targetProject) {
+		console.error(err(`Target project not found: ${targetProjectSlug}`));
+		process.exit(1);
+	}
+	const validTypes = [
+		"related",
+		"follow-up",
+		"reference"
+	];
+	const linkType = opts.type ?? "related";
+	if (!validTypes.includes(linkType)) {
+		console.error(err(`Invalid link type "${linkType}". Valid: ${validTypes.join(", ")}`));
+		process.exit(1);
+	}
+	try {
+		db.prepare(`INSERT INTO links (session_id, target_project_id, link_type, created_at)
+       VALUES (?, ?, ?, ?)`).run(session.id, targetProject.id, linkType, Date.now());
+	} catch {
+		console.log(warn(`  Link already exists: session #${session.number} → ${targetProjectSlug}`));
+		return;
+	}
+	console.log();
+	console.log(ok(`  Linked session #${session.number} (${project.slug}) → ${targetProject.display_name} (${targetProjectSlug})`));
+	console.log(dim$1(`  Link type: ${linkType}`));
+	console.log();
+}
+function cmdActive(db, opts) {
+	const minutes = parseInt(opts.minutes ?? "60", 10);
+	const cutoff = Date.now() - minutes * 60 * 1e3;
+	const claudeProjectsDir = join(homedir(), ".claude", "projects");
+	if (!existsSync(claudeProjectsDir)) {
+		console.log(err("Claude projects directory not found."));
+		return;
+	}
+	const active = [];
+	const entries = readdirSync(claudeProjectsDir);
+	for (const entry of entries) {
+		const projectDir = join(claudeProjectsDir, entry);
+		try {
+			if (!statSync(projectDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let latestJsonl = null;
+		let latestMtime = 0;
+		try {
+			for (const file of readdirSync(projectDir)) {
+				if (!file.endsWith(".jsonl")) continue;
+				const filePath = join(projectDir, file);
+				try {
+					const mtime = statSync(filePath).mtimeMs;
+					if (mtime > latestMtime) {
+						latestMtime = mtime;
+						latestJsonl = filePath;
+					}
+				} catch {
+					continue;
+				}
+			}
+		} catch {
+			continue;
+		}
+		if (!latestJsonl || latestMtime < cutoff) continue;
+		const project = db.prepare("SELECT slug, display_name, root_path FROM projects WHERE encoded_dir = ?").get(entry);
+		active.push({
+			slug: project?.slug ?? entry,
+			displayName: project?.display_name ?? project?.slug ?? entry,
+			rootPath: project?.root_path ?? "",
+			encodedDir: entry,
+			lastModified: new Date(latestMtime),
+			jsonlFile: latestJsonl
+		});
+	}
+	active.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = active.filter((a) => {
+		const key = a.slug.replace(/-\d+$/, "");
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+	if (opts.json) {
+		console.log(JSON.stringify(deduped.map((a) => ({
+			slug: a.slug,
+			display_name: a.displayName,
+			root_path: a.rootPath,
+			last_modified: a.lastModified.toISOString()
+		})), null, 2));
+		return;
+	}
+	if (deduped.length === 0) {
+		console.log(dim$1(`No active sessions in the last ${minutes} minutes.`));
+		return;
+	}
+	console.log(header(`Currently Active Sessions`) + dim$1(` (modified in last ${minutes}min)`));
+	console.log();
+	const rows = deduped.map((a) => {
+		const time = a.lastModified.toTimeString().slice(0, 5);
+		const dirName = a.rootPath ? a.rootPath.replace(homedir(), "~").split("/").pop() ?? a.slug : a.slug;
+		return [
+			chalk.cyan(dirName),
+			dim$1(a.slug),
+			chalk.green(time)
+		];
+	});
+	console.log(renderTable([
+		"Directory",
+		"Project",
+		"Last Active"
+	], rows));
+}
+async function cmdAutoRoute(opts) {
+	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("./auto-route-CdvjEWs5.mjs");
+	const { openRegistry } = await import("./db-BtuN768f.mjs").then((n) => n.t);
+	const { createStorageBackend } = await import("./factory-HcQsQqh0.mjs").then((n) => n.n);
+	const { loadConfig } = await import("./config-DGOfoGfm.mjs").then((n) => n.r);
+	const config = loadConfig();
+	const registryDb = openRegistry();
+	const federation = await createStorageBackend(config);
+	const targetCwd = opts.cwd ?? process.cwd();
+	const result = await autoRoute(registryDb, federation, targetCwd, opts.context);
+	if (!result) {
+		console.log();
+		console.log(warn("  No project match found for: " + targetCwd));
+		console.log();
+		console.log(dim$1("  Tried: path match, PAI.md marker walk") + (opts.context ? dim$1(", topic detection") : ""));
+		console.log();
+		console.log(dim$1("  Run 'pai project add .' to register this directory."));
+		console.log();
+		return;
+	}
+	if (opts.json) {
+		console.log(formatAutoRouteJson(result));
+		return;
+	}
+	console.log();
+	console.log(header("  PAI Auto-Route"));
+	console.log();
+	console.log(`  ${bold$1("Project:")}     ${result.display_name}`);
+	console.log(`  ${bold$1("Slug:")}        ${result.slug}`);
+	console.log(`  ${bold$1("Root path:")}   ${result.root_path}`);
+	console.log(`  ${bold$1("Method:")}      ${result.method}`);
+	console.log(`  ${bold$1("Confidence:")}  ${(result.confidence * 100).toFixed(0)}%`);
+	console.log();
+	console.log(ok("  Routed to: ") + bold$1(result.slug));
+	console.log();
+}
+
+//#endregion
+//#region src/cli/commands/session/checkpoint.ts
+/**
+* Session checkpoint command — appends a timestamped block to the active
+* session note. Designed for use in hooks; fast, silent, rate-limited.
+*/
+function findNotesDirForCwd() {
+	const cwd = process.cwd();
+	const claudeProjectsDir = join(homedir(), ".claude", "projects");
+	if (!existsSync(claudeProjectsDir)) return null;
+	const expectedEncoded = cwd.replace(/[/\s.\-]/g, "-");
+	let encodedDir = null;
+	try {
+		const entries = readdirSync(claudeProjectsDir);
+		if (entries.includes(expectedEncoded)) encodedDir = expectedEncoded;
+		else for (const entry of entries) {
+			const full = join(claudeProjectsDir, entry);
+			try {
+				if (!statSync(full).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			if (entry.replace(/-+$/, "") === expectedEncoded.replace(/-+$/, "")) {
+				encodedDir = entry;
+				break;
+			}
+		}
+	} catch {
+		return null;
+	}
+	if (!encodedDir) return null;
+	const notesDir = join(claudeProjectsDir, encodedDir, "Notes");
+	return existsSync(notesDir) ? notesDir : null;
+}
+function findLatestNoteFile(notesDir) {
+	let entries;
+	try {
+		entries = readdirSync(notesDir);
+	} catch {
+		return null;
+	}
+	const mdFiles = entries.filter((e) => e.endsWith(".md"));
+	if (mdFiles.length === 0) return null;
+	let latestPath = null;
+	let latestMtime = 0;
+	for (const file of mdFiles) {
+		const full = join(notesDir, file);
+		try {
+			const { mtimeMs } = statSync(full);
+			if (mtimeMs > latestMtime) {
+				latestMtime = mtimeMs;
+				latestPath = full;
+			}
+		} catch {}
+	}
+	return latestPath;
+}
+function checkpointTooRecent(notesDir, minGapSeconds) {
+	const safeKey = notesDir.replace(/[^a-zA-Z0-9]/g, "-").slice(-80);
+	const tmpFile = join(tmpdir(), `pai-checkpoint-${safeKey}`);
+	if (!existsSync(tmpFile)) return false;
+	try {
+		const { mtimeMs } = statSync(tmpFile);
+		return Date.now() - mtimeMs < minGapSeconds * 1e3;
+	} catch {
+		return false;
+	}
+}
+function touchCheckpointSentinel(notesDir) {
+	const safeKey = notesDir.replace(/[^a-zA-Z0-9]/g, "-").slice(-80);
+	const tmpFile = join(tmpdir(), `pai-checkpoint-${safeKey}`);
+	try {
+		writeFileSync(tmpFile, String(Date.now()), "utf8");
+	} catch {}
+}
+function cmdCheckpoint(message, opts) {
+	const minGapSeconds = parseInt(opts.minGap ?? "300", 10);
+	const notesDir = findNotesDirForCwd();
+	if (!notesDir) process.exit(0);
+	if (checkpointTooRecent(notesDir, minGapSeconds)) process.exit(0);
+	const notePath = findLatestNoteFile(notesDir);
+	if (!notePath) process.exit(0);
+	const block = `\n## Checkpoint — ${(/* @__PURE__ */ new Date()).toISOString()}\n${message}\n`;
+	const tmpPath = `${notePath}.checkpoint.tmp`;
+	try {
+		writeFileSync(tmpPath, readFileSync(notePath, "utf8") + block, "utf8");
+		renameSync(tmpPath, notePath);
+	} catch {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, tmpPath + ".dead");
+		} catch {}
+		process.exit(0);
+	}
+	touchCheckpointSentinel(notesDir);
+	process.exit(0);
+}
+
+//#endregion
+//#region src/cli/commands/session/pause.ts
+/** Format a session row as "0003 - 2026-08-01 - Title". */
+function formatSessionLine(session) {
+	if (!session) return "Unknown session";
+	const num = String(session.number).padStart(4, "0");
+	const titlePart = session.title || session.slug || "Session";
+	return `${num} - ${session.date} - ${titlePart}`;
+}
+/**
+* Resolve the string that identifies a session in a ## Continue block.
+*
+* THIS IS THE PRESERVATION KEY. It decides whether an authored checkpoint
+* belongs to the current session and must be left alone, so every writer must
+* derive it identically — `pai pause`, `pai session handover`, and the hooks'
+* updateTodoContinue. Deriving it in more than one place is how a checkpoint
+* gets clobbered: one writer says "0006 - …" and the other says
+* "Unknown session", the keys do not match, and the unattended writer replaces
+* work it should have preserved.
+*
+* The registry row is preferred. When the project has no session rows — which
+* happens whenever one codebase is registered under several paths — it falls
+* back to the session note's filename, which is what the hooks use.
+*/
+function resolveSessionLine(project, session, notePath) {
+	if (session) return formatSessionLine(session);
+	if (notePath) return basename(notePath).replace(/\.md$/, "");
+	return "Unknown session";
+}
+/** Locate the latest session note for a project, or null. */
+function resolveNotePath(project) {
+	const notesDir = findNotesDir$1(project.root_path, project.encoded_dir ?? "");
+	return notesDir ? findLatestNote(notesDir) : null;
+}
+/**
+* Resolve the project containing cwd, or undefined.
+*
+* Tries the literal path first, then its resolved form. A symlinked path
+* prefix (`~/dev -> Cloud/Development`) makes one directory reachable under
+* two spellings; matching only the literal string means a session started from
+* the other spelling finds nothing, and the scanner then registers a second
+* project for the same directory — which splits session history in half.
+*/
+function resolveProjectByCwd(db, cwd) {
+	const stmt = 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`);
+	const direct = stmt.get(cwd);
+	if (direct) return direct;
+	let resolved;
+	try {
+		resolved = realpathSync(cwd);
+	} catch {
+		return;
+	}
+	if (resolved === cwd) return void 0;
+	return stmt.get(resolved);
+}
+function printMissingBodyError() {
+	console.error("\n" + chalk.bgRed.white.bold("  CHECKPOINT BODY MISSING — nothing was written                ") + "\n\n" + chalk.yellow("  A checkpoint without a body is just a timestamp. The next session\n  would learn nothing about what was decided or what is blocked.\n") + "\n" + chalk.white("  Write your checkpoint markdown to a file, then re-run:\n") + "\n" + chalk.cyan("    pai pause --body-file /path/to/checkpoint.md \\\n") + chalk.cyan("              --session-id <claude-session-uuid>\n") + "\n" + chalk.dim("  Or pipe it:  ") + chalk.cyan("cat checkpoint.md | pai pause --body-file -\n") + "\n" + chalk.dim("  If you genuinely want a metadata-only checkpoint, pass --no-body.\n"));
+}
+function cmdPause(db, opts) {
+	let body = "";
+	if (opts.bodyFile) {
+		try {
+			body = readBodyFile(opts.bodyFile).trim();
+		} catch (err) {
+			console.error(chalk.red("pai pause: ") + `Could not read checkpoint body from ${opts.bodyFile}: ${String(err)}`);
+			process.exit(1);
+		}
+		if (!body) {
+			console.error(chalk.red("pai pause: ") + `Checkpoint body at ${opts.bodyFile} is empty.`);
+			process.exit(1);
+		}
+	} else if (!opts.noBody) {
+		printMissingBodyError();
+		process.exit(1);
+	}
+	const cwd = process.cwd();
+	const project = resolveProjectByCwd(db, cwd);
+	if (!project) {
+		console.error(chalk.red("pai 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 notePath = resolveNotePath(project);
+	const sessionLine = resolveSessionLine(project, session, notePath);
+	if (!session) {
+		const siblings = db.prepare(`SELECT p.slug, p.root_path, COUNT(s.id) AS n
+           FROM projects p LEFT JOIN sessions s ON s.project_id = p.id
+          WHERE p.id != ? AND (p.slug = ? OR p.slug LIKE ? || '-%' OR ? LIKE p.slug || '-%')
+          GROUP BY p.id HAVING n > 0
+          ORDER BY n DESC LIMIT 3`).all(project.id, project.slug, project.slug, project.slug);
+		console.log(chalk.yellow(`  Note: project '${project.slug}' has no registered sessions; the checkpoint is labelled from the session note instead ("${sessionLine}").`));
+		for (const s of siblings) console.log(chalk.dim(`        '${s.slug}' (${s.root_path}) has ${s.n} — likely the same project under another path.`));
+	}
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const result = applyContinue({
+		rootPath: project.root_path,
+		authored: body ? "model" : "auto",
+		sessionLine,
+		sessionId: opts.sessionId,
+		cwd,
+		body,
+		timestamp,
+		dryRun: opts.dryRun
+	});
+	if (result.action === "failed") {
+		console.error(chalk.red("pai pause: ") + `Failed to write TODO.md: ${result.error}`);
+		process.exit(1);
+	}
+	if (opts.dryRun) {
+		console.log("\n" + chalk.bold("Dry run — would write to:") + " " + chalk.cyan(result.path ?? "?"));
+		console.log(chalk.dim("─".repeat(60)));
+		console.log(chalk.dim(result.block));
+		console.log(chalk.dim("─".repeat(60)));
+	} else console.log(chalk.green("  ## Continue written to: ") + chalk.cyan(result.path ?? "?"));
+	if (body) if (!notePath) console.log(chalk.yellow("  (No session note found — checkpoint saved to TODO.md only.)"));
+	else if (opts.dryRun) console.log(chalk.dim(`  Would append checkpoint to: ${basename(notePath)}`));
+	else {
+		const { appended, error } = appendCheckpointToNote(notePath, body, timestamp);
+		if (appended) console.log(chalk.green("  Checkpoint appended to note: ") + chalk.cyan(basename(notePath)));
+		else if (error) console.log(chalk.yellow(`  (Could not append to session note: ${error})`));
+	}
+	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/handover.ts
+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 row = resolveProjectByCwd(db, process.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);
+	}
+	applyContinue({
+		rootPath: project.root_path,
+		authored: "auto",
+		sessionLine: resolveSessionLine(project, session, resolveNotePath(project)),
+		cwd: process.cwd()
+	});
+	process.exit(0);
+}
+
+//#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(allLiveSessions, allTabs) {
+	const displayed = allTabs ? allLiveSessions : allLiveSessions.filter((s) => s.kind !== "shell");
+	const skippedCount = allLiveSessions.length - displayed.length;
+	if (displayed.length === 0) return;
+	console.log("\n" + header("Live Sessions") + "\n");
+	const liveHeaders = [
+		"#",
+		"id",
+		"name",
+		"at prompt",
+		"kind"
+	];
+	const liveRows = displayed.map((s, idx) => {
+		const shortId = s.sessionId.slice(0, 8);
+		const rawName = s.paiName ?? s.name;
+		const name = rawName.length > 36 ? rawName.slice(0, 35) + "…" : rawName;
+		const atPrompt = s.atPrompt ? chalk.green("yes") : chalk.yellow("busy");
+		const kind = s.kind === "claude" ? chalk.cyan(s.kind) : chalk.dim(s.kind);
+		return [
+			chalk.dim(String(idx + 1)),
+			chalk.cyan(shortId),
+			name,
+			atPrompt,
+			kind
+		];
+	});
+	console.log(renderTable(liveHeaders, liveRows));
+	if (skippedCount > 0) console.log(dim$1(`  (${skippedCount} shell tab${skippedCount === 1 ? "" : "s"} hidden — use --all-tabs to show)`));
+}
+async function cmdRecent(db, opts) {
+	const limit = parseInt(opts.n ?? "20", 10);
+	const includeAll = opts.all === true;
+	const allTabs = opts.allTabs === true;
+	const liveSessions = await fetchLiveSessions();
+	const sessions = scanSessions(db, {
+		limit,
+		filter: includeAll ? "all" : "named"
+	});
+	if (opts.json) {
+		const output = {
+			live: liveSessions.map((s) => ({
+				index: s.index,
+				sessionId: s.sessionId,
+				name: s.name,
+				paiName: s.paiName,
+				atPrompt: s.atPrompt,
+				kind: s.kind,
+				active: s.active
+			})),
+			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 hasClaudeLive = liveSessions.some((s) => s.kind === "claude");
+	if (liveSessions.length > 0) renderLiveSessions(liveSessions, allTabs);
+	if (sessions.length === 0) {
+		if (!hasClaudeLive) if (includeAll) console.log(err("No sessions found in ~/.claude/projects/."));
+		else console.log(err("No named sessions found.\n\n  Named sessions appear when you have entries in ~/.claude/session.json\n  (set via /Name inside Claude Code) or resumable top-level jsonl files.\n  Run: pai session recent --all  to list all sessions including unnamed orphans."));
+		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$1("—");
+		return [
+			chalk.dim(String(idx + 1)),
+			chalk.cyan(s.shortId),
+			dim$1(fmtAge(s.mtime)),
+			name.length > 26 ? name.slice(0, 25) + "…" : name,
+			prompt,
+			s.userLines > 0 ? String(s.userLines) : dim$1("—"),
+			dim$1(fmtSize(s.topLevelSize)),
+			fmtStatus(s.sessionStatus)
+		];
+	});
+	console.log(renderTable(headers, rows));
+	console.log("\n" + dim$1("Go to a session:   ") + chalk.white("pai resume <name>") + "\n" + (hasClaudeLive ? dim$1("Pause all live:    ") + chalk.white("pai pause all") + "\n" : "") + (includeAll ? "" : dim$1("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$1(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) {
+		let msg = String(resolveErr).replace(/^Error: /, "");
+		if (msg.includes("No session found matching")) msg += `\n\nTip: pai find "${query}"  — search prompt history by keywords`;
+		console.error(err(msg));
+		process.exit(1);
+	}
+	const { session: matchedSession, friendlyName } = resolved;
+	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$1(resumableUuid, projectDir);
+		if (probe.ok) {
+			const result = spawnSync("claude", [
+				"--resume",
+				resumableUuid,
+				"--name",
+				name,
+				promptArg
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.error) {
+				console.error(err(`Failed to launch claude: ${result.error.message}`));
+				process.exit(1);
+			}
+			printExitDir(projectDir);
+			process.exit(result.status ?? 0);
+		} else {
+			process.stderr.write(chalk.yellow(`\n  Resume failed for ${resumableUuid.slice(0, 8)}: ${probe.reason ?? "unknown error"}\n  Starting fresh session in same directory.\n\n`));
+			const result = spawnSync("claude", [
+				"--name",
+				name,
+				promptArg
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.error) {
+				console.error(err(`Failed to launch claude: ${result.error.message}`));
+				process.exit(1);
+			}
+			printExitDir(projectDir);
+			process.exit(result.status ?? 0);
+		}
+	} else {
+		const result = spawnSync("claude", [
+			"--name",
+			name,
+			promptArg
+		], {
+			cwd: projectDir,
+			stdio: "inherit",
+			env: process.env
+		});
+		if (result.error) {
+			console.error(err(`Failed to launch claude: ${result.error.message}`));
+			process.exit(1);
+		}
+		printExitDir(projectDir);
+		process.exit(result.status ?? 0);
+	}
+}
+
+//#endregion
+//#region src/cli/commands/session/index.ts
+function registerSessionCommands(sessionCmd, getDb) {
+	sessionCmd.command("list").description("Resumable sessions catalog — named sessions with resume status.\nShort form: pai sessions\nDefault shows all sessions you've named or that are resumable.\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) => {
+		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) => {
+		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) => {
+		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) => {
+		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) => {
+		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) => {
+		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) => {
+		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) => {
+		cmdActive(getDb(), opts);
+	});
+	sessionCmd.command("recent").description("[Deprecated] Use `pai session list` or `pai sessions` 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(async (opts) => {
+		process.stderr.write("Deprecated: `pai session recent` — use `pai session list` or `pai sessions` instead.\n");
+		await cmdRecent(getDb(), opts);
+	});
+	sessionCmd.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.\nSends '/Name <name>\\ngo' as the initial prompt so the PAI ## Continue hook fires.").option("--skip-name", "Do not prepend /Name to set the session name in chrome").option("--skip-go", "Do not append \\ngo to trigger PAI auto-resume (## Continue)").option("--dry-run", "Print the exact argv and cwd, then exit without launching").action((nameOrId, opts) => {
+		process.stderr.write("Note: `pai session goto` works but `pai resume` is the new shorter form.\n");
+		cmdGoto(getDb(), nameOrId, {
+			noName: opts.skipName,
+			noGo: opts.skipGo,
+			dryRun: opts.dryRun
+		});
+	});
+	sessionCmd.command("pause").description("Write a ## Continue checkpoint to the project's TODO.md.\nRecommended short form: pai pause\nCtrl+C bypasses the stop-hook, orphaning the session (cannot --resume).\nUse /exit inside Claude Code to preserve full session resumability.").option("--dry-run", "Preview the ## Continue block without writing it").option("--body-file <path>", "File holding the checkpoint markdown to persist ('-' reads stdin). Required unless --no-body.").option("--session-id <uuid>", "Claude Code session UUID — recorded as the `claude --resume` handle").option("--no-body", "Deliberately write a metadata-only checkpoint (no content)").action((opts) => {
+		process.stderr.write("Note: `pai session pause` works but `pai pause` is the new shorter form.\n");
+		cmdPause(getDb(), {
+			dryRun: opts.dryRun,
+			bodyFile: opts.bodyFile,
+			sessionId: opts.sessionId,
+			noBody: opts.body === false
+		});
+	});
+	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) => {
+		await cmdAutoRoute(opts);
+	});
+}
+
+//#endregion
+//#region src/cli/commands/session-cleanup/types.ts
+const TEMPLATE_INDICATORS = [
+	"<!-- PAI will add completed work here during session -->",
+	"<!-- PAI will add completed work here -->",
+	"Session completed.",
+	"Session started and ready for your instructions"
+];
+const MODERN_PATTERN = /^(\d{4}) - (\d{4}-\d{2}-\d{2}) - (.+)\.md$/;
+const LEGACY_PATTERN = /^(\d{4})_(\d{4}-\d{2}-\d{2})_(.+)\.md$/;
+
+//#endregion
+//#region src/cli/commands/session-cleanup/rename.ts
+/**
+* Auto-name extraction and string helpers for session-cleanup.
+* Derives a meaningful session title from Markdown content.
+*/
+const META_PHRASE_PATTERNS = [
+	/session initialized and ready for your instructions/i,
+	/fresh session with no pending tasks/i,
+	/starting new session.*checking for pending work/i,
+	/fresh session with empty todo/i,
+	/session started and ready/i,
+	/^session\b.*\bready\b/i,
+	/^session\b.*\binitialized\b/i,
+	/^session\b.*\bno pending\b/i,
+	/^session\b.*\bno prior work\b/i,
+	/^no pending tasks/i,
+	/^no prior work/i
+];
+const TITLE_CASE_MINOR_WORDS = new Set([
+	"a",
+	"an",
+	"the",
+	"in",
+	"on",
+	"at",
+	"for",
+	"to",
+	"of",
+	"and",
+	"or",
+	"but",
+	"via",
+	"with",
+	"from",
+	"by",
+	"as",
+	"nor"
+]);
+function cleanMarkdownLine(raw) {
+	let s = raw.trim();
+	s = s.replace(/^[-*+]\s+\[[ xX]\]\s*/, "");
+	s = s.replace(/^[-*+]\s+/, "");
+	s = s.replace(/^\[[ xX]\]\s*/, "");
+	s = s.replace(/\*\*\s*([^*]+?)\s*\*\*/g, "$1");
+	s = s.replace(/\*\s*([^*]+?)\s*\*/g, "$1");
+	s = s.replace(/`([^`]+)`/g, "$1");
+	s = s.replace(/^\*+\s*/, "");
+	s = s.replace(/^[.,;:]+/, "").replace(/[.,;:]+$/, "");
+	s = s.replace(/\s+/g, " ").trim();
+	return s.length >= 4 ? s : null;
+}
+function isMetaPhrase(text) {
+	return META_PHRASE_PATTERNS.some((re) => re.test(text));
+}
+function toTitleCase(text) {
+	return text.split(" ").map((word, i) => {
+		const lower = word.toLowerCase();
+		if (i !== 0 && TITLE_CASE_MINOR_WORDS.has(lower)) return lower;
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join(" ");
+}
+function sanitizeName(raw) {
+	let s = raw.replace(/[\/\\:*?"<>|#`]/g, "");
+	s = s.replace(/\s+/g, " ").trim();
+	if (s.length > 60) {
+		const truncated = s.slice(0, 60);
+		const lastSpace = truncated.lastIndexOf(" ");
+		s = lastSpace > 20 ? truncated.slice(0, lastSpace) : truncated;
+	}
+	s = s.trim();
+	return toTitleCase(s);
+}
+function extractAutoName(content) {
+	const lines = content.split("\n");
+	const CONTENT_SECTION_HEADINGS = new Set([
+		"Work Done",
+		"Summary",
+		"Completed",
+		"What Was Done",
+		"Results",
+		"Outcomes",
+		"Changes",
+		"Progress"
+	]);
+	const SKIP_SECTION_HEADINGS = new Set([
+		"Next Steps",
+		"Tags",
+		"TODO",
+		"Blockers",
+		"Notes",
+		"Metadata",
+		"Context",
+		"Background"
+	]);
+	let pastH1 = false;
+	let pastFirstHr = false;
+	let currentSection = null;
+	const contentSectionLines = [];
+	const otherH2Headings = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("# ")) {
+			pastH1 = true;
+			continue;
+		}
+		if (!pastH1) continue;
+		if (!pastFirstHr) {
+			if (trimmed === "---") pastFirstHr = true;
+			continue;
+		}
+		if (trimmed.startsWith("## ")) {
+			const headingText = trimmed.slice(3).trim();
+			if (CONTENT_SECTION_HEADINGS.has(headingText)) currentSection = "content";
+			else if (SKIP_SECTION_HEADINGS.has(headingText)) currentSection = "skip";
+			else {
+				currentSection = null;
+				otherH2Headings.push(headingText);
+			}
+			continue;
+		}
+		if (trimmed.startsWith("#")) continue;
+		if (trimmed === "-->") continue;
+		if (trimmed.startsWith("<!--") && /^<!--.*-->$/.test(trimmed)) continue;
+		if (currentSection === "content" && trimmed.length > 0) {
+			const withoutComment = trimmed.replace(/^<!--.*?-->\s*/, "");
+			const effective = withoutComment.length > 0 ? withoutComment : trimmed;
+			if (effective.length === 0) continue;
+			contentSectionLines.push(effective);
+		}
+	}
+	for (const raw of contentSectionLines) {
+		const cleaned = cleanMarkdownLine(raw);
+		if (!cleaned) continue;
+		if (isMetaPhrase(cleaned)) continue;
+		if (cleaned.startsWith("<!--") || cleaned.includes("PAI will add")) continue;
+		if (cleaned.length < 5) continue;
+		return sanitizeName(cleaned);
+	}
+	for (const heading of otherH2Headings) {
+		const cleaned = cleanMarkdownLine(heading);
+		if (!cleaned) continue;
+		if (isMetaPhrase(cleaned)) continue;
+		if (cleaned.length > 3 && cleaned.length < 80) return sanitizeName(cleaned);
+	}
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("# ")) {
+			const title = trimmed.slice(2).trim();
+			if (/^Session \d{4}/i.test(title)) continue;
+			const cleaned = cleanMarkdownLine(title);
+			if (cleaned && !isMetaPhrase(cleaned) && cleaned.length > 3) return sanitizeName(cleaned);
+		}
+	}
+	return "Unnamed Session";
+}
+/** Format a 4-digit padded session number. */
+function padNum(n) {
+	return String(n).padStart(4, "0");
+}
+
+//#endregion
+//#region src/cli/commands/session-cleanup/scanner.ts
+function getAllProjects(db) {
+	return db.prepare("SELECT id, slug, display_name, root_path, encoded_dir, claude_notes_dir FROM projects WHERE status = 'active' ORDER BY slug").all();
+}
+function getProject(db, slug) {
+	return db.prepare("SELECT id, slug, display_name, root_path, encoded_dir, claude_notes_dir FROM projects WHERE slug = ?").get(slug);
+}
+function getProjectSessions(db, projectId) {
+	return db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number ASC").all(projectId);
+}
+function findRootNotesDir(rootPath) {
+	const canonical = join(rootPath, "Notes");
+	if (existsSync(canonical)) return canonical;
+	const alt = join(rootPath, ".claude", "Notes");
+	if (existsSync(alt)) return alt;
+	return null;
+}
+function findClaudeNotesDir(project, rootNotesDir) {
+	const candidate = project.claude_notes_dir ?? join(homedir(), ".claude", "projects", project.encoded_dir, "Notes");
+	if (!existsSync(candidate)) return null;
+	if (rootNotesDir && candidate === rootNotesDir) return null;
+	return candidate;
+}
+function findAllNotesDirs(project) {
+	const rootDir = findRootNotesDir(project.root_path);
+	const claudeDir = findClaudeNotesDir(project, rootDir);
+	const dirs = [];
+	if (rootDir) dirs.push(rootDir);
+	if (claudeDir) dirs.push(claudeDir);
+	return dirs;
+}
+function isTemplateOnly(content) {
+	if (!TEMPLATE_INDICATORS.some((ind) => content.includes(ind))) return false;
+	const lines = content.split("\n");
+	let inWorkDone = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed === "## Work Done") {
+			inWorkDone = true;
+			continue;
+		}
+		if (trimmed.startsWith("## ") && inWorkDone) break;
+		if (!inWorkDone) continue;
+		if (!trimmed) continue;
+		if (trimmed.startsWith("<!--") && trimmed.endsWith("-->")) continue;
+		if (trimmed.startsWith("<!--")) continue;
+		if (trimmed === "-->") continue;
+		if (trimmed === "Session completed.") continue;
+		if (trimmed === "#Session" || trimmed === "**Tags:** #Session") continue;
+		return false;
+	}
+	return true;
+}
+function scanNotesDir(notesDir, dbByFilename) {
+	const candidates = [];
+	let flatFiles = [];
+	try {
+		flatFiles = readdirSync(notesDir, { withFileTypes: true }).filter((d) => d.isFile() && d.name.endsWith(".md")).map((d) => d.name);
+	} catch {}
+	const subDirFiles = [];
+	try {
+		const topEntries = readdirSync(notesDir, { withFileTypes: true });
+		for (const entry of topEntries) {
+			if (!entry.isDirectory()) continue;
+			if (!/^\d{4}$/.test(entry.name)) continue;
+			const yearDir = join(notesDir, entry.name);
+			const monthDirs = readdirSync(yearDir, { withFileTypes: true });
+			for (const mEntry of monthDirs) {
+				if (!mEntry.isDirectory()) continue;
+				const monthDir = join(yearDir, mEntry.name);
+				const files = readdirSync(monthDir).filter((f) => f.endsWith(".md"));
+				for (const f of files) subDirFiles.push({
+					filename: f,
+					filepath: join(monthDir, f)
+				});
+			}
+		}
+	} catch {}
+	const allFiles = [...flatFiles.map((f) => ({
+		filename: f,
+		filepath: join(notesDir, f)
+	})), ...subDirFiles];
+	for (const { filename, filepath } of allFiles) {
+		let num;
+		let date;
+		let namepart;
+		let classification;
+		const modernMatch = MODERN_PATTERN.exec(filename);
+		const legacyMatch = LEGACY_PATTERN.exec(filename);
+		if (modernMatch) {
+			num = parseInt(modernMatch[1], 10);
+			date = modernMatch[2];
+			namepart = modernMatch[3];
+			classification = "NAMED";
+		} else if (legacyMatch) {
+			num = parseInt(legacyMatch[1], 10);
+			date = legacyMatch[2];
+			namepart = legacyMatch[3];
+			classification = "LEGACY_FORMAT";
+		} else continue;
+		let sizeBytes = 0;
+		let content = "";
+		try {
+			sizeBytes = statSync(filepath).size;
+			content = readFileSync(filepath, "utf8");
+		} catch {
+			continue;
+		}
+		const dbSession = dbByFilename.get(filename) ?? dbByFilename.get(filepath.split(`${notesDir}/`)[1] ?? "") ?? null;
+		if (classification !== "LEGACY_FORMAT") {
+			if (sizeBytes < 400 || isTemplateOnly(content)) classification = "EMPTY";
+			else if (namepart === "New Session" || namepart === (process.env.USER ?? "") || namepart === "session-started-and-ready-for-your-instructions") classification = "UNNAMED";
+		}
+		const candidate = {
+			session: dbSession,
+			filename,
+			filepath,
+			sizeBytes,
+			classification,
+			date,
+			number: num
+		};
+		if (classification === "UNNAMED" || classification === "LEGACY_FORMAT") candidate.autoName = extractAutoName(content);
+		candidates.push(candidate);
+	}
+	return candidates;
+}
+function buildRenumberMap(survivors) {
+	const map = /* @__PURE__ */ new Map();
+	[...survivors].sort((a, b) => a.number - b.number).forEach((s, idx) => {
+		const newNum = idx + 1;
+		if (s.number !== newNum) map.set(s.number, newNum);
+	});
+	return map;
+}
+function analyzeProject(db, project) {
+	const notesDirPaths = findAllNotesDirs(project);
+	if (notesDirPaths.length === 0) return null;
+	const dbSessions = getProjectSessions(db, project.id);
+	const dbByFilename = /* @__PURE__ */ new Map();
+	for (const s of dbSessions) dbByFilename.set(s.filename, s);
+	const notesDirPlans = [];
+	const allSurvivors = [];
+	for (const notesDir of notesDirPaths) {
+		const candidates = scanNotesDir(notesDir, dbByFilename);
+		if (candidates.length === 0) continue;
+		const toDelete = candidates.filter((c) => c.classification === "EMPTY");
+		const toRename = candidates.filter((c) => c.classification === "UNNAMED" || c.classification === "LEGACY_FORMAT");
+		const survivors = candidates.filter((c) => c.classification !== "EMPTY");
+		notesDirPlans.push({
+			notesDir,
+			toDelete,
+			toRename,
+			toMove: survivors
+		});
+		allSurvivors.push(...survivors);
+	}
+	if (notesDirPlans.length === 0) return null;
+	return {
+		project,
+		notesDirs: notesDirPlans,
+		renumberMap: buildRenumberMap(allSurvivors)
+	};
+}
+
+//#endregion
+//#region src/cli/commands/session-cleanup/executor.ts
+async function countVectorDbPaths(oldPaths) {
+	if (oldPaths.length === 0) return 0;
+	try {
+		const { loadConfig } = await import("./config-DGOfoGfm.mjs").then((n) => n.r);
+		const { PostgresBackend } = await import("./postgres-zjKqPl4X.mjs");
+		const config = loadConfig();
+		if (config.storageBackend !== "postgres") return 0;
+		const pgBackend = new PostgresBackend(config.postgres ?? {});
+		if (await pgBackend.testConnection()) {
+			await pgBackend.close();
+			return 0;
+		}
+		const pool = pgBackend.pool;
+		const placeholders = oldPaths.map((_, i) => `$${i + 1}`).join(", ");
+		const result = await pool.query(`SELECT COUNT(*)::text AS n FROM pai_files WHERE path IN (${placeholders})`, oldPaths);
+		await pgBackend.close();
+		return parseInt(result.rows[0]?.n ?? "0", 10);
+	} catch {
+		return 0;
+	}
+}
+async function updateVectorDbPaths(moves) {
+	if (moves.length === 0) return 0;
+	try {
+		const { loadConfig } = await import("./config-DGOfoGfm.mjs").then((n) => n.r);
+		const { PostgresBackend } = await import("./postgres-zjKqPl4X.mjs");
+		const config = loadConfig();
+		if (config.storageBackend !== "postgres") return 0;
+		const pgBackend = new PostgresBackend(config.postgres ?? {});
+		const connErr = await pgBackend.testConnection();
+		if (connErr) {
+			process.stderr.write(`[session-cleanup] Postgres unavailable (${connErr}). Skipping vector DB path update.\n`);
+			await pgBackend.close();
+			return 0;
+		}
+		const client = await pgBackend.pool.connect();
+		let filesUpdated = 0;
+		try {
+			await client.query("BEGIN", []);
+			for (const { oldPath, newPath } of moves) {
+				const r = await client.query("UPDATE pai_files SET path = $1 WHERE path = $2", [newPath, oldPath]);
+				filesUpdated += r.rowCount ?? 0;
+				await client.query("UPDATE pai_chunks SET path = $1 WHERE path = $2", [newPath, oldPath]);
+			}
+			await client.query("COMMIT", []);
+		} catch (e) {
+			await client.query("ROLLBACK", []);
+			throw e;
+		} finally {
+			client.release();
+		}
+		await pgBackend.close();
+		return filesUpdated;
+	} catch (e) {
+		process.stderr.write(`[session-cleanup] Failed to update vector DB paths: ${e}\n`);
+		return -1;
+	}
+}
+async function displayDryRun(plans) {
+	let totalDelete = 0;
+	let totalRename = 0;
+	let totalMove = 0;
+	let totalRenumber = 0;
+	for (const plan of plans) {
+		if (!(plan.notesDirs.some((d) => d.toDelete.length > 0 || d.toRename.length > 0 || d.toMove.length > 0) || plan.renumberMap.size > 0)) continue;
+		console.log();
+		console.log(header(`  Project: ${plan.project.display_name} (${plan.project.slug})`));
+		for (const dirPlan of plan.notesDirs) {
+			console.log(dim$1(`  Notes: ${dirPlan.notesDir}`));
+			if (dirPlan.toDelete.length > 0) {
+				console.log(bold$1("  DELETE (empty/template-only sessions):"));
+				for (const c of dirPlan.toDelete) {
+					console.log(`    ${chalk.red("DEL")}  ${dim$1(padNum(c.number))} - ${c.date} - ${c.filename.split(" - ").slice(2).join(" - ")} ${dim$1(`(${c.sizeBytes}b)`)}`);
+					totalDelete++;
+				}
+				console.log();
+			}
+			if (dirPlan.toRename.length > 0) {
+				console.log(bold$1("  RENAME (unnamed or legacy-format sessions):"));
+				for (const c of dirPlan.toRename) {
+					const autoName = c.autoName ?? "Unnamed Session";
+					console.log(`    ${chalk.yellow("REN")}  ${c.filename}`);
+					console.log(`         → ${padNum(c.number)} - ${c.date} - ${autoName}.md`);
+					totalRename++;
+				}
+				console.log();
+			}
+			if (dirPlan.toMove.length > 0) {
+				console.log(bold$1("  MOVE TO YYYY/MM/ hierarchy:"));
+				for (const c of dirPlan.toMove) {
+					const [year, month] = c.date.split("-");
+					console.log(`    ${chalk.cyan("MOV")}  ${c.filename}`);
+					console.log(`         → ${year}/${month}/${c.filename}`);
+					totalMove++;
+				}
+				console.log();
+			}
+		}
+		if (plan.renumberMap.size > 0) {
+			console.log(bold$1("  RENUMBER (after deletions, global across all Notes/ dirs):"));
+			for (const [oldN, newN] of plan.renumberMap) {
+				console.log(`    ${chalk.blue("NUM")}  #${padNum(oldN)} → #${padNum(newN)}`);
+				totalRenumber++;
+			}
+			console.log();
+		}
+	}
+	const wouldMovePaths = [];
+	for (const plan of plans) for (const dirPlan of plan.notesDirs) for (const c of dirPlan.toMove) {
+		const [year, month] = c.date.split("-");
+		const targetPath = join(dirPlan.notesDir, year, month, c.filename);
+		if (c.filepath !== targetPath) wouldMovePaths.push(c.filepath);
+	}
+	const vectorDbCount = await countVectorDbPaths(wouldMovePaths);
+	console.log();
+	console.log(bold$1("  Summary (dry-run):"));
+	console.log(`    ${chalk.red("DEL")}  ${totalDelete} empty sessions to delete`);
+	console.log(`    ${chalk.yellow("REN")}  ${totalRename} unnamed sessions to rename`);
+	console.log(`    ${chalk.blue("NUM")}  ${totalRenumber} sessions to renumber`);
+	console.log(`    ${chalk.cyan("MOV")}  ${totalMove} sessions to move into YYYY/MM/ dirs`);
+	if (vectorDbCount > 0) console.log(`    ${chalk.magenta("VEC")}  ${vectorDbCount} file path(s) will be updated in the vector DB (embeddings preserved)`);
+	else if (wouldMovePaths.length > 0) console.log(`    ${chalk.magenta("VEC")}  0 file path(s) found in vector DB for moved files (no embeddings to preserve)`);
+	console.log();
+	console.log(warn("  This is a dry-run. Add --execute to apply changes."));
+	console.log();
+}
+async function executeCleanup(db, plans, skipReindex) {
+	let deleted = 0;
+	let renamed = 0;
+	let moved = 0;
+	let renumbered = 0;
+	let dbUpdated = 0;
+	const vectorDbMoves = [];
+	for (const plan of plans) {
+		console.log();
+		console.log(header(`  Project: ${plan.project.display_name} (${plan.project.slug})`));
+		for (const dirPlan of plan.notesDirs) {
+			const { notesDir } = dirPlan;
+			if (plan.notesDirs.length > 1) console.log(dim$1(`  Directory: ${notesDir}`));
+			for (const c of dirPlan.toDelete) {
+				try {
+					unlinkSync(c.filepath);
+					console.log(ok(`  DEL  ${c.filename}`));
+					deleted++;
+				} catch (e) {
+					console.log(err(`  FAIL to delete ${c.filename}: ${e}`));
+				}
+				if (c.session) try {
+					db.prepare("DELETE FROM sessions WHERE id = ?").run(c.session.id);
+					dbUpdated++;
+				} catch (e) {
+					console.log(err(`  FAIL to remove session #${c.number} from DB: ${e}`));
+				}
+			}
+			for (const c of dirPlan.toRename) {
+				const autoName = c.autoName ?? "Unnamed Session";
+				const newFilename = `${padNum(c.number)} - ${c.date} - ${autoName}.md`;
+				const newPath = join(notesDir, newFilename);
+				if (c.filepath !== newPath) try {
+					renameSync(c.filepath, newPath);
+					console.log(ok(`  REN  ${c.filename}`));
+					console.log(dim$1(`       → ${newFilename}`));
+					renamed++;
+					c.filename = newFilename;
+					c.filepath = newPath;
+				} catch (e) {
+					console.log(err(`  FAIL rename ${c.filename}: ${e}`));
+					continue;
+				}
+				try {
+					const lines = readFileSync(newPath, "utf8").split("\n");
+					let h1Updated = false;
+					const updated = lines.map((line) => {
+						if (!h1Updated && line.startsWith("# ")) {
+							h1Updated = true;
+							return `# ${autoName}`;
+						}
+						return line;
+					});
+					if (!h1Updated) updated.unshift(`# ${autoName}`, "");
+					writeFileSync(newPath, updated.join("\n"), "utf8");
+				} catch {}
+				if (c.session) {
+					const normalizedSlug = autoName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+					try {
+						db.prepare("UPDATE sessions SET slug = ?, title = ?, filename = ? WHERE id = ?").run(normalizedSlug, autoName, newFilename, c.session.id);
+						dbUpdated++;
+					} catch (e) {
+						console.log(err(`  FAIL DB update for session #${c.number}: ${e}`));
+					}
+				}
+			}
+			if (plan.renumberMap.size > 0) {
+				const toRenumber = dirPlan.toMove.filter((c) => plan.renumberMap.has(c.number));
+				const tempFiles = [];
+				for (const c of toRenumber) {
+					const newNum = plan.renumberMap.get(c.number);
+					const tempPath = join(notesDir, `__tmp_${padNum(c.number)}_${c.filename}`);
+					try {
+						if (existsSync(c.filepath)) {
+							renameSync(c.filepath, tempPath);
+							tempFiles.push({
+								candidate: c,
+								tempPath,
+								newNum
+							});
+						}
+					} catch (e) {
+						console.log(err(`  FAIL temp-rename #${c.number}: ${e}`));
+					}
+				}
+				for (const { candidate: c, tempPath, newNum } of tempFiles) {
+					const newFilename = c.filename.replace(/^\d{4}/, padNum(newNum));
+					const newPath = join(notesDir, newFilename);
+					try {
+						renameSync(tempPath, newPath);
+						console.log(ok(`  NUM  #${padNum(c.number)} → #${padNum(newNum)}: ${newFilename}`));
+						renumbered++;
+						c.filename = newFilename;
+						c.filepath = newPath;
+						c.number = newNum;
+					} catch (e) {
+						console.log(err(`  FAIL final-rename #${newNum}: ${e}`));
+					}
+					if (existsSync(newPath)) try {
+						writeFileSync(newPath, readFileSync(newPath, "utf8").split("\n").map((line) => {
+							if (line.match(/^# Session \d{4}:/)) return line.replace(/^# Session \d{4}:/, `# Session ${padNum(newNum)}:`);
+							return line;
+						}).join("\n"), "utf8");
+					} catch {}
+				}
+				const dbRenumbers = tempFiles.filter(({ candidate: c }) => c.session != null).map(({ candidate: c, newNum }) => ({
+					session: c.session,
+					newNum,
+					newFilename: c.filename
+				}));
+				if (dbRenumbers.length > 0) {
+					const renumberDb = db.transaction(() => {
+						for (const { session, newNum } of dbRenumbers) db.prepare("UPDATE sessions SET number = ? WHERE id = ?").run(-newNum, session.id);
+						for (const { session, newNum, newFilename } of dbRenumbers) db.prepare("UPDATE sessions SET number = ?, filename = ? WHERE id = ?").run(newNum, newFilename, session.id);
+					});
+					try {
+						renumberDb();
+						dbUpdated += dbRenumbers.length;
+					} catch (e) {
+						console.log(err(`  FAIL DB renumber transaction: ${e}`));
+					}
+				}
+			}
+			for (const c of dirPlan.toMove) {
+				const [year, month] = c.date.split("-");
+				const targetDir = join(notesDir, year, month);
+				const targetPath = join(targetDir, c.filename);
+				if (c.filepath === targetPath) continue;
+				try {
+					mkdirSync(targetDir, { recursive: true });
+				} catch (e) {
+					console.log(err(`  FAIL mkdir ${targetDir}: ${e}`));
+					continue;
+				}
+				const oldAbsPath = c.filepath;
+				try {
+					if (existsSync(c.filepath)) {
+						renameSync(c.filepath, targetPath);
+						console.log(ok(`  MOV  ${c.filename}`));
+						console.log(dim$1(`       → ${year}/${month}/${c.filename}`));
+						moved++;
+						vectorDbMoves.push({
+							oldPath: oldAbsPath,
+							newPath: targetPath
+						});
+					}
+				} catch (e) {
+					console.log(err(`  FAIL move ${c.filename}: ${e}`));
+					continue;
+				}
+				const newFilenameInDb = `${year}/${month}/${c.filename}`;
+				if (c.session) try {
+					db.prepare("UPDATE sessions SET filename = ? WHERE id = ?").run(newFilenameInDb, c.session.id);
+					dbUpdated++;
+				} catch (e) {
+					console.log(err(`  FAIL DB update path for ${c.filename}: ${e}`));
+				}
+			}
+		}
+	}
+	let vectorDbUpdated = 0;
+	if (vectorDbMoves.length > 0) {
+		console.log();
+		console.log(dim$1(`  Updating ${vectorDbMoves.length} file path(s) in vector DB to preserve embeddings...`));
+		const result = await updateVectorDbPaths(vectorDbMoves);
+		if (result >= 0) {
+			vectorDbUpdated = result;
+			console.log(ok(`  Updated ${vectorDbUpdated} file path(s) in Postgres (embeddings preserved)`));
+		} else console.log(warn("  Vector DB path update failed — embeddings may be orphaned (check logs)"));
+	}
+	console.log();
+	console.log(bold$1("  Cleanup complete:"));
+	console.log(ok(`    ${deleted} session(s) deleted`));
+	console.log(ok(`    ${renamed} session(s) renamed`));
+	console.log(ok(`    ${renumbered} session(s) renumbered`));
+	console.log(ok(`    ${moved} session(s) moved to YYYY/MM/ hierarchy`));
+	console.log(ok(`    ${dbUpdated} registry DB record(s) updated`));
+	if (vectorDbMoves.length > 0) console.log(ok(`    ${vectorDbUpdated} vector DB file path(s) updated (embeddings preserved)`));
+	if (!skipReindex) {
+		console.log();
+		console.log(dim$1("  Memory re-index: the PAI daemon will pick up changes within 5 minutes."));
+		console.log(dim$1("  To force immediate re-index: pai memory index --all"));
+	}
+	console.log();
+}
+
+//#endregion
+//#region src/cli/commands/session-cleanup/index.ts
+function registerSessionCleanupCommand(sessionCmd, getDb) {
+	sessionCmd.command("cleanup [project-slug]").description("Clean up session notes: delete empties, auto-name unnamed, move into YYYY/MM/ hierarchy, renumber").option("--execute", "Actually perform the cleanup (default is dry-run)").option("--no-renumber", "Skip renumbering sessions after deletions").option("--no-reindex", "Skip triggering memory re-index after moves").action(async (projectSlug, opts) => {
+		const db = getDb();
+		const dryRun = !opts.execute;
+		const skipReindex = opts.reindex === false;
+		let projects;
+		if (projectSlug) {
+			const p = getProject(db, projectSlug);
+			if (!p) {
+				console.error(err(`Project not found: ${projectSlug}`));
+				process.exit(1);
+			}
+			projects = [p];
+		} else projects = getAllProjects(db);
+		console.log();
+		console.log(header(dryRun ? "  pai session cleanup — DRY RUN (no changes will be made)" : "  pai session cleanup — EXECUTING"));
+		console.log(dim$1(`  Analyzing ${projects.length} project(s)...`));
+		const plans = [];
+		for (const project of projects) {
+			const plan = analyzeProject(db, project);
+			if (plan) plans.push(plan);
+		}
+		const activePlans = plans.filter((p) => p.notesDirs.some((d) => d.toDelete.length > 0 || d.toRename.length > 0 || d.toMove.length > 0) || p.renumberMap.size > 0);
+		if (activePlans.length === 0) {
+			console.log();
+			console.log(ok("  Nothing to do — all session notes are clean!"));
+			console.log();
+			return;
+		}
+		if (dryRun) await displayDryRun(activePlans);
+		else await executeCleanup(db, activePlans, skipReindex);
+	});
+}
+
+//#endregion
+//#region src/cli/commands/session/end.ts
+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(project.root_path, project.encoded_dir ?? "");
+	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);
@@ -8526,164 +10607,6 @@ function printEndBox(dryRun) {
 	console.log(box);
 }
 
-//#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$1(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) {
-		let msg = String(resolveErr).replace(/^Error: /, "");
-		if (msg.includes("No session found matching")) msg += `\n\nTip: pai find "${query}"  — search prompt history by keywords`;
-		console.error(err(msg));
-		process.exit(1);
-	}
-	const { session: matchedSession, friendlyName } = resolved;
-	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$1(resumableUuid, projectDir);
-		if (probe.ok) {
-			const result = spawnSync("claude", [
-				"--resume",
-				resumableUuid,
-				"--name",
-				name,
-				promptArg
-			], {
-				cwd: projectDir,
-				stdio: "inherit",
-				env: process.env
-			});
-			if (result.error) {
-				console.error(err(`Failed to launch claude: ${result.error.message}`));
-				process.exit(1);
-			}
-			printExitDir(projectDir);
-			process.exit(result.status ?? 0);
-		} else {
-			process.stderr.write(chalk.yellow(`\n  Resume failed for ${resumableUuid.slice(0, 8)}: ${probe.reason ?? "unknown error"}\n  Starting fresh session in same directory.\n\n`));
-			const result = spawnSync("claude", [
-				"--name",
-				name,
-				promptArg
-			], {
-				cwd: projectDir,
-				stdio: "inherit",
-				env: process.env
-			});
-			if (result.error) {
-				console.error(err(`Failed to launch claude: ${result.error.message}`));
-				process.exit(1);
-			}
-			printExitDir(projectDir);
-			process.exit(result.status ?? 0);
-		}
-	} else {
-		const result = spawnSync("claude", [
-			"--name",
-			name,
-			promptArg
-		], {
-			cwd: projectDir,
-			stdio: "inherit",
-			env: process.env
-		});
-		if (result.error) {
-			console.error(err(`Failed to launch claude: ${result.error.message}`));
-			process.exit(1);
-		}
-		printExitDir(projectDir);
-		process.exit(result.status ?? 0);
-	}
-}
-
 //#endregion
 //#region src/cli/commands/session/pause-all.ts
 /**
@@ -8845,96 +10768,6 @@ async function cmdClearNames(opts) {
 	} else console.log(ok("\nDone. Use /Name to re-label each tab."));
 }
 
-//#endregion
-//#region src/cli/commands/session/helpers.ts
-function getProject(db, slug) {
-	return db.prepare("SELECT id, slug, display_name, root_path, encoded_dir FROM projects WHERE slug = ?").get(slug);
-}
-function statusColor(status) {
-	switch (status) {
-		case "completed": return chalk.green(status);
-		case "compacted": return chalk.blue(status);
-		default: return chalk.yellow(status);
-	}
-}
-
-//#endregion
-//#region src/cli/commands/session/commands.ts
-function cmdList(db, projectSlug, opts) {
-	const limit = parseInt(opts.limit ?? "20", 10);
-	const params = [];
-	let query = `
-    SELECT s.*, p.slug AS project_slug, p.display_name AS project_name
-    FROM sessions s
-    JOIN projects p ON p.id = s.project_id
-  `;
-	const where = [];
-	if (projectSlug) {
-		const project = getProject(db, projectSlug);
-		if (!project) {
-			console.error(err(`Project not found: ${projectSlug}`));
-			process.exit(1);
-		}
-		where.push("s.project_id = ?");
-		params.push(project.id);
-	}
-	if (opts.status) {
-		where.push("s.status = ?");
-		params.push(opts.status);
-	}
-	if (where.length) query += " WHERE " + where.join(" AND ");
-	query += " ORDER BY s.date DESC, s.number DESC";
-	query += ` LIMIT ${limit}`;
-	const rows = db.prepare(query).all(...params);
-	if (!rows.length) {
-		console.log(warn("No sessions found."));
-		return;
-	}
-	const showProject = !projectSlug;
-	const headers = showProject ? [
-		"#",
-		"Project",
-		"Date",
-		"Title",
-		"Status",
-		"Tokens"
-	] : [
-		"#",
-		"Date",
-		"Title",
-		"Status",
-		"Tokens"
-	];
-	const tableRows = rows.map((r) => {
-		const title = r.title.length > 45 ? r.title.slice(0, 42) + "..." : r.title;
-		const tokens = r.token_count != null ? dim$1(r.token_count.toLocaleString()) : dim$1("—");
-		if (showProject) return [
-			dim$1(`#${r.number}`),
-			r.project_slug,
-			r.date,
-			title,
-			statusColor(r.status),
-			tokens
-		];
-		return [
-			dim$1(`#${r.number}`),
-			r.date,
-			title,
-			statusColor(r.status),
-			tokens
-		];
-	});
-	console.log();
-	if (projectSlug) {
-		const project = getProject(db, projectSlug);
-		console.log(`  ${bold$1(project.display_name)} sessions:`);
-		console.log();
-	}
-	console.log(renderTable(headers, tableRows));
-	console.log();
-	console.log(dim$1(`  ${rows.length} session(s) shown (limit: ${limit})`));
-}
-
 //#endregion
 //#region src/cli/commands/find.ts
 /**
@@ -9304,7 +11137,7 @@ function buildFeedFrom(allSessions, projects, liveSessions, allProjects) {
 	const nameRoot = /* @__PURE__ */ new Map();
 	for (const p of allProjects) {
 		slugRoot.set(p.slug, p.root_path);
-		nameRoot.set(normalizeName(p.display_name ?? p.slug).toLowerCase(), p.root_path);
+		nameRoot.set(normalizeName$1(p.display_name ?? p.slug).toLowerCase(), p.root_path);
 	}
 	const bestResumable = /* @__PURE__ */ new Map();
 	for (const s of allSessions) {
@@ -9706,5 +11539,5 @@ async function cmdPick(db, opts = {}) {
 }
 
 //#endregion
-export { registerDaemonCommands as C, registerProjectsCommands as D, registerRegistryCommands as E, findMovedPath as O, registerBackupCommands as S, registerMemoryCommands as T, registerObservationCommands as _, cmdPauseAll as a, registerSetupCommand as b, cmdPause as c, registerKgCommands as d, registerTopicCommands as f, registerSkillCommands as g, registerUpdateCommand as h, cmdClearNames as i, resolveIdentifier as k, registerHelpCommand as l, registerNotifyCommands as m, cmdFind as n, cmdGoto as o, registerTaskCommands as p, cmdList as r, cmdEnd as s, cmdPick as t, registerDbCommands as u, registerZettelCommands as v, registerMcpCommands as w, registerRestoreCommands as x, registerObsidianCommands as y };
-//# sourceMappingURL=pick-gne3kOJG.mjs.map
+export { findMovedPath as A, registerRestoreCommands as C, registerMemoryCommands as D, registerMcpCommands as E, registerRegistryCommands as O, registerSetupCommand as S, registerDaemonCommands as T, registerUpdateCommand as _, cmdEnd as a, registerZettelCommands as b, cmdGoto as c, registerHelpCommand as d, registerDbCommands as f, registerNotifyCommands as g, registerTaskCommands as h, cmdPauseAll as i, resolveIdentifier as j, registerProjectsCommands as k, cmdPause as l, registerTopicCommands as m, cmdFind as n, registerSessionCleanupCommand as o, registerKgCommands as p, cmdClearNames as r, registerSessionCommands as s, cmdPick as t, cmdList as u, registerSkillCommands as v, registerBackupCommands as w, registerObsidianCommands as x, registerObservationCommands as y };
+//# sourceMappingURL=pick-B3zEYjin.mjs.map