@tekmidian/pai 0.31.0 → 0.32.0

package/dist/cli/index.mjs

@@ -7,7 +7,7 @@ import "../helpers-crDEr6S2.mjs";
 import "../sync--BoxBBok.mjs";
 import "../embeddings-Bn86ssxR.mjs";
 import "../search-CpTv1I24.mjs";
-import "../pick-Bmz718uo.mjs";
+import "../pick-DlsM0ppq.mjs";
 import "../checkpoint-block-DYq9RmMU.mjs";
 import "../indexer-AEcT8wHf.mjs";
 import "../ipc-client-aVKVERjJ.mjs";

package/dist/cli/program.mjs

@@ -6,7 +6,7 @@ import "../helpers-crDEr6S2.mjs";
 import "../sync--BoxBBok.mjs";
 import "../embeddings-Bn86ssxR.mjs";
 import "../search-CpTv1I24.mjs";
-import { A as registerProjectsCommands, C as registerRestoreCommands, D as registerIdentityCommands, E as registerMcpCommands, M as resolveIdentifier, O as registerMemoryCommands, S as registerSetupCommand, T as registerDaemonCommands, _ as registerUpdateCommand, a as cmdEnd, b as registerZettelCommands, c as cmdGoto, d as registerHelpCommand, f as registerDbCommands, g as registerNotifyCommands, h as registerTaskCommands, i as cmdPauseAll, j as findMovedPath, k as registerRegistryCommands, l as cmdPause, m as registerTopicCommands, n as cmdFind, o as registerSessionCleanupCommand, p as registerKgCommands, r as cmdClearNames, s as registerSessionCommands, t as cmdPick, u as cmdList, v as registerSkillCommands, w as registerBackupCommands, x as registerObsidianCommands, y as registerObservationCommands } from "../pick-Bmz718uo.mjs";
+import { A as registerProjectsCommands, C as registerRestoreCommands, D as registerIdentityCommands, E as registerMcpCommands, M as resolveIdentifier, O as registerMemoryCommands, S as registerSetupCommand, T as registerDaemonCommands, _ as registerUpdateCommand, a as cmdEnd, b as registerZettelCommands, c as cmdGoto, d as registerHelpCommand, f as registerDbCommands, g as registerNotifyCommands, h as registerTaskCommands, i as cmdPauseAll, j as findMovedPath, k as registerRegistryCommands, l as cmdPause, m as registerTopicCommands, n as cmdFind, o as registerSessionCleanupCommand, p as registerKgCommands, r as cmdClearNames, s as registerSessionCommands, t as cmdPick, u as cmdList, v as registerSkillCommands, w as registerBackupCommands, x as registerObsidianCommands, y as registerObservationCommands } from "../pick-DlsM0ppq.mjs";
 import "../checkpoint-block-DYq9RmMU.mjs";
 import "../indexer-AEcT8wHf.mjs";
 import "../ipc-client-aVKVERjJ.mjs";

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

@@ -16,7 +16,7 @@ import { s as kgQuery } from "./kg-entity-r8duqhi9.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,24 +1600,179 @@ 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) {
@@ -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);
 	});
@@ -13581,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-Bmz718uo.mjs.map
+//# sourceMappingURL=pick-DlsM0ppq.mjs.map