@tekmidian/pai 0.30.1 → 0.32.0

package/dist/{pick-BcmBBfOF.mjs → pick-DlsM0ppq.mjs}

@@ -1,5 +1,5 @@
 import { n as openRegistry } from "./db-BtuN768f.mjs";
-import { _ as warn$1, a as fmtDate, c as ok$1, 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 { _ as warn$1, a as fmtDate, c as ok$1, d as scaffoldProjectDirs, f as shortenPath, h as smartDecodeDir, 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";
@@ -11,12 +11,12 @@ import { _ as transcriptFiles, a as readBodyFile, c as loadScanConfig, d as save
 import { a as schedulerLogPath, i as paiSocketPath, n as daemonLogPath, r as daemonPidPath } from "./runtime-paths-B0P1TvUr.mjs";
 import { t as PaiClient } from "./ipc-client-aVKVERjJ.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-CcdkNSWa.mjs";
-import { t as createStorageBackend } from "./factory-BqAdO21B.mjs";
+import { i as humanDuration, t as createStorageBackend } from "./factory-BydJSrZJ.mjs";
 import { s as kgQuery } from "./kg-entity-r8duqhi9.mjs";
-import { a as renderDedupedSessions, c as fetchLiveSessions, d as fmtAge, f as resolveSessionByNameOrId, i as normalizeName$2, l as revealItermSession, o as printExitDir, p as scanSessions, r as buildDeduped, s as callAiBroker, u as sendToSession } from "./main-resolver-BfSL8zio.mjs";
+import { _ as scanSessions, a as renderDedupedSessions, c as probeResume, d as callAiBroker, f as fetchLiveSessions, g as resolveSessionByNameOrId, h as fmtAge, i as normalizeName$2, l as restoreTopLevel, m as sendToSession, o as hasConversation, p as revealItermSession, r as buildDeduped, s as launchInDir, u as printExitDir } from "./main-resolver-DjyUDJrv.mjs";
 import { appendFileSync, chmodSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, platform, tmpdir } from "node:os";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { fileURLToPath } from "node:url";
 import { execFile, execFileSync, execSync, spawn, spawnSync } from "node:child_process";
@@ -24,6 +24,61 @@ import { createInterface } from "node:readline";
 import { createConnection } from "net";
 import { promisify } from "node:util";
 
+//#region src/registry/registrable.ts
+/**
+* registrable.ts — directories that must never become registered projects.
+*
+* A project is a durable thing. The registry, however, has been accepting
+* whatever directory a session happened to start in, and some of those
+* directories are disposable by construction. Measured on the real registry,
+* 2026-08-04:
+*
+*   08 - Others/MDF/Infrastruktur/.claude/worktrees/cool-haibt      1 session
+*   08 - Others/MDF/Infrastruktur/.claude/worktrees/strange-haibt   7 sessions
+*   /private/tmp/ops-webui                                          dead
+*   /private/tmp/claude-501/-Users-…-AIBroker/aae854c6-…            dead
+*
+* The worktrees are agent isolation directories, created to be removed. The temp
+* paths are exactly what their name says. Registering them attributes session
+* history to a location with no future, and lets `pai <name>` route someone into
+* a directory a cleanup can delete underneath them.
+*
+* So this refuses at the point of registration rather than reclassifying
+* afterwards. It is a guard, not a policy about what health should call things —
+* it stops the set growing while the vocabulary question (dead vs duplicate vs
+* misnamed vs ephemeral) is decided separately.
+*
+* Found by the AIBroker session while we were dividing up the dead-path work.
+*/
+/** Path fragments that mark a location as disposable, with why. */
+const EPHEMERAL = [
+	{
+		fragment: `${sep}.claude${sep}worktrees${sep}`,
+		because: "a git worktree created for agent isolation — it is meant to be removed"
+	},
+	{
+		fragment: `${sep}private${sep}tmp${sep}`,
+		because: "a system temp directory"
+	},
+	{
+		fragment: `${sep}var${sep}folders${sep}`,
+		because: "a macOS per-user temp directory"
+	}
+];
+/**
+* Why this path cannot be a project, or undefined if it can.
+*
+* Returns the reason rather than a boolean so the caller can tell the user which
+* rule caught them — "refused" without a reason invites someone to work around it
+* rather than move their project somewhere durable.
+*/
+function unregistrableReason(rootPath) {
+	const padded = rootPath.endsWith(sep) ? rootPath : rootPath + sep;
+	for (const { fragment, because } of EPHEMERAL) if (padded.includes(fragment)) return because;
+	if (padded.startsWith(`${sep}tmp${sep}`)) return "a system temp directory";
+}
+
+//#endregion
 //#region src/session/promote.ts
 /**
 * Derive a human-readable project name from a session note filename.
@@ -74,6 +129,13 @@ function cmdPromote(db, opts) {
 		console.error(err(`Could not derive a valid slug from name: "${displayName}"`));
 		process.exit(1);
 	}
+	const ephemeral = unregistrableReason(targetPath);
+	if (ephemeral) {
+		console.error(err(`Refusing to promote into ${targetPath}`));
+		console.error(dim$1(`  That is ${ephemeral}.`));
+		console.error(dim$1(`  Pick a durable location for the new project.`));
+		process.exit(1);
+	}
 	const encodedDir = encodeDir(targetPath);
 	if (db.prepare("SELECT id FROM projects WHERE slug = ? OR root_path = ? OR encoded_dir = ?").get(slug, targetPath, encodedDir)) {
 		console.error(err(`A project with slug "${slug}" or path "${targetPath}" is already registered.`));
@@ -360,6 +422,13 @@ function cmdAdd(db, rawPath, opts) {
 		console.error(err(`Invalid type "${type}". Valid: ${validTypes.join(", ")}`));
 		process.exit(1);
 	}
+	const ephemeral = unregistrableReason(rootPath);
+	if (ephemeral) {
+		console.error(err(`Refusing to register ${shortenPath(rootPath, 60)}`));
+		console.error(dim$1(`  That is ${ephemeral}.`));
+		console.error(dim$1(`  A project needs a durable location — move it, then register.`));
+		process.exit(1);
+	}
 	if (db.prepare("SELECT id FROM projects WHERE slug = ? OR root_path = ?").get(slug, rootPath)) {
 		console.error(err(`Project already registered (slug: ${slug} or path: ${rootPath})`));
 		process.exit(1);
@@ -1170,6 +1239,197 @@ function cmdConfig(db, identifier, opts) {
 	console.log();
 }
 
+//#endregion
+//#region src/cli/commands/project/relocate.ts
+/**
+* relocate.ts — find a registered project whose ancestor directory was renamed.
+*
+* The registry stores absolute root paths. Rename any directory ABOVE a project
+* and every project underneath it goes missing at once — `existsSync` fails, and
+* the health check reported them as dead and offered to archive them. Renaming
+* `Ideaverse` to `🧠 Ideaverse` orphaned a whole subtree that way: 32 entries, all
+* still on disk, none of them findable.
+*
+* The old suggestion logic could not see this. It took the project's BASENAME and
+* looked for it in four hardcoded directories (`~/dev`, `~/dev/ai`, `~/Desktop`,
+* `~/Projects`), so it could only recognise "the leaf moved into a place I already
+* know about". A renamed ancestor leaves the leaf exactly where it was.
+*
+* So walk down from the root while the path still exists — that lands on the
+* deepest surviving ancestor, which is precisely where the rename happened — then
+* match the remaining segments by NORMALISED name. Normalising strips the emoji,
+* the space and the case, so `🧠 Ideaverse` and `Ideaverse` both reduce to
+* "ideaverse". The general case is "an ancestor was renamed decoratively", which
+* is the whole class of failure rather than this one instance of it.
+*
+* Algorithm and the measurements behind it come from the AIBroker session, which
+* probed it and handed it over rather than implementing it in a file that was not
+* theirs.
+*/
+/**
+* A directory name reduced to what a rename is unlikely to have changed.
+*
+* NFC first because macOS hands back decomposed Unicode: an "ä" typed in one
+* place and read from a directory listing in another are different byte
+* sequences, and comparing them raw fails for reasons no one can see. Then case
+* and every non-alphanumeric are dropped, which is what makes `🧠 Ideaverse`
+* match `Ideaverse` — and, unavoidably, what makes `my-project` match
+* `my project`. That looseness is the point, and the uniqueness rule below is
+* what keeps it safe.
+*/
+function norm(s) {
+	return s.normalize("NFC").toLowerCase().replace(/[^\p{Letter}\p{Number}]+/gu, "");
+}
+/** Hidden by Unix convention — tool state rather than a project directory. */
+function isHidden(name) {
+	return name.startsWith(".");
+}
+/**
+* Drop a leading ordering prefix: `20 - Webseiten` -> `Webseiten`.
+*
+* This vault numbers directories to force sort order — `04 - Ablage`,
+* `08 - Others`, `01 - Base Setup`, `20 - Webseiten` — and adding or removing that
+* prefix is a rename of exactly the same kind as adding an emoji. `norm()` alone
+* cannot see it, because the digits survive normalisation: "webseiten" against
+* "20webseiten".
+*
+* Found because `MDF.md` links to `Infrastruktur/20 - Webseiten` while the
+* registry has a dead entry for plain `Infrastruktur/Webseiten`. The note files
+* knew where it went.
+*
+* Deliberately NOT a general suffix match, and the reason is worth spelling out
+* because "why not just match on the suffix" is the obvious next question.
+*
+* `MDF/Infrastruktur/` is wall-to-wall numbered: `00 - Migration Analysis`,
+* `01 - Base Setup`, `02 - Storage Setup`, `03 - Network Setup`, and so on. A
+* suffix rule on a wanted `Setup` hits eight of them at once — so the uniqueness
+* rule below would veto it, and the danger would never show itself. The one that
+* bites is a wanted `Analysis` against `00 - Migration Analysis`: a single hit,
+* therefore silently relocated, therefore wrong, and uniqueness cannot save you
+* because there is nothing ambiguous about it.
+*
+* That is a failure mode this file's own safety rule would have HIDDEN rather than
+* caught. Only a leading run of digits with optional separator comes off.
+*/
+function stripOrderingPrefix(name) {
+	return name.replace(/^\d+\s*[-._)]?\s*/, "");
+}
+/**
+* The names under which a directory can be recognised.
+*
+* Both spellings are offered from both sides, so the prefix can have been added
+* OR removed since the path was registered.
+*/
+function matchKeys(name) {
+	const keys = /* @__PURE__ */ new Set();
+	const bare = norm(name);
+	if (bare) keys.add(bare);
+	const stripped = norm(stripOrderingPrefix(name));
+	if (stripped) keys.add(stripped);
+	return keys;
+}
+function shareAKey(a, b) {
+	for (const k of a) if (b.has(k)) return true;
+	return false;
+}
+/**
+* Resolve symlinks so two spellings of one directory compare equal.
+*
+* Falls back to the input when it cannot resolve — a path that does not exist has
+* no real path, and for the duplicate check below "unresolvable" must not
+* accidentally equal some other unresolvable path.
+*/
+function realOrSelf(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function isDir(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Where a project went when a directory above it was renamed.
+*
+* Returns undefined rather than a guess whenever it cannot be certain — see the
+* uniqueness rule inside. undefined means "still dead as far as this can tell",
+* which leaves the entry exactly as it was.
+*/
+function relocateRenamedAncestor(rootPath) {
+	if (existsSync(rootPath)) return void 0;
+	const segments = rootPath.split(sep).filter((s) => s.length > 0);
+	if (segments.length === 0) return void 0;
+	let current = rootPath.startsWith(sep) ? sep : "";
+	let i = 0;
+	for (; i < segments.length; i++) {
+		const next = join(current, segments[i]);
+		if (!existsSync(next)) break;
+		current = next;
+	}
+	if (i === segments.length) return void 0;
+	for (; i < segments.length; i++) {
+		const wanted = matchKeys(segments[i]);
+		if (wanted.size === 0) return void 0;
+		let children;
+		try {
+			children = readdirSync(current);
+		} catch {
+			return;
+		}
+		const hits = children.filter((c) => isDir(join(current, c)) && shareAKey(matchKeys(c), wanted) && isHidden(c) === isHidden(segments[i]));
+		if (hits.length !== 1) return void 0;
+		current = join(current, hits[0]);
+	}
+	return current;
+}
+/**
+* The pre-existing guess: the project's leaf name in one of a few usual places.
+*
+* Kept, and kept SECOND, because it answers a different question — "the project
+* itself was moved somewhere I know about" rather than "an ancestor was renamed".
+* It is the weaker of the two: matching on basename alone can point at an
+* unrelated directory that happens to share a name, so it only gets to answer
+* when the ancestor walk has declined.
+*/
+function suggestByBasename(rootPath) {
+	const name = basename(rootPath);
+	const candidates = [
+		join(homedir(), "dev", name),
+		join(homedir(), "dev", "ai", name),
+		join(homedir(), "Desktop", name),
+		join(homedir(), "Projects", name)
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+}
+/**
+* Where a missing project probably is, or undefined.
+*
+* Feeds the health check's `suggestedPath ? "stale" : "dead"` classification, so
+* an answer here moves an entry out of the dead list and into the one `--fix`
+* repairs.
+*
+* `otherRoots` is every OTHER registered project's root path, and it is what
+* stops a repair from becoming a duplicate. Caught by the AIBroker session on the
+* first version of this: `~/PAI` was "recovered" to `~/dev/ai/PAI`, which is a
+* second spelling of `~/Daten/Cloud/Development/ai/PAI` — a path an ACTIVE project
+* already owns. Two registry entries for one directory is the exact mess that was
+* merged out of this registry earlier the same day.
+*
+* The comparison must be by realpath, not string. String equality is precisely
+* what missed it: the two paths share not one character after `/Users/i052341/`.
+*/
+function suggestMovedPath(rootPath, otherRoots = []) {
+	const candidate = relocateRenamedAncestor(rootPath) ?? suggestByBasename(rootPath);
+	if (!candidate) return void 0;
+	if (new Set(otherRoots.map(realOrSelf)).has(realOrSelf(candidate))) return void 0;
+	return candidate;
+}
+
 //#endregion
 //#region src/cli/commands/project/health.ts
 function findOrphanedNotesDirs(project) {
@@ -1193,15 +1453,66 @@ function findOrphanedNotesDirs(project) {
 	} catch {}
 	return results;
 }
-function suggestMovedPath(project) {
-	const name = basename(project.root_path);
-	const candidates = [
-		join(homedir(), "dev", name),
-		join(homedir(), "dev", "ai", name),
-		join(homedir(), "Desktop", name),
-		join(homedir(), "Projects", name)
-	];
-	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+/**
+* Why a row is unhealthy, and what to do about it.
+*
+* `category` said only dead / stale / active, and "archive" was offered as the
+* remedy for everything. Four different situations were collapsed into that, and
+* archiving is right for exactly one of them:
+*
+*   EPHEMERAL   the path is a worktree or a temp dir — it should never have been
+*               registered. Checked FIRST, deliberately: a temp path whose
+*               directory has also vanished is both ephemeral and dead, and
+*               "should never have been registered" is the stronger and more
+*               actionable statement. Without a stated precedence the same row
+*               gets different labels depending on evaluation order.
+*   DUPLICATE   the path is gone and another project owns where it went. Its
+*               sessions are the only thing of value on it, so the remedy is
+*               merge — archiving strands them.
+*   MISNAMED    the path EXISTS and another project owns a subtree of it, under a
+*               slug that has nothing to do with it. `pferde` on `08 - Others/MDF`.
+*               health never reported this at all, because existsSync says yes.
+*   DEAD        the path is gone and nothing claims it. Archive is correct here.
+*
+* The action must never name a command that destroys a row holding sessions —
+* a wrong command in an action field reads as vetted.
+*/
+function diagnose(project, pathExists, others) {
+	const ephemeral = unregistrableReason(project.root_path);
+	if (ephemeral) return {
+		reason: "ephemeral",
+		action: project.session_count > 0 ? `holds ${project.session_count} session(s) — pai project merge ${project.slug} <durable-project> --execute, then unregister` : `pai project unregister ${project.slug} --execute  (${ephemeral})`
+	};
+	if (pathExists) {
+		const nested = others.find((o) => o.status === "active" && o.root_path.startsWith(project.root_path + "/") && existsSync(o.root_path));
+		if (nested && project.status !== "active") return {
+			reason: "misnamed",
+			owner: nested.slug,
+			action: `live directory, but ${nested.slug} owns a subtree of it — rename, or pai project merge ${project.slug} ${nested.slug}`
+		};
+		return {};
+	}
+	const suggestion = suggestMovedPath(project.root_path, []);
+	if (suggestion) {
+		const owner = others.find((o) => o.root_path === suggestion || realpathEq(o.root_path, suggestion));
+		if (owner) return {
+			reason: "duplicate",
+			owner: owner.slug,
+			action: project.session_count > 0 ? `pai project merge ${project.slug} ${owner.slug}  (moves ${project.session_count} session(s))` : `pai project merge ${project.slug} ${owner.slug}  (no sessions — a plain drop)`
+		};
+	}
+	return {
+		reason: "dead",
+		action: project.session_count > 0 ? `holds ${project.session_count} session(s) — merge before archiving, or they become unreachable` : `pai project archive ${project.slug}`
+	};
+}
+/** Same directory under two spellings — symlinks, not string equality. */
+function realpathEq(a, b) {
+	try {
+		return realpathSync(a) === realpathSync(b);
+	} catch {
+		return false;
+	}
 }
 function cmdHealth$1(db, opts) {
 	const rows = db.prepare(`SELECT p.*,
@@ -1211,19 +1522,24 @@ function cmdHealth$1(db, opts) {
 	const results = rows.map((project) => {
 		const pathExists = existsSync(project.root_path);
 		const orphaned = findOrphanedNotesDirs(project);
+		const others = rows.filter((r) => r.id !== project.id);
 		let category;
 		let suggestedPath;
 		if (pathExists) category = "active";
 		else {
-			suggestedPath = suggestMovedPath(project);
+			suggestedPath = suggestMovedPath(project.root_path, others.map((r) => r.root_path));
 			category = suggestedPath ? "stale" : "dead";
 		}
+		const { reason, owner, action } = diagnose(project, pathExists, others);
 		return {
 			project,
 			category,
 			suggestedPath,
 			claudeNotesExists: orphaned.length > 0,
-			orphanedNotesDirs: orphaned
+			orphanedNotesDirs: orphaned,
+			reason,
+			owner,
+			action
 		};
 	});
 	const filtered = opts.status ? results.filter((r) => r.category === opts.status) : results;
@@ -1236,7 +1552,10 @@ function cmdHealth$1(db, opts) {
 			session_count: r.project.session_count,
 			suggested_path: r.suggestedPath ?? null,
 			claude_notes_exists: r.claudeNotesExists,
-			orphaned_notes_dirs: r.orphanedNotesDirs
+			orphaned_notes_dirs: r.orphanedNotesDirs,
+			reason: r.reason ?? null,
+			owner: r.owner ?? null,
+			action: r.action ?? null
 		})), null, 2));
 		return;
 	}
@@ -1281,29 +1600,184 @@ function cmdHealth$1(db, opts) {
 		console.log();
 	}
 	if (dead.length) {
-		console.log(err("  Dead projects (path missing, no match found):"));
+		console.log(err("  Unreachable projects (path missing):"));
 		for (const r of dead) {
-			console.log(`    ${bold$1(r.project.slug)}   ${dim$1(r.project.root_path)}`);
+			const label = r.reason && r.reason !== "dead" ? warn$1(`  [${r.reason}]`) : "";
+			console.log(`    ${bold$1(r.project.slug)}   ${dim$1(r.project.root_path)}${label}`);
 			if (r.claudeNotesExists) console.log(chalk.yellow(`      Notes:  ${r.orphanedNotesDirs.join(", ")}`));
-			if (r.project.session_count === 0 && opts.fix) {
+			if (r.project.session_count === 0 && opts.fix && r.reason === "dead") {
 				db.prepare("UPDATE projects SET status = 'archived', archived_at = ?, updated_at = ? WHERE id = ?").run(now(), now(), r.project.id);
-				console.log(ok$1("      Auto-fixed: archived (0 sessions, path gone)"));
-			} else console.log(dim$1(`      Fix:    pai project archive ${r.project.slug}  (or  pai project move ...)`));
+				console.log(ok$1("      Auto-fixed: archived (0 sessions, path gone, nothing claims it)"));
+			} else if (r.action) console.log(dim$1(`      Do:     ${r.action}`));
 		}
 		console.log();
 	}
-	console.log(dim$1(`  ${rows.length} total: ${active.length} active, ${stale.length} stale, ${dead.length} dead`));
+	const archivedButPresent = results.filter((r) => r.category === "active" && r.project.status !== "active").length;
+	console.log(dim$1(`  ${rows.length} total: ${active.length} with the path present, ${stale.length} stale, ${dead.length} dead`));
+	if (archivedButPresent > 0) console.log(dim$1(`  ${archivedButPresent} of those ${active.length} are archived in the registry — "present" here is about the directory, not the registry status.`));
 	if (!opts.fix && (stale.length > 0 || dead.length > 0)) {
 		console.log();
 		console.log(warn$1("  Run with --fix to auto-remediate where possible."));
 	}
 }
 
+//#endregion
+//#region src/registry/merge.ts
+var MergeError = class extends Error {};
+/**
+* What a merge would do, without doing it.
+*
+* Built as a plan first because the session renumbering is the part a reader will
+* not predict, and printing "0001 -> 0016" is the difference between a command
+* that can be trusted and one that has to be taken on faith.
+*/
+function planMerge(db, fromSlug, intoSlug) {
+	if (fromSlug === intoSlug) throw new MergeError(`Cannot merge ${fromSlug} into itself.`);
+	const from = db.prepare("SELECT id, slug FROM projects WHERE slug = ?").get(fromSlug);
+	const into = db.prepare("SELECT id, slug FROM projects WHERE slug = ?").get(intoSlug);
+	if (!from) throw new MergeError(`No project with slug "${fromSlug}".`);
+	if (!into) throw new MergeError(`No project with slug "${intoSlug}".`);
+	let next = db.prepare("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = ?").get(into.id).n;
+	const sessions = db.prepare("SELECT id, number FROM sessions WHERE project_id = ? ORDER BY number ASC").all(from.id).map((s) => ({
+		id: s.id,
+		from: s.number,
+		to: ++next
+	}));
+	const count = (sql, ...args) => db.prepare(sql).get(...args).n;
+	const aliasTaken = count("SELECT COUNT(*) AS n FROM aliases WHERE alias = ?", from.slug) > 0 || count("SELECT COUNT(*) AS n FROM projects WHERE slug = ?", from.slug) > 1;
+	return {
+		fromId: from.id,
+		fromSlug: from.slug,
+		intoId: into.id,
+		intoSlug: into.slug,
+		sessions,
+		tags: count("SELECT COUNT(*) AS n FROM project_tags WHERE project_id = ?", from.id),
+		aliases: count("SELECT COUNT(*) AS n FROM aliases WHERE project_id = ?", from.id),
+		compactions: count("SELECT COUNT(*) AS n FROM compaction_log WHERE project_id = ?", from.id),
+		links: count("SELECT COUNT(*) AS n FROM links WHERE target_project_id = ?", from.id),
+		aliasToAdd: aliasTaken ? void 0 : from.slug
+	};
+}
+/**
+* Apply a plan. One transaction: either the whole row is folded in or nothing is.
+*
+* A half-merged project is the worst outcome available here — sessions moved but
+* the row still present, or the row gone and its tags orphaned — and with foreign
+* keys off nothing would complain.
+*/
+function applyMerge(db, plan) {
+	db.transaction(() => {
+		const move = db.prepare("UPDATE sessions SET project_id = ?, number = ? WHERE id = ?");
+		for (const s of plan.sessions) move.run(plan.intoId, s.to, s.id);
+		db.prepare(`INSERT OR IGNORE INTO project_tags (project_id, tag_id)
+       SELECT ?, tag_id FROM project_tags WHERE project_id = ?`).run(plan.intoId, plan.fromId);
+		db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(plan.fromId);
+		db.prepare("UPDATE aliases SET project_id = ? WHERE project_id = ?").run(plan.intoId, plan.fromId);
+		db.prepare("UPDATE compaction_log SET project_id = ? WHERE project_id = ?").run(plan.intoId, plan.fromId);
+		db.prepare(`UPDATE OR IGNORE links SET target_project_id = ? WHERE target_project_id = ?`).run(plan.intoId, plan.fromId);
+		db.prepare("DELETE FROM links WHERE target_project_id = ?").run(plan.fromId);
+		db.prepare(`DELETE FROM links WHERE target_project_id = ?
+         AND session_id IN (SELECT id FROM sessions WHERE project_id = ?)`).run(plan.intoId, plan.intoId);
+		if (plan.aliasToAdd) db.prepare("INSERT OR IGNORE INTO aliases (alias, project_id) VALUES (?, ?)").run(plan.aliasToAdd, plan.intoId);
+		db.prepare("DELETE FROM projects WHERE id = ?").run(plan.fromId);
+	})();
+}
+
+//#endregion
+//#region src/cli/commands/project/merge.ts
+function cmdMerge(db, fromSlug, intoSlug, opts = {}) {
+	let plan;
+	try {
+		plan = planMerge(db, fromSlug, intoSlug);
+	} catch (e) {
+		if (e instanceof MergeError) {
+			console.error(err(`  ${e.message}`));
+			process.exit(1);
+		}
+		throw e;
+	}
+	const path = (id) => {
+		const row = db.prepare("SELECT root_path FROM projects WHERE id = ?").get(id);
+		return row ? shortenPath(row.root_path, 54) : "(unknown)";
+	};
+	console.log();
+	console.log(bold$1(`  Merge ${plan.fromSlug} into ${plan.intoSlug}`));
+	console.log();
+	console.log(dim$1(`    from  ${plan.fromSlug.padEnd(22)} ${path(plan.fromId)}`));
+	console.log(dim$1(`    into  ${plan.intoSlug.padEnd(22)} ${path(plan.intoId)}`));
+	console.log();
+	if (plan.sessions.length > 0) {
+		console.log(`    ${plan.sessions.length} session(s) move and are renumbered:`);
+		for (const s of plan.sessions) console.log(dim$1(`      ${String(s.from).padStart(4)}  ->  ${String(s.to).padStart(4)}`));
+	} else console.log(dim$1(`    No sessions to move.`));
+	const extras = [];
+	if (plan.tags) extras.push(`${plan.tags} tag(s)`);
+	if (plan.aliases) extras.push(`${plan.aliases} existing alias(es)`);
+	if (plan.compactions) extras.push(`${plan.compactions} compaction record(s)`);
+	if (plan.links) extras.push(`${plan.links} inbound link(s)`);
+	if (extras.length > 0) console.log(dim$1(`    Also repointed: ${extras.join(", ")}.`));
+	if (plan.aliasToAdd) console.log(dim$1(`    "${plan.aliasToAdd}" is kept as an alias, so the old name still resolves.`));
+	else console.log(warn$1(`    "${plan.fromSlug}" cannot be kept as an alias — the name is already taken.`));
+	console.log(dim$1(`    Then the ${plan.fromSlug} row is deleted.`));
+	console.log();
+	if (!opts.execute) {
+		console.log(dim$1("  Preview — nothing was changed. Re-run with --execute to merge."));
+		console.log();
+		return;
+	}
+	applyMerge(db, plan);
+	console.log(ok$1(`  Merged. ${plan.sessions.length} session(s) now belong to ${plan.intoSlug}.`));
+	console.log();
+}
+
+//#endregion
+//#region src/cli/commands/project/unregister.ts
+function cmdUnregister(db, slug, opts = {}) {
+	const row = db.prepare(`SELECT p.id, p.slug, p.root_path, p.status,
+              (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count
+       FROM projects p WHERE p.slug = ?`).get(slug);
+	if (!row) {
+		console.error(err(`  No project with slug "${slug}".`));
+		process.exit(1);
+	}
+	console.log();
+	console.log(bold$1(`  Unregister ${row.slug}`));
+	console.log(dim$1(`    ${row.root_path}`));
+	console.log(dim$1(`    status ${row.status}, ${row.session_count} session(s)`));
+	console.log();
+	if (row.session_count > 0 && !opts.force) {
+		console.log(warn$1(`  Refusing: ${row.session_count} session(s) would be stranded.`));
+		console.log(dim$1(`  Those sessions are the only thing of value on this row. Move them first:`));
+		console.log(dim$1(`      pai project merge ${row.slug} <into> --execute`));
+		console.log(dim$1(`  Or pass --force if the sessions are genuinely worthless.`));
+		console.log();
+		process.exit(1);
+	}
+	if (!opts.execute) {
+		console.log(dim$1("  Preview — nothing was changed. Re-run with --execute to unregister."));
+		if (row.session_count > 0) console.log(warn$1(`  --force is set: ${row.session_count} session(s) WILL be deleted.`));
+		console.log();
+		return;
+	}
+	db.transaction(() => {
+		db.prepare("DELETE FROM links WHERE target_project_id = ?").run(row.id);
+		db.prepare("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = ?)").run(row.id);
+		db.prepare("DELETE FROM compaction_log WHERE project_id = ?").run(row.id);
+		db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(row.id);
+		db.prepare("DELETE FROM aliases WHERE project_id = ?").run(row.id);
+		db.prepare("DELETE FROM sessions WHERE project_id = ?").run(row.id);
+		db.prepare("DELETE FROM projects WHERE id = ?").run(row.id);
+	})();
+	console.log(ok$1(`  Unregistered ${row.slug}.`));
+	console.log(dim$1(`  The directory itself was not touched.`));
+	console.log();
+}
+
 //#endregion
 //#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-BfSL8zio.mjs").then((n) => n.n);
+		const { cmdMain } = await import("./main-resolver-DjyUDJrv.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) => {
@@ -1351,6 +1825,12 @@ function registerProjectsCommands(projectsCmd, getDb) {
 	projectsCmd.command("archive <slug>").description("Archive a project").action((slug) => {
 		cmdArchive(getDb(), slug);
 	});
+	projectsCmd.command("merge <from> <into>").description("Fold a duplicate project into another: move its sessions (renumbered), repoint its tags, aliases, compaction records and links, keep the old slug as an alias, then delete the row. Preview unless --execute is given.").option("--execute", "Actually perform the merge").action((from, into, opts) => {
+		cmdMerge(getDb(), from, into, opts);
+	});
+	projectsCmd.command("unregister <slug>").description("Remove a project row entirely, for paths that should never have been registered (worktrees, temp dirs). Refuses when the row holds sessions — merge those first. Preview unless --execute is given. The directory itself is never touched.").option("--execute", "Actually remove the row").option("--force", "Remove even though sessions would be deleted with it").action((slug, opts) => {
+		cmdUnregister(getDb(), slug, opts);
+	});
 	projectsCmd.command("unarchive <slug>").description("Restore an archived project to active status").action((slug) => {
 		cmdUnarchive(getDb(), slug);
 	});
@@ -2684,6 +3164,65 @@ function registerMcpCommands(mcpCmd) {
 	});
 }
 
+//#endregion
+//#region src/cli/commands/daemon-status.ts
+/**
+* Health lines to print above the index/DB figures, worst first.
+*
+* Empty when there is nothing wrong: a healthy daemon should not grow a
+* paragraph of reassurance, or the one time it says something real gets read as
+* more of the same.
+*/
+function formatStorageHealth(s, now = Date.now()) {
+	const lines = [];
+	const outage = s.backendOutage ?? null;
+	if (outage) {
+		lines.push({
+			severity: "error",
+			text: `BACKEND DOWN: ${outage.backend} unreachable for ${humanDuration(now - outage.since)}`
+		});
+		lines.push({
+			severity: "warn",
+			text: `${outage.attempts} attempts — ${outage.lastError}`
+		});
+	}
+	const queue = queueLine(s.workQueue, outage !== null);
+	if (queue) lines.push(queue);
+	if (outage) lines.push({
+		severity: "info",
+		text: "Indexing, session notes and the work queue are stalled until it returns."
+	});
+	return lines;
+}
+/**
+* The queue depth, when it means something.
+*
+* During an outage it always means something — including a depth of zero, which
+* says the backlog is not the reason nothing is happening. Otherwise it is only
+* worth a line when work is actually sitting there: a queue that is empty
+* because everything drained is the normal case, and printing it every time
+* teaches the reader to skip the line.
+*
+* `failed` is reported whenever it is non-zero, outage or not. Items that
+* exhausted their retries are the silent-loss case this whole status block
+* exists for — they will never be retried and nothing else surfaces them.
+*/
+function queueLine(q, duringOutage) {
+	if (!q) return null;
+	const pending = q.pending ?? 0;
+	const processing = q.processing ?? 0;
+	const failed = q.failed ?? 0;
+	const waiting = pending + processing;
+	if (!duringOutage && waiting === 0 && failed === 0) return null;
+	const parts = [`${pending} pending`];
+	if (processing > 0) parts.push(`${processing} processing`);
+	if (failed > 0) parts.push(`${failed} failed`);
+	return {
+		severity: failed > 0 ? "error" : duringOutage || waiting > 0 ? "warn" : "info",
+		text: `Work queue:  ${parts.join(", ")}`
+	};
+}
+
 //#endregion
 //#region src/cli/commands/daemon.ts
 const HOME$2 = homedir();
@@ -2755,14 +3294,13 @@ async function cmdStatus$2() {
 		console.log(ok$1(`  Daemon running`));
 		console.log(dim$1(`    Uptime:      ${s["uptime"]}s`));
 		console.log(dim$1(`    Socket:      ${s["socketPath"]}`));
-		const outage = s["backendOutage"];
-		if (outage) {
-			const mins = Math.max(1, Math.round((Date.now() - outage.since) / 6e4));
-			const forHow = mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;
+		const health = formatStorageHealth(s);
+		if (health.length > 0) {
 			console.log();
-			console.log(err(`    BACKEND DOWN: ${outage.backend} unreachable for ${forHow}`));
-			console.log(warn$1(`    ${outage.attempts} attempts — ${outage.lastError}`));
-			console.log(dim$1(`    Indexing, session notes and the work queue are stalled until it returns.`));
+			for (const line of health) {
+				const paint = line.severity === "error" ? err : line.severity === "warn" ? warn$1 : dim$1;
+				console.log(paint(`    ${line.text}`));
+			}
 			console.log();
 		}
 		console.log(dim$1(`    Index:       ${s["indexInProgress"] ? "in progress" : "idle"}  (interval: ${s["indexIntervalSecs"]}s)`));
@@ -2946,7 +3484,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("./daemon-mFGnPd8q.mjs").then((n) => n.t);
+		const { serve } = await import("./daemon-iNuNMMKd.mjs").then((n) => n.t);
 		const { loadConfig: lc, ensureConfigDir } = await import("./config-CcdkNSWa.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());
@@ -7983,6 +8521,33 @@ function restoreDueString(recurrence, prevDue) {
 	return `${recurrence}${hasTime && !ruleCarriesTime ? ` at ${prevDue.slice(11, 16)}` : ""} starting ${date}`;
 }
 /**
+* When a restored slot actually falls due — the inverse of `restoreDueString`.
+*
+* Callers need this to decide whether putting the slot back is still useful.
+* Restoring one that has already passed writes a task that is overdue the
+* instant it lands, and the next tick dispatches it, which advances the date,
+* which restores it again: an unbounded loop that fires every tick for the rest
+* of the day. That is not hypothetical — it happened on 2026-08-04 with "every
+* day at 9am", which re-dispatched roughly every 30 minutes (two 900s ticks)
+* because the guard compared against the end of the day rather than 09:00.
+*
+* Both shapes `restoreDueString` can emit put the time after "at", so one match
+* covers "every day at 9am starting …" and "every week at 08:00 starting …".
+* A rule carrying no time at all is a genuine date-only occurrence, and for
+* those the slot really does run until the end of the day.
+*/
+function triggeredSlotMs(keep, date) {
+	const at = /\bat\s+(\d{1,2})(?::(\d{2}))?\s*([ap]m)?/i.exec(keep);
+	if (!at) return (/* @__PURE__ */ new Date(`${date}T23:59:59`)).getTime();
+	let hour = Number(at[1]);
+	const suffix = at[3]?.toLowerCase();
+	if (suffix === "pm" && hour < 12) hour += 12;
+	if (suffix === "am" && hour === 12) hour = 0;
+	const hh = String(hour).padStart(2, "0");
+	const mm = String(Number(at[2] ?? 0)).padStart(2, "0");
+	return (/* @__PURE__ */ new Date(`${date}T${hh}:${mm}:00`)).getTime();
+}
+/**
 * Expected runtime for a task.
 *
 * The mean rather than the max, deliberately: with a liveness probe available,
@@ -8577,7 +9142,7 @@ async function keepTriggeredSchedule(task, opts, state, now) {
 	delete state.triggeredRestore[task.id];
 	const date = /starting (\d{4}-\d{2}-\d{2})/.exec(keep)?.[1];
 	if (!date || !opts.provider.setDue) return "";
-	if ((/* @__PURE__ */ new Date(`${date}T23:59:59`)).getTime() <= now) return ", triggered-run slot already past — schedule left as it is";
+	if (triggeredSlotMs(keep, date) <= now) return ", triggered-run slot already past — schedule left as it is";
 	try {
 		await opts.provider.setDue(task.id, keep);
 		state.lastSeenDue[task.id] = date;
@@ -10683,7 +11248,7 @@ function cmdActive(db, opts) {
 async function cmdAutoRoute(opts) {
 	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("./auto-route-BWGvvpcP.mjs");
 	const { openRegistry } = await import("./db-BtuN768f.mjs").then((n) => n.t);
-	const { createStorageBackend } = await import("./factory-BqAdO21B.mjs").then((n) => n.n);
+	const { createStorageBackend } = await import("./factory-BydJSrZJ.mjs").then((n) => n.n);
 	const { loadConfig } = await import("./config-CcdkNSWa.mjs").then((n) => n.r);
 	const config = loadConfig();
 	const registryDb = openRegistry();
@@ -11453,43 +12018,6 @@ async function cmdRecent(db, opts) {
 
 //#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,
@@ -11553,7 +12081,7 @@ function cmdGoto(db, query, opts) {
 		return;
 	}
 	if (resumableUuid) {
-		const probe = probeResume$1(resumableUuid, projectDir);
+		const probe = probeResume(resumableUuid, projectDir);
 		if (probe.ok) {
 			const result = spawnSync("claude", [
 				"--resume",
@@ -11609,12 +12137,229 @@ function cmdGoto(db, query, opts) {
 	}
 }
 
+//#endregion
+//#region src/cli/commands/session/restore.ts
+/**
+* pai session restore — put displaced transcripts back where resume looks.
+*
+* PAI moved session transcripts out of `~/.claude/projects/<dir>/` into
+* `<dir>/sessions/`, and `claude --resume <uuid>` reads only the former. The
+* archiver no longer does that (it hardlinks), but the sessions already moved
+* stayed moved — and every checkpoint PAI ever wrote ends with
+* "Resume with: claude --resume <uuid>". For a displaced session that line is an
+* instruction that cannot work, and nothing says so.
+*
+* One project measured 1 transcript at the project root against 52 underneath.
+*
+* So this is a repair, and it is deliberately a COMMAND rather than another hook.
+* Silently relinking dozens of a user's files during an unrelated session start is
+* the same class of mistake as silently moving them was. Dry run is the default;
+* `--execute` is the only thing that touches disk.
+*
+* The link logic itself is imported, not rewritten. Today's other bug was a fix
+* that landed in one of three copies of `probeResume`, so `restoreTopLevel` stays
+* the single implementation.
+*/
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Transcripts that exist under `sessions/` with no twin at the project root.
+*
+* A twin means nothing needs doing: the archiver hardlinks now, so the normal
+* state is both names pointing at one inode. Only the ones missing upstairs were
+* displaced by the old rename.
+*/
+function findDisplaced(projectsDir = claudeProjectsDir()) {
+	const out = [];
+	let encodedDirs;
+	try {
+		encodedDirs = readdirSync(projectsDir);
+	} catch {
+		return out;
+	}
+	for (const encodedDir of encodedDirs) {
+		const projectDir = join(projectsDir, encodedDir);
+		const sessionsDir = join(projectDir, "sessions");
+		if (!existsSync(sessionsDir)) continue;
+		let files;
+		try {
+			files = readdirSync(sessionsDir);
+		} catch {
+			continue;
+		}
+		for (const file of files) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			if (existsSync(join(projectDir, file))) continue;
+			let bytes = 0;
+			let mtime = 0;
+			try {
+				const st = statSync(join(sessionsDir, file));
+				bytes = st.size;
+				mtime = st.mtimeMs;
+			} catch {
+				continue;
+			}
+			out.push({
+				uuid,
+				projectDir,
+				encodedDir,
+				cwd: smartDecodeDir(encodedDir),
+				bytes,
+				mtime,
+				promisedBy: [],
+				hasConversation: hasConversation(join(sessionsDir, file))
+			});
+		}
+	}
+	return out.sort((a, b) => b.bytes - a.bytes);
+}
+/**
+* Notes that instruct the user to resume this id.
+*
+* Bounded on purpose — the project's own TODO.md and note files, never a search
+* from the home directory. The point is to name the specific promise each
+* restore makes true, so a count of files is not enough.
+*/
+function findResumePromises(uuid, cwd) {
+	if (!cwd) return [];
+	const candidates = [];
+	for (const notesDir of [
+		cwd,
+		join(cwd, "Notes"),
+		join(cwd, "notes")
+	]) try {
+		for (const entry of readdirSync(notesDir)) if (entry.endsWith(".md")) candidates.push(join(notesDir, entry));
+	} catch {}
+	const seen = /* @__PURE__ */ new Set();
+	const hits = [];
+	for (const file of candidates) {
+		let key;
+		try {
+			const st = statSync(file);
+			key = `${st.dev}:${st.ino}`;
+		} catch {
+			key = file.toLowerCase();
+		}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		try {
+			if (readFileSync(file, "utf8").includes(uuid)) hits.push(file);
+		} catch {}
+	}
+	return hits;
+}
+function human(bytes) {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+	if (bytes >= 1024) return `${Math.round(bytes / 1024)} KB`;
+	return `${bytes} B`;
+}
+/** How many to list before the report stops being readable. */
+const LIST_LIMIT = 20;
+/**
+* Which of the displaced sessions a run is about, and which of those to link.
+*
+* Pure, and separate from the printing, for two reasons. The obvious one is that
+* it can be tested without pointing a test at the developer's real
+* `~/.claude/projects` — an earlier draft of the test did exactly that and would
+* have relinked live files. The other is that the report and the action must
+* agree: `--json` originally restored everything in scope while the formatted
+* path skipped stubs, so the two modes did different things with the same flags.
+*/
+function selectTargets(everything, opts) {
+	const inScope = everything.filter((d) => {
+		if (opts.promised && d.promisedBy.length === 0) return false;
+		if (opts.cwd && d.cwd !== opts.cwd) return false;
+		return true;
+	});
+	return {
+		inScope,
+		toRestore: opts.includeStubs ? inScope : inScope.filter((d) => d.hasConversation)
+	};
+}
+function cmdRestore(opts = {}) {
+	const everything = findDisplaced();
+	for (const d of everything) d.promisedBy = findResumePromises(d.uuid, d.cwd);
+	const { inScope: displaced, toRestore } = selectTargets(everything, opts);
+	if (opts.json) {
+		console.log(JSON.stringify({
+			displaced,
+			wouldRestore: toRestore.map((d) => d.uuid),
+			executed: Boolean(opts.execute)
+		}, null, 2));
+		if (opts.execute) for (const d of toRestore) restoreTopLevel(d.uuid, d.projectDir);
+		return;
+	}
+	console.log();
+	console.log(bold$1("  Displaced session transcripts"));
+	console.log();
+	if (displaced.length === 0) {
+		if (everything.length > 0) {
+			console.log(ok$1(`  Nothing displaced in this scope.`));
+			console.log(dim$1(`  ${everything.length} displaced elsewhere — drop the filters to see them.`));
+		} else {
+			console.log(ok$1("  Nothing displaced — every archived transcript has its twin at the"));
+			console.log(dim$1("  project root, which is where claude --resume looks."));
+		}
+		console.log();
+		return;
+	}
+	const promised = displaced.filter((d) => d.promisedBy.length > 0);
+	const totalBytes = displaced.reduce((n, d) => n + d.bytes, 0);
+	console.log(warn$1(`  ${displaced.length} transcript(s), ${human(totalBytes)}, currently unresumable.`));
+	if (displaced.length !== everything.length) console.log(dim$1(`  (filtered from ${everything.length} machine-wide)`));
+	if (promised.length > 0) console.log(err(`  ${promised.length} named in a checkpoint that tells you to resume them — those lines are lies today.`));
+	const stubs = displaced.filter((d) => !d.hasConversation);
+	if (stubs.length > 0) console.log(dim$1(`  ${stubs.length} of them hold no conversation at all — restoring those changes nothing.`));
+	console.log();
+	const ordered = [...promised, ...displaced.filter((d) => d.promisedBy.length === 0)];
+	const shown = opts.all ? ordered : ordered.slice(0, LIST_LIMIT);
+	for (const d of shown) {
+		const where = d.cwd ?? dim$1(`(undecodable: ${d.encodedDir})`);
+		const stub = d.hasConversation ? "" : warn$1("  [stub — no conversation]");
+		console.log(`  ${bold$1(d.uuid.slice(0, 8))}  ${human(d.bytes).padStart(8)}  ${where}${stub}`);
+		for (const file of d.promisedBy) console.log(d.hasConversation ? err(`      promised by  ${file}`) : dim$1(`      promised by  ${file}  (promise cannot be kept: empty transcript)`));
+	}
+	if (shown.length < ordered.length) {
+		console.log();
+		console.log(dim$1(`  … and ${ordered.length - shown.length} more. --all lists every one.`));
+	}
+	console.log();
+	if (!opts.execute) {
+		console.log(dim$1("  Dry run — nothing was touched."));
+		console.log(dim$1("  Restore hardlinks each transcript back to the project root: same inode,"));
+		console.log(dim$1("  no copy, and the sessions/ archive is left exactly where it is."));
+		console.log();
+		console.log(dim$1("    --promised --execute   just the ones a checkpoint promises (start here)"));
+		console.log(dim$1("    --cwd <path> --execute one project"));
+		console.log(dim$1("    --execute              everything in scope"));
+		console.log();
+		return;
+	}
+	const target = toRestore;
+	const skipped = displaced.length - target.length;
+	let restored = 0;
+	const failed = [];
+	for (const d of target) if (restoreTopLevel(d.uuid, d.projectDir)) restored++;
+	else failed.push(d.uuid);
+	console.log(ok$1(`  Restored ${restored} of ${target.length} recoverable.`));
+	if (skipped > 0) console.log(dim$1(`  Skipped ${skipped} stub(s) — nothing in them to resume. --include-stubs overrides.`));
+	if (failed.length > 0) {
+		console.log(warn$1(`  Could not restore ${failed.length}:`));
+		for (const uuid of failed) console.log(dim$1(`    ${uuid}`));
+	}
+	console.log();
+}
+
 //#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("restore").description("Restore transcripts PAI displaced into sessions/ so claude --resume can find them again. Reports what is unresumable, which checkpoints promise it, and which transcripts are empty. Dry run unless --execute is given.").option("--execute", "Actually restore (hardlink back to the project root)").option("--promised", "Only sessions a checkpoint tells you to resume").option("--cwd <path>", "Only sessions belonging to this working directory").option("--all", "List every displaced session, not just the largest few").option("--include-stubs", "Also restore transcripts that hold no conversation").option("--json", "Output raw JSON instead of a formatted report").action((opts) => {
+		cmdRestore(opts);
+	});
 	sessionCmd.command("info <project-slug> <number>").description("Show full details for a specific session").action((projectSlug, number) => {
 		cmdInfo(getDb(), projectSlug, number);
 	});
@@ -12804,181 +13549,6 @@ async function cmdFind(query, opts) {
 	console.log();
 }
 
-//#endregion
-//#region src/cli/lib/launch.ts
-/**
-* launch.ts — Launch Claude Code in a directory, in the CURRENT terminal.
-*
-* Shared by the interactive picker (pick.ts). Deliberately does NOT switch
-* iTerm tabs (aibroker_switch): switching jumps the user to a different — and
-* sometimes wrong — terminal, which is confusing. Picking a place should start
-* a session right here, in the chosen directory.
-*
-* Behaviour:
-*   resume-or-fresh  → if a resumable UUID is given, probe it; on success
-*                      `claude --resume`, otherwise fall back to a fresh session
-*                      in the same dir. With no UUID, start fresh.
-*
-* The `claude` child inherits the tty (stdio: "inherit"), so the session runs
-* in the terminal that launched `pai`. On exit we print the working directory.
-*/
-/**
-* Does a transcript for this session exist on disk?
-*
-* Returns true/false when it can tell, and null when it cannot — the caller
-* must treat null as "ask something else", never as "no". A path this function
-* fails to recognise would otherwise silently veto a perfectly good resume.
-*
-* Claude Code stores transcripts at ~/.claude/projects/<encoded-cwd>/, where the
-* encoding replaces every non-alphanumeric character with `-`. Finished sessions
-* are moved into a `sessions/` subdirectory by the stop hook, so both are checked.
-*/
-function transcriptOnDisk(uuid, cwd) {
-	try {
-		const encoded = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-		const dir = join(homedir(), ".claude", "projects", encoded);
-		if (!existsSync(dir)) return null;
-		return existsSync(join(dir, `${uuid}.jsonl`)) || existsSync(join(dir, "sessions", `${uuid}.jsonl`));
-	} catch {
-		return null;
-	}
-}
-/**
-* Probe whether a session UUID is resumable from `cwd`.
-*
-* The filesystem is asked first, and usually answers.
-*
-* This used to run `claude --resume <uuid> --print --output-format=json "_"`
-* with a 5s timeout, which is not a probe: it resumes the session AND sends a
-* prompt to the model, then waits for a complete JSON reply. That costs a model
-* round-trip per probe, and 5s is not enough time for one — for a LARGE session
-* least of all, because the transcript has to be loaded first.
-*
-* So the check failed precisely for the sessions most worth resuming, and the
-* caller's fallback quietly started a fresh session in their place. Observed
-* 2026-08-04: `pai Paperfull` reported `spawn error: spawnSync claude ETIMEDOUT`
-* for fb76a6c3 and started over, while
-* `~/.claude/projects/…-Paperfull/sessions/fb76a6c3-….jsonl` sat on disk the
-* whole time.
-*
-* A transcript on disk is what resumable MEANS, and reading a directory entry is
-* free. The spawn remains only for the case the filesystem cannot answer, and
-* now gets a timeout that a real answer can fit inside.
-*/
-function probeResume(uuid, cwd) {
-	const onDisk = transcriptOnDisk(uuid, cwd);
-	if (onDisk === true) return { ok: true };
-	if (onDisk === false) return {
-		ok: false,
-		reason: "No transcript on disk for this UUID"
-	};
-	const result = spawnSync("claude", [
-		"--resume",
-		uuid,
-		"--print",
-		"--output-format=json",
-		"_"
-	], {
-		cwd,
-		timeout: 3e4,
-		env: process.env,
-		stdio: [
-			"ignore",
-			"ignore",
-			"pipe"
-		]
-	});
-	if (result.error) return {
-		ok: false,
-		reason: `spawn error: ${result.error.message}`
-	};
-	const stderr = result.stderr?.toString("utf8") ?? "";
-	if (stderr.toLowerCase().includes("no conversation found") || stderr.toLowerCase().includes("session not found")) return {
-		ok: false,
-		reason: "No conversation found for this UUID"
-	};
-	if (result.status !== 0) return {
-		ok: false,
-		reason: `claude exited ${result.status ?? "signal"}${stderr ? `: ${stderr.slice(0, 120).trim()}` : ""}`
-	};
-	return { ok: true };
-}
-/**
-* Launch `claude` in `dir` in the current terminal. `name` is used for both the
-* Claude session label (--name) and the /Name slash command (tab/statusline).
-* Never returns on the live path — it exits the process after claude exits.
-*/
-function launchInDir(dir, name, opts = {}) {
-	let cwd;
-	try {
-		cwd = realpathSync(dir);
-	} catch {
-		console.error(err(`Directory does not exist or cannot be resolved:\n  ${dir}\n  The folder may have moved or been deleted.`));
-		process.exit(1);
-		return;
-	}
-	const promptArg = `/Name ${name}\ngo`;
-	const wantResume = !opts.forceFresh && !!opts.resumableUuid;
-	if (opts.dryRun) {
-		if (wantResume) {
-			console.log("\n" + chalk.bold("Dry run — would probe then exec (RESUME path):") + "\n");
-			console.log(`  cwd:      ${chalk.cyan(cwd)}`);
-			console.log(`  probe:    claude --resume ${opts.resumableUuid} --print --output-format=json "_"`);
-			console.log(`  argv:     claude --resume ${opts.resumableUuid} --name "${name}" "/Name ${name}\\ngo"`);
-			console.log(`  fallback: claude --name "${name}" "/Name ${name}\\ngo"`);
-		} else {
-			console.log("\n" + chalk.bold("Dry run — would exec (FRESH path):") + "\n");
-			console.log(`  cwd:  ${chalk.cyan(cwd)}`);
-			console.log(`  argv: claude --name "${name}" "/Name ${name}\\ngo"`);
-		}
-		console.log();
-		return;
-	}
-	const fresh = () => {
-		const result = spawnSync("claude", [
-			"--name",
-			name,
-			promptArg
-		], {
-			cwd,
-			stdio: "inherit",
-			env: process.env
-		});
-		if (result.error) {
-			console.error(err(`Failed to launch claude: ${result.error.message}`));
-			process.exit(1);
-		}
-		printExitDir(cwd);
-		process.exit(result.status ?? 0);
-	};
-	if (wantResume) {
-		const probe = probeResume(opts.resumableUuid, cwd);
-		if (probe.ok) {
-			const result = spawnSync("claude", [
-				"--resume",
-				opts.resumableUuid,
-				"--name",
-				name,
-				promptArg
-			], {
-				cwd,
-				stdio: "inherit",
-				env: process.env
-			});
-			if (result.error) {
-				console.error(err(`Failed to launch claude: ${result.error.message}`));
-				process.exit(1);
-			}
-			printExitDir(cwd);
-			process.exit(result.status ?? 0);
-		}
-		process.stderr.write(chalk.yellow(`\n  Resume failed for ${opts.resumableUuid.slice(0, 8)}: ${probe.reason ?? "unknown error"}\n  Starting fresh session in same directory.\n\n`));
-		fresh();
-		return;
-	}
-	fresh();
-}
-
 //#endregion
 //#region src/cli/commands/pick.ts
 function getProjects(db, includeArchived) {
@@ -13491,4 +14061,4 @@ async function cmdPick(db, opts = {}) {
 
 //#endregion
 export { registerProjectsCommands as A, registerRestoreCommands as C, registerIdentityCommands as D, registerMcpCommands as E, resolveIdentifier as M, registerMemoryCommands 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, findMovedPath as j, registerRegistryCommands 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-BcmBBfOF.mjs.map
+//# sourceMappingURL=pick-DlsM0ppq.mjs.map