@tekmidian/pai 0.66.0 → 0.66.2

package/dist/factory-Ypf8r0fK.mjs

@@ -0,0 +1,2892 @@
+import { a as parseSessionTitleChunk, c as yieldToEventLoop, f as fileContentHash, h as sha256File, i as isPathTooBroadForContentScan, n as chunkId, o as walkContentFiles, r as detectTier, s as walkMdFiles, t as INDEX_YIELD_EVERY, u as chunkMarkdown } from "./helpers-CZsi_49C.mjs";
+import { t as STOP_WORDS } from "./stop-words-DtxaTWU_.mjs";
+import { n as buildFtsQuery, r as isQuerySyntaxError } from "./search-CNAGTiJP.mjs";
+import { i as entityContentId, t as PostgresBackend } from "./postgres-D3xc2RB4.mjs";
+import { n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-DOLZnT1X.mjs";
+import { t as routeNotification } from "./router-BaTbc9VX.mjs";
+import { s as loadConfig } from "./config-C-LiGlop.mjs";
+import { a as paiHomePath, o as resolvePaiFile } from "./pai-home-Cm9rcJgX.mjs";
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import pg from "pg";
+import BetterSqlite3 from "better-sqlite3";
+
+//#region src/storage/outage.ts
+let current = null;
+/** Record that the backend is currently unreachable. */
+function setBackendOutage(outage) {
+	current = outage;
+}
+/**
+* Record that the backend answered.
+*
+* Called on every successful connection, including the first — so a daemon that
+* never had a problem reports none, and one that recovered stops reporting an
+* outage that has ended.
+*/
+function clearBackendOutage() {
+	current = null;
+}
+/** The current outage, or null when the backend is answering. */
+function getBackendOutage() {
+	return current;
+}
+/**
+* Human-readable elapsed time, for a status line rather than a log.
+*
+* Exported because the status command needs the duration on its own, to colour
+* it separately from the rest of the sentence. Without this it kept a second
+* copy of the same rounding, which is how two renderings of one outage drift.
+*/
+function humanDuration(ms) {
+	const mins = Math.max(1, Math.round(ms / 6e4));
+	return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;
+}
+
+//#endregion
+//#region src/storage/sqlite/federation-schema.ts
+const FEDERATION_SCHEMA_SQL = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS memory_files (
+  project_id   INTEGER NOT NULL,
+  path         TEXT    NOT NULL,
+  source       TEXT    NOT NULL DEFAULT 'memory',
+  tier         TEXT    NOT NULL DEFAULT 'topic',
+  hash         TEXT    NOT NULL,
+  mtime        INTEGER NOT NULL,
+  size         INTEGER NOT NULL,
+  PRIMARY KEY (project_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS memory_chunks (
+  id               TEXT    PRIMARY KEY,
+  project_id       INTEGER NOT NULL,
+  source           TEXT    NOT NULL DEFAULT 'memory',
+  tier             TEXT    NOT NULL DEFAULT 'topic',
+  path             TEXT    NOT NULL,
+  start_line       INTEGER NOT NULL,
+  end_line         INTEGER NOT NULL,
+  hash             TEXT    NOT NULL,
+  text             TEXT    NOT NULL,
+  updated_at       INTEGER NOT NULL,
+  last_accessed_at INTEGER,
+  relevance_score  REAL    DEFAULT 0.5,
+  embedding        BLOB
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+  text,
+  id UNINDEXED,
+  project_id UNINDEXED,
+  path UNINDEXED,
+  source UNINDEXED,
+  tier UNINDEXED,
+  start_line UNINDEXED,
+  end_line UNINDEXED
+);
+
+CREATE INDEX IF NOT EXISTS idx_mc_project ON memory_chunks(project_id);
+CREATE INDEX IF NOT EXISTS idx_mc_source  ON memory_chunks(project_id, source);
+CREATE INDEX IF NOT EXISTS idx_mc_tier    ON memory_chunks(tier);
+CREATE INDEX IF NOT EXISTS idx_mf_project ON memory_files(project_id);
+
+CREATE TABLE IF NOT EXISTS kg_entities (
+  entity_id       TEXT    PRIMARY KEY,
+  tenant_id       TEXT    NOT NULL DEFAULT 'default',
+  name            TEXT    NOT NULL,
+  type            TEXT    NOT NULL DEFAULT 'unknown',
+  description     TEXT,
+  first_seen      INTEGER,
+  last_seen       INTEGER,
+  mention_count   INTEGER NOT NULL DEFAULT 1,
+  feedback_weight REAL    NOT NULL DEFAULT 0.5,
+  UNIQUE(tenant_id, entity_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_kge_tenant    ON kg_entities(tenant_id);
+CREATE INDEX IF NOT EXISTS idx_kge_name      ON kg_entities(tenant_id, name);
+CREATE INDEX IF NOT EXISTS idx_kge_type      ON kg_entities(tenant_id, type);
+`;
+/**
+* Apply the full federation schema to an open database.
+*
+* Idempotent — all statements use IF NOT EXISTS so calling this on an
+* already-initialised database is safe.
+*
+* Also runs any necessary migrations for existing databases (e.g. adding the
+* embedding column to an older schema that was created without it).
+*/
+function initializeFederationSchema(db) {
+	db.exec(FEDERATION_SCHEMA_SQL);
+	runMigrations$1(db);
+}
+/**
+* Apply incremental migrations to an existing database.
+*
+* Each migration is idempotent — safe to call on a database that has already
+* been migrated.
+*/
+function runMigrations$1(db) {
+	const columns = db.prepare("PRAGMA table_info(memory_chunks)").all();
+	if (!columns.some((c) => c.name === "embedding")) db.exec("ALTER TABLE memory_chunks ADD COLUMN embedding BLOB");
+	db.exec("CREATE INDEX IF NOT EXISTS idx_mc_embedding ON memory_chunks(id) WHERE embedding IS NOT NULL");
+	if (!columns.some((c) => c.name === "last_accessed_at")) db.exec("ALTER TABLE memory_chunks ADD COLUMN last_accessed_at INTEGER");
+	if (!columns.some((c) => c.name === "relevance_score")) db.exec("ALTER TABLE memory_chunks ADD COLUMN relevance_score REAL DEFAULT 0.5");
+}
+
+//#endregion
+//#region src/storage/sqlite/federation-db.ts
+/**
+* Database connection helper for the PAI federation DB.
+*
+* Uses better-sqlite3 (synchronous API) to open or create federation.db.
+* On first open it runs the full DDL via initializeFederationSchema().
+*/
+/** Old federation.db path, inside the ~/.pai/ directory (pre-2026-09-19). */
+function oldFederationPath() {
+	return join(homedir(), ".pai", "federation.db");
+}
+/** Federation DB path: PAI_HOME/federation.db if present, else the old
+*  ~/.pai/federation.db (one-time stderr notice), else the new path. */
+function federationDbPath() {
+	return resolvePaiFile(paiHomePath("federation.db"), [oldFederationPath()], "pai config migrate --federation");
+}
+/**
+* Open (or create) the PAI federation database.
+*
+* @param path  Absolute path to federation.db.  Defaults to PAI_HOME/federation.db
+*              (falling back to the pre-2026-09-19 ~/.pai/federation.db).
+* @returns     An open better-sqlite3 Database instance.
+*
+* Side effects on first call:
+*  - Creates the parent directory if it does not exist.
+*  - Enables WAL journal mode.
+*  - Runs initializeFederationSchema() to ensure tables exist.
+*/
+function openFederation(path = federationDbPath()) {
+	mkdirSync(dirname(path), { recursive: true });
+	const db = new BetterSqlite3(path);
+	db.pragma("journal_mode = WAL");
+	db.pragma("foreign_keys = ON");
+	initializeFederationSchema(db);
+	return db;
+}
+
+//#endregion
+//#region src/storage/sqlite/indexer.ts
+/**
+* Synchronous (SQLite) indexer — moved from memory/indexer/sync.ts so the
+* only file that opens prepared statements against the federation database
+* lives under src/storage/ (design doc docs/design/postgres-only.md, unit 7).
+*
+* Scans project memory/ and Notes/ directories, chunks markdown files, and
+* inserts the resulting chunks into the federation memory store for BM25
+* search. Uses raw better-sqlite3 Database directly for maximum SQLite
+* performance (synchronous transactions, no serialisation overhead) — the
+* reason SQLiteBackend keeps this path instead of routing through the
+* generic (StorageBackend) indexer that Postgres uses.
+*/
+/**
+* Index a single file into the federation database.
+*
+* @returns true if the file was re-indexed (changed or new), false if skipped.
+*/
+function indexFile(db, projectId, rootPath, relativePath, source, tier) {
+	const absPath = join(rootPath, relativePath);
+	let content;
+	let stat;
+	try {
+		content = readFileSync(absPath, "utf8");
+		stat = statSync(absPath);
+	} catch {
+		return false;
+	}
+	const hash = fileContentHash(content);
+	const mtime = Math.floor(stat.mtimeMs);
+	const size = stat.size;
+	if (db.prepare("SELECT hash FROM memory_files WHERE project_id = ? AND path = ?").get(projectId, relativePath)?.hash === hash) return false;
+	const oldChunkIds = db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, relativePath);
+	const deleteFts = db.prepare("DELETE FROM memory_fts WHERE id = ?");
+	const deleteChunk = db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
+	db.transaction(() => {
+		for (const row of oldChunkIds) deleteFts.run(row.id);
+		deleteChunk.run(projectId, relativePath);
+	})();
+	const chunks = chunkMarkdown(content);
+	const insertChunk = db.prepare(`
+    INSERT INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+	const insertFts = db.prepare(`
+    INSERT INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+	const upsertFile = db.prepare(`
+    INSERT INTO memory_files (project_id, path, source, tier, hash, mtime, size)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(project_id, path) DO UPDATE SET
+      source = excluded.source,
+      tier   = excluded.tier,
+      hash   = excluded.hash,
+      mtime  = excluded.mtime,
+      size   = excluded.size
+  `);
+	const updatedAt = Date.now();
+	db.transaction(() => {
+		for (let i = 0; i < chunks.length; i++) {
+			const chunk = chunks[i];
+			const id = chunkId(projectId, relativePath, i, chunk.startLine, chunk.endLine);
+			insertChunk.run(id, projectId, source, tier, relativePath, chunk.startLine, chunk.endLine, chunk.hash, chunk.text, updatedAt);
+			insertFts.run(chunk.text, id, projectId, relativePath, source, tier, chunk.startLine, chunk.endLine);
+		}
+		upsertFile.run(projectId, relativePath, source, tier, hash, mtime, size);
+	})();
+	return true;
+}
+/**
+* Index all memory, Notes, and content files for a single registered project.
+*/
+async function indexProject(db, projectId, rootPath, claudeNotesDir) {
+	const result = {
+		filesProcessed: 0,
+		chunksCreated: 0,
+		filesSkipped: 0
+	};
+	const filesToIndex = [];
+	const rootMemoryMd = join(rootPath, "MEMORY.md");
+	if (existsSync(rootMemoryMd)) filesToIndex.push({
+		absPath: rootMemoryMd,
+		rootBase: rootPath,
+		source: "memory",
+		tier: "evergreen"
+	});
+	const memoryDir = join(rootPath, "memory");
+	for (const absPath of walkMdFiles(memoryDir)) {
+		const tier = detectTier(relative(rootPath, absPath));
+		filesToIndex.push({
+			absPath,
+			rootBase: rootPath,
+			source: "memory",
+			tier
+		});
+	}
+	const notesDir = join(rootPath, "Notes");
+	for (const absPath of walkMdFiles(notesDir)) filesToIndex.push({
+		absPath,
+		rootBase: rootPath,
+		source: "notes",
+		tier: "session"
+	});
+	{
+		const titleInsertChunk = db.prepare(`
+      INSERT OR IGNORE INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+		const titleInsertFts = db.prepare(`
+      INSERT OR IGNORE INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+		const updatedAt = Date.now();
+		for (const absPath of walkMdFiles(notesDir)) {
+			const text = parseSessionTitleChunk(basename(absPath));
+			if (!text) continue;
+			const syntheticPath = `${relative(rootPath, absPath)}::title`;
+			const id = chunkId(projectId, syntheticPath, 0, 0, 0);
+			const hash = sha256File(text);
+			db.transaction(() => {
+				titleInsertChunk.run(id, projectId, "notes", "session", syntheticPath, 0, 0, hash, text, updatedAt);
+				titleInsertFts.run(text, id, projectId, syntheticPath, "notes", "session", 0, 0);
+			})();
+		}
+	}
+	if (!isPathTooBroadForContentScan(rootPath)) for (const absPath of walkContentFiles(rootPath)) filesToIndex.push({
+		absPath,
+		rootBase: rootPath,
+		source: "content",
+		tier: "topic"
+	});
+	if (claudeNotesDir && claudeNotesDir !== notesDir) {
+		for (const absPath of walkMdFiles(claudeNotesDir)) filesToIndex.push({
+			absPath,
+			rootBase: claudeNotesDir,
+			source: "notes",
+			tier: "session"
+		});
+		{
+			const updatedAt = Date.now();
+			const titleInsertChunk2 = db.prepare(`
+        INSERT OR IGNORE INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+			const titleInsertFts2 = db.prepare(`
+        INSERT OR IGNORE INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+			for (const absPath of walkMdFiles(claudeNotesDir)) {
+				const text = parseSessionTitleChunk(basename(absPath));
+				if (!text) continue;
+				const syntheticPath = `${relative(claudeNotesDir, absPath)}::title`;
+				const id = chunkId(projectId, syntheticPath, 0, 0, 0);
+				const hash = sha256File(text);
+				db.transaction(() => {
+					titleInsertChunk2.run(id, projectId, "notes", "session", syntheticPath, 0, 0, hash, text, updatedAt);
+					titleInsertFts2.run(text, id, projectId, syntheticPath, "notes", "session", 0, 0);
+				})();
+			}
+		}
+		if (claudeNotesDir.endsWith("/Notes")) {
+			const claudeProjectDir = claudeNotesDir.slice(0, -6);
+			const claudeMemoryDir = join(claudeProjectDir, "memory");
+			const claudeMemoryMd = join(claudeProjectDir, "MEMORY.md");
+			if (existsSync(claudeMemoryMd)) filesToIndex.push({
+				absPath: claudeMemoryMd,
+				rootBase: claudeProjectDir,
+				source: "memory",
+				tier: "evergreen"
+			});
+			for (const absPath of walkMdFiles(claudeMemoryDir)) {
+				const tier = detectTier(relative(claudeProjectDir, absPath));
+				filesToIndex.push({
+					absPath,
+					rootBase: claudeProjectDir,
+					source: "memory",
+					tier
+				});
+			}
+		}
+	}
+	await yieldToEventLoop();
+	let filesSinceYield = 0;
+	for (const { absPath, rootBase, source, tier } of filesToIndex) {
+		if (filesSinceYield >= INDEX_YIELD_EVERY) {
+			await yieldToEventLoop();
+			filesSinceYield = 0;
+		}
+		filesSinceYield++;
+		const relPath = relative(rootBase, absPath);
+		if (indexFile(db, projectId, rootBase, relPath, source, tier)) {
+			const count = db.prepare("SELECT COUNT(*) as n FROM memory_chunks WHERE project_id = ? AND path = ?").get(projectId, relPath);
+			result.filesProcessed++;
+			result.chunksCreated += count.n;
+		} else result.filesSkipped++;
+	}
+	const livePaths = /* @__PURE__ */ new Set();
+	for (const { absPath, rootBase } of filesToIndex) livePaths.add(relative(rootBase, absPath));
+	const dbChunkPaths = db.prepare("SELECT DISTINCT path FROM memory_chunks WHERE project_id = ?").all(projectId);
+	const stalePaths = [];
+	for (const row of dbChunkPaths) {
+		const basePath = row.path.endsWith("::title") ? row.path.slice(0, -7) : row.path;
+		if (!livePaths.has(basePath)) stalePaths.push(row.path);
+	}
+	if (stalePaths.length > 0) {
+		const deleteChunksFts = db.prepare("DELETE FROM memory_fts WHERE id = ?");
+		const deleteChunks = db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
+		const deleteFile = db.prepare("DELETE FROM memory_files WHERE project_id = ? AND path = ?");
+		db.transaction(() => {
+			for (const stalePath of stalePaths) {
+				const chunkIds = db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, stalePath);
+				for (const { id } of chunkIds) deleteChunksFts.run(id);
+				deleteChunks.run(projectId, stalePath);
+				deleteFile.run(projectId, stalePath);
+			}
+		})();
+	}
+	return result;
+}
+/**
+* Index all active projects registered in the registry DB.
+*
+* Async: yields to the event loop between each project so that the daemon's
+* Unix socket server can process IPC requests (e.g. status) while indexing.
+*/
+async function indexAllSqlite(db, registry) {
+	const projects = await registry.listProjects({ status: "active" });
+	const totals = {
+		filesProcessed: 0,
+		chunksCreated: 0,
+		filesSkipped: 0
+	};
+	for (const project of projects) {
+		await yieldToEventLoop();
+		const r = await indexProject(db, project.id, project.root_path, project.claude_notes_dir);
+		totals.filesProcessed += r.filesProcessed;
+		totals.chunksCreated += r.chunksCreated;
+		totals.filesSkipped += r.filesSkipped;
+	}
+	return {
+		projects: projects.length,
+		result: totals
+	};
+}
+
+//#endregion
+//#region src/storage/sqlite/tunnels.ts
+async function findTunnelsForSlugMap(db, slugMap, opts) {
+	const projectIds = Object.keys(slugMap).map(Number);
+	if (projectIds.length < 2) return {
+		tunnels: [],
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: 0
+	};
+	let candidateTerms = [];
+	try {
+		candidateTerms = db.prepare(`SELECT term, SUM(doc) AS doc_count, SUM(cnt) AS total_cnt
+         FROM memory_fts_v
+         GROUP BY term
+         HAVING SUM(cnt) >= ?
+         ORDER BY SUM(doc) DESC
+         LIMIT 500`).all(opts.min_occurrences).map((r) => r.term).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+	} catch {
+		const sampleRows = db.prepare(`SELECT LOWER(text) AS text FROM memory_chunks
+         WHERE LENGTH(text) > 20
+         ORDER BY RANDOM()
+         LIMIT 2000`).all();
+		const freq = /* @__PURE__ */ new Map();
+		for (const { text } of sampleRows) {
+			const tokens = text.split(/[\s\p{P}]+/u).filter(Boolean).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+			for (const t of tokens) freq.set(t, (freq.get(t) ?? 0) + 1);
+		}
+		candidateTerms = [...freq.entries()].filter(([, n]) => n >= opts.min_occurrences).sort((a, b) => b[1] - a[1]).slice(0, 200).map(([t]) => t);
+	}
+	if (candidateTerms.length === 0) return {
+		tunnels: [],
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: 0
+	};
+	const tunnels = [];
+	for (const term of candidateTerms) try {
+		const rows = db.prepare(`SELECT c.project_id, COUNT(*) AS cnt,
+                  MIN(c.updated_at) AS first_seen,
+                  MAX(c.updated_at) AS last_seen
+           FROM memory_fts f
+           JOIN memory_chunks c ON c.id = f.id
+           WHERE memory_fts MATCH ?
+             AND c.project_id IN (${projectIds.map(() => "?").join(", ")})
+           GROUP BY c.project_id`).all(`"${term.replace(/"/g, "\"\"")}"`, ...projectIds);
+		if (rows.length < opts.min_projects) continue;
+		const totalOccurrences = rows.reduce((s, r) => s + Number(r.cnt), 0);
+		if (totalOccurrences < opts.min_occurrences) continue;
+		const projects = rows.map((r) => slugMap[r.project_id] ?? String(r.project_id)).filter(Boolean);
+		const firstSeen = Math.min(...rows.map((r) => r.first_seen));
+		const lastSeen = Math.max(...rows.map((r) => r.last_seen));
+		tunnels.push({
+			concept: term,
+			projects,
+			occurrences: totalOccurrences,
+			first_seen: firstSeen,
+			last_seen: lastSeen
+		});
+	} catch {
+		continue;
+	}
+	tunnels.sort((a, b) => {
+		const byProjects = b.projects.length - a.projects.length;
+		if (byProjects !== 0) return byProjects;
+		return b.occurrences - a.occurrences;
+	});
+	return {
+		tunnels: tunnels.slice(0, opts.limit),
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: candidateTerms.length
+	};
+}
+/** Find cross-project concept tunnels against a SQLite federation database. */
+async function findTunnelsSqlite(db, registry, options) {
+	const opts = {
+		min_projects: options?.min_projects ?? 2,
+		min_occurrences: options?.min_occurrences ?? 3,
+		limit: options?.limit ?? 20
+	};
+	const projectRows = await registry.listProjects({ excludeArchived: true });
+	const slugMap = {};
+	for (const { id, slug } of projectRows) slugMap[id] = slug;
+	return findTunnelsForSlugMap(db, slugMap, opts);
+}
+
+//#endregion
+//#region src/storage/sqlite/sources.ts
+function getMemorySourcesReportSqlite(db) {
+	return {
+		composition: db.prepare(`SELECT source, tier, COUNT(*) AS chunks,
+              SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+         FROM memory_chunks GROUP BY source, tier ORDER BY COUNT(*) DESC`).all(),
+		paths: db.prepare(`SELECT path, COUNT(*) AS chunks FROM memory_chunks GROUP BY path`).all(),
+		churn: db.prepare(`SELECT date(updated_at/1000,'unixepoch') AS day, COUNT(*) AS chunks,
+              SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+         FROM memory_chunks GROUP BY day ORDER BY day DESC LIMIT 10`).all()
+	};
+}
+
+//#endregion
+//#region src/storage/sqlite/search.ts
+/**
+* Search across all indexed memory using FTS5 BM25 ranking.
+*
+* Results are ordered by BM25 score (most relevant first).
+* FTS5 bm25() returns negative values; closer to 0 = more relevant.
+* We negate the score so callers get positive values where higher = better.
+*/
+function searchMemory(db, query, opts) {
+	const maxResults = opts?.maxResults ?? 10;
+	const ftsQuery = buildFtsQuery(query);
+	const conditions = [];
+	const params = [ftsQuery];
+	if (opts?.projectIds && opts.projectIds.length > 0) {
+		const placeholders = opts.projectIds.map(() => "?").join(", ");
+		conditions.push(`c.project_id IN (${placeholders})`);
+		params.push(...opts.projectIds);
+	}
+	if (opts?.sources && opts.sources.length > 0) {
+		const placeholders = opts.sources.map(() => "?").join(", ");
+		conditions.push(`c.source IN (${placeholders})`);
+		params.push(...opts.sources);
+	}
+	if (opts?.tiers && opts.tiers.length > 0) {
+		const placeholders = opts.tiers.map(() => "?").join(", ");
+		conditions.push(`c.tier IN (${placeholders})`);
+		params.push(...opts.tiers);
+	}
+	const whereClause = conditions.length > 0 ? "AND " + conditions.join(" AND ") : "";
+	params.push(maxResults);
+	const sql = `
+    SELECT
+      c.id,
+      c.project_id,
+      c.path,
+      c.start_line,
+      c.end_line,
+      c.text             AS snippet,
+      c.tier,
+      c.source,
+      c.updated_at,
+      c.last_accessed_at,
+      c.relevance_score,
+      bm25(memory_fts) AS bm25_score
+    FROM memory_fts
+    JOIN memory_chunks c ON memory_fts.id = c.id
+    WHERE memory_fts MATCH ?
+      ${whereClause}
+    ORDER BY bm25_score
+    LIMIT ?
+  `;
+	let rows;
+	try {
+		rows = db.prepare(sql).all(...params);
+	} catch (e) {
+		if (!isQuerySyntaxError(e)) throw new Error(`Memory keyword search failed — the index is unusable, so this is NOT an empty result set. Cause: ${e instanceof Error ? e.message : String(e)}`);
+		return [];
+	}
+	const minScore = opts?.minScore ?? 0;
+	return rows.map((row) => {
+		const score = -row.bm25_score * (.5 + (row.relevance_score ?? .5));
+		return {
+			chunkId: row.id,
+			projectId: row.project_id,
+			path: row.path,
+			startLine: row.start_line,
+			endLine: row.end_line,
+			snippet: row.snippet,
+			score,
+			tier: row.tier,
+			source: row.source,
+			updatedAt: row.updated_at,
+			lastAccessedAt: row.last_accessed_at ?? void 0
+		};
+	}).filter((r) => r.score >= minScore);
+}
+/**
+* Search chunks using brute-force cosine similarity over stored embeddings.
+*
+* Only chunks that have a non-null embedding BLOB are considered.
+*
+* @param queryEmbedding  Pre-computed Float32Array for the search query.
+*/
+function searchMemorySemantic(db, queryEmbedding, opts) {
+	const maxResults = opts?.maxResults ?? 10;
+	const conditions = ["embedding IS NOT NULL"];
+	const params = [];
+	if (opts?.projectIds && opts.projectIds.length > 0) {
+		const placeholders = opts.projectIds.map(() => "?").join(", ");
+		conditions.push(`project_id IN (${placeholders})`);
+		params.push(...opts.projectIds);
+	}
+	if (opts?.sources && opts.sources.length > 0) {
+		const placeholders = opts.sources.map(() => "?").join(", ");
+		conditions.push(`source IN (${placeholders})`);
+		params.push(...opts.sources);
+	}
+	if (opts?.tiers && opts.tiers.length > 0) {
+		const placeholders = opts.tiers.map(() => "?").join(", ");
+		conditions.push(`tier IN (${placeholders})`);
+		params.push(...opts.tiers);
+	}
+	const sql = `
+    SELECT id, project_id, path, start_line, end_line, text, tier, source, embedding, updated_at, last_accessed_at, relevance_score
+    FROM memory_chunks
+    ${"WHERE " + conditions.join(" AND ")}
+    LIMIT 5000
+  `;
+	const rows = db.prepare(sql).all(...params);
+	if (rows.length === 0) return [];
+	const scored = rows.map((row) => {
+		const score = cosineSimilarity(queryEmbedding, deserializeEmbedding(row.embedding)) * (.5 + (row.relevance_score ?? .5));
+		return {
+			chunkId: row.id,
+			projectId: row.project_id,
+			path: row.path,
+			startLine: row.start_line,
+			endLine: row.end_line,
+			snippet: row.text,
+			score,
+			tier: row.tier,
+			source: row.source,
+			updatedAt: row.updated_at,
+			lastAccessedAt: row.last_accessed_at ?? void 0
+		};
+	});
+	const minScore = opts?.minScore ?? -Infinity;
+	return scored.filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, maxResults);
+}
+/**
+* Update last_accessed_at for a set of chunk IDs to the current timestamp.
+*
+* Best-effort: errors are silently ignored so search is never blocked.
+*/
+function touchChunksLastAccessed(db, chunkIds) {
+	if (chunkIds.length === 0) return;
+	try {
+		const now = Date.now();
+		const placeholders = chunkIds.map(() => "?").join(", ");
+		db.prepare(`UPDATE memory_chunks SET last_accessed_at = ? WHERE id IN (${placeholders})`).run(now, ...chunkIds);
+	} catch {}
+}
+
+//#endregion
+//#region src/storage/sqlite/kg-entity.ts
+/**
+* Upsert a KG entity in the federation SQLite database.
+*
+* If the entity already exists for this tenant:
+*   - Updates last_seen to now
+*   - Increments mention_count
+*   - Updates description if provided (overwrites older description)
+*
+* Returns the entity_id for use as a foreign key in kg_triples.
+*/
+function upsertKgEntitySqlite(db, params) {
+	const tenantId = params.tenantId ?? "default";
+	const entityId = entityContentId(params.name, tenantId);
+	const now = Date.now();
+	db.prepare(`
+    INSERT INTO kg_entities
+      (entity_id, tenant_id, name, type, description, first_seen, last_seen, mention_count, feedback_weight)
+    VALUES
+      (?, ?, ?, ?, ?, ?, ?, 1, 0.5)
+    ON CONFLICT(entity_id) DO UPDATE SET
+      last_seen     = excluded.last_seen,
+      mention_count = mention_count + 1,
+      description   = COALESCE(excluded.description, description),
+      type          = CASE WHEN excluded.type != 'unknown' THEN excluded.type ELSE type END
+  `).run(entityId, tenantId, params.name, params.type ?? "unknown", params.description ?? null, now, now);
+	return entityId;
+}
+/**
+* Look up a KG entity by name within a tenant.
+* Returns null if the entity does not exist.
+*/
+function findKgEntitySqlite(db, name, tenantId = "default") {
+	const entityId = entityContentId(name, tenantId);
+	return db.prepare("SELECT * FROM kg_entities WHERE entity_id = ? AND tenant_id = ?").get(entityId, tenantId) ?? null;
+}
+/**
+* List KG entities for a tenant, optionally filtered by type.
+*/
+function listKgEntitiesSqlite(db, tenantId = "default", type, limit = 100) {
+	if (type) return db.prepare("SELECT * FROM kg_entities WHERE tenant_id = ? AND type = ? ORDER BY mention_count DESC LIMIT ?").all(tenantId, type, limit);
+	return db.prepare("SELECT * FROM kg_entities WHERE tenant_id = ? ORDER BY mention_count DESC LIMIT ?").all(tenantId, limit);
+}
+/**
+* Apply an EMA (Exponential Moving Average) feedback update to an entity's weight.
+*
+* EMA formula: new_weight = old_weight + alpha * (target - old_weight)
+*/
+function updateEntityFeedbackWeightSqlite(db, entityId, normalizedRating, alpha = .1) {
+	const row = db.prepare("SELECT feedback_weight FROM kg_entities WHERE entity_id = ?").get(entityId);
+	if (!row) return;
+	const newWeight = row.feedback_weight + alpha * (normalizedRating - row.feedback_weight);
+	db.prepare("UPDATE kg_entities SET feedback_weight = ? WHERE entity_id = ?").run(newWeight, entityId);
+}
+
+//#endregion
+//#region src/storage/sqlite.ts
+var SQLiteBackend = class {
+	backendType = "sqlite";
+	supportsPostgresFeatures = false;
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Expose the raw better-sqlite3 Database handle. Storage-internal only —
+	* used by db-admin.ts for `pai db query|tables|schema` (the one place
+	* outside this class allowed to reach for it). Every other operation must
+	* be a StorageBackend method; nothing outside src/storage/ may call this.
+	*/
+	getRawDb() {
+		return this.db;
+	}
+	async close() {
+		try {
+			this.db.close();
+		} catch {}
+	}
+	async getStats() {
+		return {
+			files: this.db.prepare("SELECT COUNT(*) AS n FROM memory_files").get().n,
+			chunks: this.db.prepare("SELECT COUNT(*) AS n FROM memory_chunks").get().n
+		};
+	}
+	async getProjectStats(projectId) {
+		return {
+			files: this.db.prepare("SELECT COUNT(*) AS n FROM memory_files WHERE project_id = ?").get(projectId).n,
+			chunks: this.db.prepare("SELECT COUNT(*) AS n FROM memory_chunks WHERE project_id = ?").get(projectId).n
+		};
+	}
+	async getFileHash(projectId, path) {
+		return this.db.prepare("SELECT hash FROM memory_files WHERE project_id = ? AND path = ?").get(projectId, path)?.hash;
+	}
+	async upsertFile(file) {
+		this.db.prepare(`INSERT INTO memory_files (project_id, path, source, tier, hash, mtime, size)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(project_id, path) DO UPDATE SET
+           source = excluded.source,
+           tier   = excluded.tier,
+           hash   = excluded.hash,
+           mtime  = excluded.mtime,
+           size   = excluded.size`).run(file.projectId, file.path, file.source, file.tier, file.hash, file.mtime, file.size);
+	}
+	async getChunkIds(projectId, path) {
+		return this.db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, path).map((r) => r.id);
+	}
+	async deleteChunksForFile(projectId, path) {
+		const ids = await this.getChunkIds(projectId, path);
+		const deleteFts = this.db.prepare("DELETE FROM memory_fts WHERE id = ?");
+		const deleteChunks = this.db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
+		this.db.transaction(() => {
+			for (const id of ids) deleteFts.run(id);
+			deleteChunks.run(projectId, path);
+		})();
+	}
+	async insertChunks(chunks) {
+		if (chunks.length === 0) return;
+		const insertChunk = this.db.prepare(`INSERT INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		const insertFts = this.db.prepare(`INSERT INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+		this.db.transaction(() => {
+			for (const c of chunks) {
+				insertChunk.run(c.id, c.projectId, c.source, c.tier, c.path, c.startLine, c.endLine, c.hash, c.text, c.updatedAt);
+				insertFts.run(c.text, c.id, c.projectId, c.path, c.source, c.tier, c.startLine, c.endLine);
+			}
+		})();
+	}
+	async getDistinctChunkPaths(projectId) {
+		return this.db.prepare("SELECT DISTINCT path FROM memory_chunks WHERE project_id = ?").all(projectId).map((r) => r.path);
+	}
+	async deletePaths(projectId, paths) {
+		if (paths.length === 0) return;
+		const deleteFts = this.db.prepare("DELETE FROM memory_fts WHERE id = ?");
+		const deleteChunks = this.db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
+		const deleteFile = this.db.prepare("DELETE FROM memory_files WHERE project_id = ? AND path = ?");
+		this.db.transaction(() => {
+			for (const path of paths) {
+				const ids = this.db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, path);
+				for (const { id } of ids) deleteFts.run(id);
+				deleteChunks.run(projectId, path);
+				deleteFile.run(projectId, path);
+			}
+		})();
+	}
+	async getUnembeddedChunkIds(projectId, limit, after) {
+		const conditions = ["embedding IS NULL"];
+		const params = [];
+		if (projectId !== void 0) {
+			conditions.push("project_id = ?");
+			params.push(projectId);
+		}
+		const paginating = after !== void 0;
+		if (after) {
+			conditions.push("(project_id > ? OR (project_id = ? AND id > ?))");
+			params.push(after.projectId, after.projectId, after.id);
+		}
+		const where = "WHERE " + conditions.join(" AND ");
+		const orderBy = paginating ? "project_id, id" : `CASE
+          WHEN path LIKE '🧠 Ideaverse/%' THEN 0
+          WHEN path LIKE 'Z - Zettelkasten/%' THEN 0
+          WHEN path LIKE '💼 Business/%' THEN 0
+          WHEN path LIKE '📆 Meetings/%' THEN 1
+          WHEN path LIKE '💡 Insights/%' THEN 1
+          WHEN path LIKE '👨‍💻 People/%' THEN 1
+          WHEN path LIKE 'University/%' THEN 1
+          WHEN path LIKE 'Copilot/%' THEN 1
+          WHEN path LIKE '🗓️ Daily Notes/%' THEN 2
+          WHEN path LIKE 'PAI/%' THEN 3
+          WHEN path LIKE '09-job-search/%' THEN 4
+          WHEN path LIKE 'seriousletter/%' THEN 4
+          WHEN path LIKE 'Attachments/%' THEN 5
+          ELSE 2
+        END, id`;
+		return this.db.prepare(`SELECT id, text, project_id, path FROM memory_chunks ${where}
+        ORDER BY ${orderBy}${limit !== void 0 ? " LIMIT ?" : ""}`).all(...params, ...limit !== void 0 ? [limit] : []);
+	}
+	async updateEmbedding(chunkId, embedding) {
+		this.db.prepare("UPDATE memory_chunks SET embedding = ? WHERE id = ?").run(embedding, chunkId);
+	}
+	async searchKeyword(query, opts) {
+		return searchMemory(this.db, query, opts);
+	}
+	async searchSemantic(queryEmbedding, opts) {
+		return searchMemorySemantic(this.db, queryEmbedding, opts);
+	}
+	vaultNotSupported() {
+		throw new Error("Vault operations require the Postgres backend");
+	}
+	async upsertVaultFile() {
+		this.vaultNotSupported();
+	}
+	async deleteVaultFile() {
+		this.vaultNotSupported();
+	}
+	async getVaultFile() {
+		this.vaultNotSupported();
+	}
+	async getVaultFileByInode() {
+		this.vaultNotSupported();
+	}
+	async getAllVaultFiles() {
+		this.vaultNotSupported();
+	}
+	async getRecentVaultFiles() {
+		this.vaultNotSupported();
+	}
+	async countVaultFiles() {
+		this.vaultNotSupported();
+	}
+	async upsertVaultAliases() {
+		this.vaultNotSupported();
+	}
+	async deleteVaultAliases() {
+		this.vaultNotSupported();
+	}
+	async replaceLinksForSources() {
+		this.vaultNotSupported();
+	}
+	async getLinksFromSource() {
+		this.vaultNotSupported();
+	}
+	async getLinksToTarget() {
+		this.vaultNotSupported();
+	}
+	async getVaultLinkGraph() {
+		this.vaultNotSupported();
+	}
+	async upsertVaultHealth() {
+		this.vaultNotSupported();
+	}
+	async getVaultHealth() {
+		this.vaultNotSupported();
+	}
+	async getOrphans() {
+		this.vaultNotSupported();
+	}
+	async getDeadLinks() {
+		this.vaultNotSupported();
+	}
+	async upsertNameIndex() {
+		this.vaultNotSupported();
+	}
+	async replaceNameIndex() {
+		this.vaultNotSupported();
+	}
+	async resolveVaultName() {
+		this.vaultNotSupported();
+	}
+	async searchVaultNameIndex() {
+		this.vaultNotSupported();
+	}
+	async getVaultFilesByPaths() {
+		this.vaultNotSupported();
+	}
+	async getVaultFilesByPathsAfter() {
+		this.vaultNotSupported();
+	}
+	async getVaultLinksFromPaths() {
+		this.vaultNotSupported();
+	}
+	async getChunksWithEmbeddings() {
+		this.vaultNotSupported();
+	}
+	async getChunksForPath() {
+		this.vaultNotSupported();
+	}
+	async searchChunksByText() {
+		this.vaultNotSupported();
+	}
+	async countVaultFilesWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async countVaultFilesAfter() {
+		this.vaultNotSupported();
+	}
+	async countVaultLinksWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async countVaultLinksAfter() {
+		this.vaultNotSupported();
+	}
+	async getDeadLinksWithLineNumbers() {
+		this.vaultNotSupported();
+	}
+	async getDeadLinksWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async getDeadLinksAfter() {
+		this.vaultNotSupported();
+	}
+	async getOrphansWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async getOrphansAfter() {
+		this.vaultNotSupported();
+	}
+	async getLowConnectivity() {
+		this.vaultNotSupported();
+	}
+	async getLowConnectivityWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async getLowConnectivityAfter() {
+		this.vaultNotSupported();
+	}
+	async getAllVaultFilePaths() {
+		this.vaultNotSupported();
+	}
+	async getVaultFilePathsWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async getVaultFilePathsAfter() {
+		this.vaultNotSupported();
+	}
+	async getVaultLinkEdges() {
+		this.vaultNotSupported();
+	}
+	async getVaultLinkEdgesWithPrefix() {
+		this.vaultNotSupported();
+	}
+	async getVaultLinkEdgesAfter() {
+		this.vaultNotSupported();
+	}
+	async getVaultAlias() {
+		this.vaultNotSupported();
+	}
+	async upsertKgEntity(params) {
+		return upsertKgEntitySqlite(this.db, params);
+	}
+	async findKgEntity(name, tenantId = "default") {
+		return findKgEntitySqlite(this.db, name, tenantId);
+	}
+	async listKgEntities(tenantId = "default", type, limit = 100) {
+		return listKgEntitiesSqlite(this.db, tenantId, type, limit);
+	}
+	async updateEntityFeedbackWeight(entityId, normalizedRating, alpha = .1) {
+		return updateEntityFeedbackWeightSqlite(this.db, entityId, normalizedRating, alpha);
+	}
+	async getChunksForFeedback(chunkIds) {
+		if (chunkIds.length === 0) return [];
+		const placeholders = chunkIds.map(() => "?").join(", ");
+		return this.db.prepare(`SELECT id, text, relevance_score FROM memory_chunks WHERE id IN (${placeholders})`).all(...chunkIds).map((r) => ({
+			id: r.id,
+			text: r.text,
+			relevanceScore: r.relevance_score
+		}));
+	}
+	async updateChunkRelevanceScore(chunkId, score) {
+		this.db.prepare("UPDATE memory_chunks SET relevance_score = ? WHERE id = ?").run(score, chunkId);
+	}
+	async touchChunksLastAccessed(chunkIds) {
+		touchChunksLastAccessed(this.db, chunkIds);
+	}
+	async indexAll(registry) {
+		return indexAllSqlite(this.db, registry);
+	}
+	async findTunnels(registry, options) {
+		return findTunnelsSqlite(this.db, registry, options);
+	}
+	async getMemorySourcesReport() {
+		return getMemorySourcesReportSqlite(this.db);
+	}
+	postgresOnly(feature) {
+		throw new Error(`${feature} is not supported on the sqlite backend — set "storageBackend": "postgres" in the daemon config`);
+	}
+	async addKgTriple() {
+		this.postgresOnly("kg_triples");
+	}
+	async queryKgTriples() {
+		this.postgresOnly("kg_triples");
+	}
+	async invalidateKgTriple() {
+		this.postgresOnly("kg_triples");
+	}
+	async getKgContradictions() {
+		this.postgresOnly("kg_triples");
+	}
+	async getKgStats() {
+		this.postgresOnly("kg_triples");
+	}
+	async storeObservation() {
+		this.postgresOnly("observations");
+	}
+	async storeObservationWithProject() {
+		this.postgresOnly("observations");
+	}
+	async queryObservations() {
+		this.postgresOnly("observations");
+	}
+	async queryRecentObservations() {
+		this.postgresOnly("observations");
+	}
+	async querySessionObservations() {
+		this.postgresOnly("observations");
+	}
+	async getObservationStats() {
+		this.postgresOnly("observations");
+	}
+	async getObservationTypesForPaths() {
+		return /* @__PURE__ */ new Map();
+	}
+	async storeSessionSummary() {
+		this.postgresOnly("session summaries");
+	}
+	async queryRecentSummaries() {
+		this.postgresOnly("session summaries");
+	}
+	async recordSkillInvocation() {
+		this.postgresOnly("skill telemetry");
+	}
+	async querySkillTelemetry() {
+		this.postgresOnly("skill telemetry");
+	}
+	async countFilesWithPaths(paths) {
+		if (paths.length === 0) return 0;
+		const placeholders = paths.map(() => "?").join(", ");
+		return this.db.prepare(`SELECT COUNT(*) AS n FROM memory_files WHERE path IN (${placeholders})`).get(...paths).n;
+	}
+	async renameFilePaths(moves) {
+		if (moves.length === 0) return 0;
+		const updateFiles = this.db.prepare("UPDATE memory_files SET path = ? WHERE path = ?");
+		const updateChunks = this.db.prepare("UPDATE memory_chunks SET path = ? WHERE path = ?");
+		let filesUpdated = 0;
+		this.db.transaction(() => {
+			for (const { oldPath, newPath } of moves) {
+				const r = updateFiles.run(newPath, oldPath);
+				filesUpdated += r.changes;
+				updateChunks.run(newPath, oldPath);
+			}
+		})();
+		return filesUpdated;
+	}
+};
+
+//#endregion
+//#region src/registry/merge.ts
+var MergeError = class extends Error {};
+
+//#endregion
+//#region src/storage/registry-postgres.ts
+/**
+* PostgresRegistryBackend — implements RegistryBackend over the pg pool
+* pattern already used by PostgresBackend (src/storage/postgres/backend.ts).
+*
+* Same SQL shape as SQLiteRegistryBackend, translated to $-placeholders.
+* Behavioural notes where Postgres diverges from SQLite's "OR IGNORE":
+*  - `INSERT ... ON CONFLICT DO NOTHING` (no target) catches any unique
+*    violation on the table, matching SQLite's INSERT OR IGNORE.
+*  - SQLite's `UPDATE OR IGNORE` (used once, in reassignLinksTarget/
+*    applyProjectMerge's link retarget) has no direct Postgres equivalent —
+*    an UPDATE cannot specify ON CONFLICT. Replicated with a NOT EXISTS guard
+*    that skips rows whose new (session_id, target_project_id) would collide,
+*    leaving them for the caller's existing cleanup DELETE, exactly as the
+*    SQLite version does.
+*/
+const { Pool: PgPool } = pg;
+/**
+* node-postgres returns BIGINT columns (created_at/updated_at/archived_at/
+* closed_at, and MAX() over a BIGINT column) as strings — JS numbers can't
+* safely hold the full 64-bit range. Every value here is Date.now() ms and
+* well inside Number.isSafeInteger, so a plain Number() conversion keeps the
+* shape identical to better-sqlite3's row objects (same pattern as
+* rowToKgEntity in postgres/backend.ts).
+*/
+function toNum(v) {
+	return typeof v === "string" ? Number(v) : v;
+}
+function toNumOrNull(v) {
+	return v === null || v === void 0 ? null : toNum(v);
+}
+function mapProject(row) {
+	return {
+		...row,
+		created_at: toNum(row.created_at),
+		updated_at: toNum(row.updated_at),
+		archived_at: toNumOrNull(row.archived_at)
+	};
+}
+function mapProjectWithStats(row) {
+	return {
+		...mapProject(row),
+		session_count: toNum(row.session_count),
+		last_active: toNumOrNull(row.last_active)
+	};
+}
+function mapSession(row) {
+	return {
+		...row,
+		created_at: toNum(row.created_at),
+		closed_at: toNumOrNull(row.closed_at)
+	};
+}
+var PostgresRegistryBackend = class {
+	backendType = "postgres";
+	pool;
+	/** False when constructed from a pool owned elsewhere (the shared storage
+	*  backend pool, wired by src/storage/factory.ts) — close() must not end
+	*  a pool this instance doesn't own. */
+	ownsPool;
+	constructor(configOrPool) {
+		if (configOrPool instanceof PgPool) {
+			this.pool = configOrPool;
+			this.ownsPool = false;
+			return;
+		}
+		const config = configOrPool;
+		this.pool = new PgPool({
+			connectionString: config.connectionString ?? `postgresql://${config.user ?? "pai"}:${config.password ?? "pai"}@${config.host ?? "localhost"}:${config.port ?? 5432}/${config.database ?? "pai"}`,
+			max: config.maxConnections ?? 5,
+			connectionTimeoutMillis: config.connectionTimeoutMs ?? 5e3,
+			idleTimeoutMillis: 3e4,
+			allowExitOnIdle: true
+		});
+		this.ownsPool = true;
+		this.pool.on("error", (err) => {
+			process.stderr.write(`[pai-postgres] Registry pool error: ${err.message}\n`);
+		});
+	}
+	async close() {
+		if (this.ownsPool) await this.pool.end();
+	}
+	async resetRegistry() {
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			await client.query("DELETE FROM links");
+			await client.query("DELETE FROM compaction_log");
+			await client.query("DELETE FROM session_tags");
+			await client.query("DELETE FROM project_tags");
+			await client.query("DELETE FROM aliases");
+			await client.query("DELETE FROM sessions");
+			await client.query("DELETE FROM tags");
+			await client.query("DELETE FROM projects");
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+	}
+	async getProjectById(id) {
+		const r = await this.pool.query("SELECT * FROM projects WHERE id = $1", [id]);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async getProjectBySlug(slug, opts = {}) {
+		let sql = opts.caseInsensitive ? "SELECT * FROM projects WHERE lower(slug) = lower($1)" : "SELECT * FROM projects WHERE slug = $1";
+		const params = [slug];
+		if (opts.excludeId !== void 0) {
+			params.push(opts.excludeId);
+			sql += ` AND id != $${params.length}`;
+		}
+		const r = await this.pool.query(sql, params);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async getProjectByAlias(alias, opts = {}) {
+		const sql = opts.caseInsensitive ? "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE lower(a.alias) = lower($1)" : "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE a.alias = $1";
+		const r = await this.pool.query(sql, [alias]);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async getProjectByRootPath(rootPath, opts = {}) {
+		let sql = "SELECT * FROM projects WHERE root_path = $1";
+		const params = [rootPath];
+		if (opts.excludeId !== void 0) {
+			params.push(opts.excludeId);
+			sql += ` AND id != $${params.length}`;
+		}
+		const r = await this.pool.query(sql, params);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async getProjectByEncodedDir(encodedDir, opts = {}) {
+		let sql = "SELECT * FROM projects WHERE encoded_dir = $1";
+		const params = [encodedDir];
+		if (opts.excludeId !== void 0) {
+			params.push(opts.excludeId);
+			sql += ` AND id != $${params.length}`;
+		}
+		const r = await this.pool.query(sql, params);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async findProjectByCwdPrefix(cwd) {
+		const r = await this.pool.query(`SELECT * FROM projects WHERE status = 'active' AND $1 LIKE root_path || '%'
+       ORDER BY length(root_path) DESC LIMIT 1`, [cwd]);
+		return r.rows[0] ? mapProject(r.rows[0]) : null;
+	}
+	async listProjects(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.status) {
+			params.push(opts.status);
+			where.push(`p.status = $${params.length}`);
+		}
+		if (opts.excludeArchived) where.push("p.status != 'archived'");
+		if (opts.tagName) {
+			params.push(opts.tagName);
+			where.push(`p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = $${params.length})`);
+		}
+		let sql = "SELECT p.* FROM projects p";
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		switch (opts.orderBy) {
+			case "updated_desc":
+				sql += " ORDER BY p.updated_at DESC";
+				break;
+			case "slug":
+				sql += " ORDER BY p.slug ASC";
+				break;
+			case "id":
+				sql += " ORDER BY p.id";
+				break;
+			default:
+				sql += " ORDER BY p.status ASC, p.updated_at DESC";
+				break;
+		}
+		if (opts.limit !== void 0) {
+			params.push(opts.limit);
+			sql += ` LIMIT $${params.length}`;
+		}
+		return (await this.pool.query(sql, params)).rows.map(mapProject);
+	}
+	async listProjectsByPathLengthDesc(opts = {}) {
+		const where = opts.excludeArchived ? "WHERE status != 'archived'" : "";
+		return (await this.pool.query(`SELECT * FROM projects ${where} ORDER BY LENGTH(root_path) DESC`)).rows.map(mapProject);
+	}
+	async listProjectsWithSessionStats(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.status) {
+			params.push(opts.status);
+			where.push(`p.status = $${params.length}`);
+		}
+		if (opts.tagId !== void 0) {
+			params.push(opts.tagId);
+			where.push(`p.id IN (SELECT project_id FROM project_tags WHERE tag_id = $${params.length})`);
+		}
+		let sql = `
+      SELECT p.*,
+        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id)::int AS session_count,
+        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
+      FROM projects p
+    `;
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		sql += opts.orderBy === "updated_desc" ? " ORDER BY p.updated_at DESC" : " ORDER BY p.status ASC, p.updated_at DESC";
+		return (await this.pool.query(sql, params)).rows.map(mapProjectWithStats);
+	}
+	async listNamedProjects(opts = {}) {
+		const sql = `
+      SELECT p.*, a.alias AS name,
+        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id)::int AS session_count,
+        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
+      FROM projects p
+      ${opts.includeUnnamed ? "LEFT JOIN" : "JOIN"} aliases a ON a.project_id = p.id
+      WHERE p.status = 'active'
+      ORDER BY p.updated_at DESC
+    `;
+		return (await this.pool.query(sql)).rows.map((row) => ({
+			...mapProjectWithStats(row),
+			name: row.name
+		}));
+	}
+	async searchProjects(query, limit = 20) {
+		const q = `%${query}%`;
+		return (await this.pool.query(`SELECT * FROM projects WHERE slug LIKE $1 OR display_name LIKE $1 OR root_path LIKE $1
+       ORDER BY updated_at DESC LIMIT $2`, [q, limit])).rows.map(mapProject);
+	}
+	async countProjects(opts = {}) {
+		const r = opts.status ? await this.pool.query("SELECT COUNT(*)::text AS n FROM projects WHERE status = $1", [opts.status]) : await this.pool.query("SELECT COUNT(*)::text AS n FROM projects");
+		return parseInt(r.rows[0].n, 10);
+	}
+	async getMostRecentProjectUpdatedAt() {
+		const r = await this.pool.query("SELECT updated_at FROM projects ORDER BY updated_at DESC LIMIT 1");
+		return r.rows[0] ? Number(r.rows[0].updated_at) : null;
+	}
+	async countChildProjects(parentId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM projects WHERE parent_id = $1", [parentId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async findSiblingProjectsBySlugPattern(excludeProjectId, slug, limit = 3) {
+		return (await this.pool.query(`SELECT p.slug, p.root_path, COUNT(s.id)::int AS session_count
+       FROM projects p LEFT JOIN sessions s ON s.project_id = p.id
+       WHERE p.id != $1 AND (p.slug = $2 OR p.slug LIKE $2 || '-%' OR $2 LIKE p.slug || '-%')
+       GROUP BY p.id HAVING COUNT(s.id) > 0 ORDER BY session_count DESC LIMIT $3`, [
+			excludeProjectId,
+			slug,
+			limit
+		])).rows;
+	}
+	async createProject(input) {
+		const type = input.type ?? "local";
+		const status = input.status ?? "active";
+		return mapProject((await this.pool.query(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *`, [
+			input.slug,
+			input.displayName,
+			input.rootPath,
+			input.encodedDir,
+			type,
+			status,
+			input.createdAt,
+			input.updatedAt
+		])).rows[0]);
+	}
+	async createProjectWithSlugRetry(input) {
+		let slug = input.baseSlug;
+		let attempt = 0;
+		while (true) {
+			const r = await this.pool.query(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, 'local', 'active', $5, $6)
+         ON CONFLICT DO NOTHING RETURNING id`, [
+				slug,
+				input.displayName,
+				input.rootPath,
+				input.encodedDir,
+				input.createdAt,
+				input.updatedAt
+			]);
+			if (r.rows.length > 0) return {
+				id: r.rows[0].id,
+				slug,
+				created: true
+			};
+			const existing = await this.pool.query("SELECT id FROM projects WHERE root_path = $1", [input.rootPath]);
+			if (existing.rows[0]) return {
+				id: existing.rows[0].id,
+				slug,
+				created: false
+			};
+			attempt++;
+			slug = `${input.baseSlug}-${attempt}`;
+		}
+	}
+	async updateProjectPath(id, patch, updatedAt) {
+		const sets = [];
+		const params = [];
+		if (patch.rootPath !== void 0) {
+			params.push(patch.rootPath);
+			sets.push(`root_path = $${params.length}`);
+		}
+		if (patch.encodedDir !== void 0) {
+			params.push(patch.encodedDir);
+			sets.push(`encoded_dir = $${params.length}`);
+		}
+		if (updatedAt !== void 0) {
+			params.push(updatedAt);
+			sets.push(`updated_at = $${params.length}`);
+		}
+		if (!sets.length) return;
+		params.push(id);
+		await this.pool.query(`UPDATE projects SET ${sets.join(", ")} WHERE id = $${params.length}`, params);
+	}
+	async updateProjectStatus(id, status, opts = {}) {
+		const sets = [];
+		const params = [status];
+		sets.push("status = $1");
+		if (opts.archivedAt !== void 0) {
+			params.push(opts.archivedAt);
+			sets.push(`archived_at = $${params.length}`);
+		}
+		if (opts.updatedAt !== void 0) {
+			params.push(opts.updatedAt);
+			sets.push(`updated_at = $${params.length}`);
+		}
+		params.push(id);
+		let sql = `UPDATE projects SET ${sets.join(", ")} WHERE id = $${params.length}`;
+		if (opts.requireCurrentStatus) {
+			params.push(opts.requireCurrentStatus);
+			sql += ` AND status = $${params.length}`;
+		}
+		await this.pool.query(sql, params);
+	}
+	async updateProjectDisplayName(id, displayName, updatedAt) {
+		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET display_name = $1, updated_at = $2 WHERE id = $3", [
+			displayName,
+			updatedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE projects SET display_name = $1 WHERE id = $2", [displayName, id]);
+	}
+	async updateProjectType(id, type, updatedAt) {
+		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET type = $1, updated_at = $2 WHERE id = $3", [
+			type,
+			updatedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE projects SET type = $1 WHERE id = $2", [type, id]);
+	}
+	async updateProjectSessionConfig(id, config, updatedAt) {
+		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET session_config = $1, updated_at = $2 WHERE id = $3", [
+			config,
+			updatedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE projects SET session_config = $1 WHERE id = $2", [config, id]);
+	}
+	async updateProjectClaudeNotesDir(id, dir, updatedAt) {
+		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET claude_notes_dir = $1, updated_at = $2 WHERE id = $3", [
+			dir,
+			updatedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE projects SET claude_notes_dir = $1 WHERE id = $2", [dir, id]);
+	}
+	async updateProjectObsidianLink(id, link, updatedAt) {
+		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET obsidian_link = $1, updated_at = $2 WHERE id = $3", [
+			link,
+			updatedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE projects SET obsidian_link = $1 WHERE id = $2", [link, id]);
+	}
+	async updateProjectSlug(id, slug, updatedAt) {
+		await this.pool.query("UPDATE projects SET slug = $1, updated_at = $2 WHERE id = $3", [
+			slug,
+			updatedAt,
+			id
+		]);
+	}
+	async reassignProjectParent(fromParentId, toParentId) {
+		return (await this.pool.query("UPDATE projects SET parent_id = $1 WHERE parent_id = $2", [toParentId, fromParentId])).rowCount ?? 0;
+	}
+	async deleteProject(id) {
+		await this.pool.query("DELETE FROM projects WHERE id = $1", [id]);
+	}
+	async deleteProjectCascade(id) {
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			await client.query("DELETE FROM links WHERE target_project_id = $1", [id]);
+			await client.query("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = $1)", [id]);
+			await client.query("DELETE FROM compaction_log WHERE project_id = $1", [id]);
+			await client.query("DELETE FROM project_tags WHERE project_id = $1", [id]);
+			await client.query("DELETE FROM aliases WHERE project_id = $1", [id]);
+			await client.query("DELETE FROM sessions WHERE project_id = $1", [id]);
+			await client.query("DELETE FROM projects WHERE id = $1", [id]);
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+	}
+	async listTagsForProject(projectId) {
+		return (await this.pool.query("SELECT t.name FROM tags t JOIN project_tags pt ON pt.tag_id = t.id WHERE pt.project_id = $1 ORDER BY t.name", [projectId])).rows.map((row) => row.name);
+	}
+	async listAllTags() {
+		return (await this.pool.query("SELECT id, name FROM tags ORDER BY name")).rows;
+	}
+	async upsertTag(name) {
+		await this.pool.query("INSERT INTO tags (name) VALUES ($1) ON CONFLICT (name) DO NOTHING", [name]);
+		return (await this.pool.query("SELECT id FROM tags WHERE name = $1", [name])).rows[0].id;
+	}
+	async addProjectTag(projectId, tagId) {
+		await this.pool.query("INSERT INTO project_tags (project_id, tag_id) VALUES ($1, $2)", [projectId, tagId]);
+	}
+	async projectHasTag(projectId, tagId) {
+		return ((await this.pool.query("SELECT 1 FROM project_tags WHERE project_id = $1 AND tag_id = $2", [projectId, tagId])).rowCount ?? 0) > 0;
+	}
+	async deleteProjectTag(projectId, tagId) {
+		await this.pool.query("DELETE FROM project_tags WHERE project_id = $1 AND tag_id = $2", [projectId, tagId]);
+	}
+	async reassignProjectTag(fromProjectId, toProjectId, tagId) {
+		await this.pool.query("UPDATE project_tags SET project_id = $1 WHERE project_id = $2 AND tag_id = $3", [
+			toProjectId,
+			fromProjectId,
+			tagId
+		]);
+	}
+	async listProjectTagIds(projectId) {
+		return (await this.pool.query("SELECT tag_id FROM project_tags WHERE project_id = $1", [projectId])).rows.map((row) => row.tag_id);
+	}
+	async countProjectTagsForProject(projectId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM project_tags WHERE project_id = $1", [projectId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async copyProjectTags(fromProjectId, toProjectId) {
+		await this.pool.query(`INSERT INTO project_tags (project_id, tag_id) SELECT $1, tag_id FROM project_tags WHERE project_id = $2
+       ON CONFLICT (project_id, tag_id) DO NOTHING`, [toProjectId, fromProjectId]);
+	}
+	async deleteProjectTagsForProject(projectId) {
+		await this.pool.query("DELETE FROM project_tags WHERE project_id = $1", [projectId]);
+	}
+	async resolveAlias(alias) {
+		return (await this.pool.query("SELECT project_id FROM aliases WHERE alias = $1", [alias])).rows[0]?.project_id ?? null;
+	}
+	async listAliasesForProject(projectId) {
+		return (await this.pool.query("SELECT alias FROM aliases WHERE project_id = $1 ORDER BY alias", [projectId])).rows.map((row) => row.alias);
+	}
+	async addAlias(alias, projectId) {
+		await this.pool.query("INSERT INTO aliases (alias, project_id) VALUES ($1, $2)", [alias, projectId]);
+	}
+	async removeAlias(alias) {
+		await this.pool.query("DELETE FROM aliases WHERE alias = $1", [alias]);
+	}
+	async countAliasesForProject(projectId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM aliases WHERE project_id = $1", [projectId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async moveProjectAliases(fromProjectId, toProjectId) {
+		await this.pool.query("UPDATE aliases SET project_id = $1 WHERE project_id = $2", [toProjectId, fromProjectId]);
+	}
+	async reassignAlias(alias, toProjectId) {
+		await this.pool.query("UPDATE aliases SET project_id = $1 WHERE alias = $2", [toProjectId, alias]);
+	}
+	async listAliasMap() {
+		return (await this.pool.query(`SELECT a.alias AS alias, p.slug AS slug, p.root_path AS root_path
+       FROM aliases a JOIN projects p ON p.id = a.project_id WHERE p.status != 'archived'`)).rows;
+	}
+	async getSessionById(id) {
+		const r = await this.pool.query("SELECT * FROM sessions WHERE id = $1", [id]);
+		return r.rows[0] ? mapSession(r.rows[0]) : null;
+	}
+	async getSessionByNumber(projectId, number) {
+		const r = await this.pool.query("SELECT * FROM sessions WHERE project_id = $1 AND number = $2", [projectId, number]);
+		return r.rows[0] ? mapSession(r.rows[0]) : null;
+	}
+	async getLatestSessionForProject(projectId) {
+		const r = await this.pool.query("SELECT * FROM sessions WHERE project_id = $1 ORDER BY number DESC LIMIT 1", [projectId]);
+		return r.rows[0] ? mapSession(r.rows[0]) : null;
+	}
+	async getMaxSessionNumber(projectId) {
+		return (await this.pool.query("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = $1", [projectId])).rows[0].n;
+	}
+	async listSessionsForProject(projectId, opts = {}) {
+		let sql = `SELECT * FROM sessions WHERE project_id = $1 ORDER BY ${opts.orderBy === "created_desc" ? "created_at DESC" : "number ASC"}`;
+		const params = [projectId];
+		if (opts.limit !== void 0) {
+			params.push(opts.limit);
+			sql += ` LIMIT $${params.length}`;
+		}
+		return (await this.pool.query(sql, params)).rows.map(mapSession);
+	}
+	async listSessions(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.projectId !== void 0) {
+			params.push(opts.projectId);
+			where.push(`s.project_id = $${params.length}`);
+		}
+		if (opts.status) {
+			params.push(opts.status);
+			where.push(`s.status = $${params.length}`);
+		}
+		let sql = `
+      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
+    `;
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		sql += " ORDER BY s.date DESC, s.number DESC";
+		params.push(opts.limit ?? 20);
+		sql += ` LIMIT $${params.length}`;
+		return (await this.pool.query(sql, params)).rows.map((row) => ({
+			...mapSession(row),
+			project_slug: row.project_slug,
+			project_name: row.project_name
+		}));
+	}
+	async findSessionByFilename(projectId, filename) {
+		return (await this.pool.query("SELECT id FROM sessions WHERE project_id = $1 AND filename = $2 LIMIT 1", [projectId, filename])).rows[0] ?? null;
+	}
+	async sessionNumberTaken(projectId, number) {
+		return ((await this.pool.query("SELECT 1 FROM sessions WHERE project_id = $1 AND number = $2 LIMIT 1", [projectId, number])).rowCount ?? 0) > 0;
+	}
+	async createSession(input) {
+		const status = input.status ?? "completed";
+		return mapSession((await this.pool.query(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *`, [
+			input.projectId,
+			input.number,
+			input.date,
+			input.slug,
+			input.title,
+			input.filename,
+			status,
+			input.createdAt
+		])).rows[0]);
+	}
+	async upsertSessionIfAbsent(input) {
+		if (((await this.pool.query("SELECT id FROM sessions WHERE project_id = $1 AND number = $2", [input.projectId, input.number])).rowCount ?? 0) > 0) return false;
+		const status = input.status ?? "completed";
+		await this.pool.query(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [
+			input.projectId,
+			input.number,
+			input.date,
+			input.slug,
+			input.title,
+			input.filename,
+			status,
+			input.createdAt
+		]);
+		return true;
+	}
+	async updateSessionMeta(id, patch) {
+		const sets = [];
+		const params = [];
+		if (patch.slug !== void 0) {
+			params.push(patch.slug);
+			sets.push(`slug = $${params.length}`);
+		}
+		if (patch.title !== void 0) {
+			params.push(patch.title);
+			sets.push(`title = $${params.length}`);
+		}
+		if (patch.filename !== void 0) {
+			params.push(patch.filename);
+			sets.push(`filename = $${params.length}`);
+		}
+		if (!sets.length) return;
+		params.push(id);
+		await this.pool.query(`UPDATE sessions SET ${sets.join(", ")} WHERE id = $${params.length}`, params);
+	}
+	async updateSessionNumber(id, number, opts = {}) {
+		if (opts.filename !== void 0) await this.pool.query("UPDATE sessions SET number = $1, filename = $2 WHERE id = $3", [
+			number,
+			opts.filename,
+			id
+		]);
+		else await this.pool.query("UPDATE sessions SET number = $1 WHERE id = $2", [number, id]);
+	}
+	async updateSessionFilename(id, filename) {
+		await this.pool.query("UPDATE sessions SET filename = $1 WHERE id = $2", [filename, id]);
+	}
+	async updateSessionStatus(id, status, opts = {}) {
+		if (opts.closedAt !== void 0) await this.pool.query("UPDATE sessions SET status = $1, closed_at = $2 WHERE id = $3", [
+			status,
+			opts.closedAt,
+			id
+		]);
+		else await this.pool.query("UPDATE sessions SET status = $1 WHERE id = $2", [status, id]);
+	}
+	async moveSessionToProject(id, projectId, opts = {}) {
+		if (opts.number !== void 0) await this.pool.query("UPDATE sessions SET project_id = $1, number = $2 WHERE id = $3", [
+			projectId,
+			opts.number,
+			id
+		]);
+		else await this.pool.query("UPDATE sessions SET project_id = $1 WHERE id = $2", [projectId, id]);
+	}
+	async deleteSession(id) {
+		await this.pool.query("DELETE FROM sessions WHERE id = $1", [id]);
+	}
+	async backfillFoldedSession(keepId, dropId) {
+		await this.pool.query(`UPDATE sessions SET
+         claude_session_id = COALESCE(claude_session_id,
+                                      (SELECT claude_session_id FROM sessions WHERE id = $1)),
+         token_count       = COALESCE(token_count,
+                                      (SELECT token_count FROM sessions WHERE id = $1)),
+         closed_at         = COALESCE(closed_at,
+                                      (SELECT closed_at FROM sessions WHERE id = $1)),
+         status            = CASE WHEN status = 'open'
+                                   AND (SELECT status FROM sessions WHERE id = $1) != 'open'
+                                  THEN (SELECT status FROM sessions WHERE id = $1)
+                                  ELSE status END
+       WHERE id = $2`, [dropId, keepId]);
+	}
+	async countSessionsForProject(projectId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM sessions WHERE project_id = $1", [projectId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async countSessions() {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM sessions");
+		return parseInt(r.rows[0].n, 10);
+	}
+	async getMostRecentSessionDate(projectId) {
+		return (await this.pool.query("SELECT date FROM sessions WHERE project_id = $1 ORDER BY date DESC LIMIT 1", [projectId])).rows[0]?.date ?? null;
+	}
+	async getMostRecentSessionCreatedAt() {
+		const r = await this.pool.query("SELECT created_at FROM sessions ORDER BY created_at DESC LIMIT 1");
+		return r.rows[0] ? Number(r.rows[0].created_at) : null;
+	}
+	async listSessionTagIds(sessionId) {
+		return (await this.pool.query("SELECT tag_id FROM session_tags WHERE session_id = $1", [sessionId])).rows.map((row) => row.tag_id);
+	}
+	async sessionHasTag(sessionId, tagId) {
+		return ((await this.pool.query("SELECT 1 FROM session_tags WHERE session_id = $1 AND tag_id = $2", [sessionId, tagId])).rowCount ?? 0) > 0;
+	}
+	async addSessionTag(sessionId, tagId) {
+		await this.pool.query("INSERT INTO session_tags (session_id, tag_id) VALUES ($1, $2)", [sessionId, tagId]);
+	}
+	async deleteSessionTag(sessionId, tagId) {
+		await this.pool.query("DELETE FROM session_tags WHERE session_id = $1 AND tag_id = $2", [sessionId, tagId]);
+	}
+	async reassignSessionTag(fromSessionId, toSessionId, tagId) {
+		await this.pool.query("UPDATE session_tags SET session_id = $1 WHERE session_id = $2 AND tag_id = $3", [
+			toSessionId,
+			fromSessionId,
+			tagId
+		]);
+	}
+	async listTagsForSession(sessionId) {
+		return (await this.pool.query("SELECT t.name FROM tags t JOIN session_tags st ON st.tag_id = t.id WHERE st.session_id = $1 ORDER BY t.name", [sessionId])).rows.map((row) => row.name);
+	}
+	async addLink(input) {
+		await this.pool.query("INSERT INTO links (session_id, target_project_id, link_type, created_at) VALUES ($1, $2, $3, $4)", [
+			input.sessionId,
+			input.targetProjectId,
+			input.linkType,
+			input.createdAt
+		]);
+	}
+	async listLinksForSession(sessionId) {
+		return (await this.pool.query("SELECT id, target_project_id FROM links WHERE session_id = $1", [sessionId])).rows;
+	}
+	async listLinksForProject(projectId) {
+		return (await this.pool.query("SELECT id, session_id FROM links WHERE target_project_id = $1", [projectId])).rows;
+	}
+	async linkExists(sessionId, targetProjectId) {
+		return ((await this.pool.query("SELECT 1 FROM links WHERE session_id = $1 AND target_project_id = $2 LIMIT 1", [sessionId, targetProjectId])).rowCount ?? 0) > 0;
+	}
+	async deleteLink(id) {
+		await this.pool.query("DELETE FROM links WHERE id = $1", [id]);
+	}
+	async deleteLinksTargetingProject(projectId) {
+		await this.pool.query("DELETE FROM links WHERE target_project_id = $1", [projectId]);
+	}
+	async deleteLinksFromProjectSessions(projectId) {
+		await this.pool.query("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = $1)", [projectId]);
+	}
+	async retargetLink(id, targetProjectId) {
+		await this.pool.query("UPDATE links SET target_project_id = $1 WHERE id = $2", [targetProjectId, id]);
+	}
+	async moveLinkToSession(id, sessionId) {
+		await this.pool.query("UPDATE links SET session_id = $1 WHERE id = $2", [sessionId, id]);
+	}
+	async reassignLinksTarget(fromProjectId, toProjectId) {
+		await this.pool.query(`UPDATE links SET target_project_id = $1 WHERE target_project_id = $2
+         AND NOT EXISTS (
+           SELECT 1 FROM links l2 WHERE l2.session_id = links.session_id AND l2.target_project_id = $1
+         )`, [toProjectId, fromProjectId]);
+	}
+	async countLinksForProject(projectId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM links WHERE target_project_id = $1", [projectId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async deleteSelfLinksForProject(projectId) {
+		await this.pool.query(`DELETE FROM links WHERE target_project_id = $1
+         AND session_id IN (SELECT id FROM sessions WHERE project_id = $2)`, [projectId, projectId]);
+	}
+	async appendCompactionLog(entry) {
+		await this.pool.query(`INSERT INTO compaction_log (project_id, session_id, trigger, files_written, token_count, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6)`, [
+			entry.projectId,
+			entry.sessionId,
+			entry.trigger,
+			entry.filesWritten,
+			entry.tokenCount,
+			entry.createdAt
+		]);
+	}
+	async countCompactionLogsForProject(projectId) {
+		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM compaction_log WHERE project_id = $1", [projectId]);
+		return parseInt(r.rows[0].n, 10);
+	}
+	async moveCompactionLogsByProject(fromProjectId, toProjectId) {
+		return (await this.pool.query("UPDATE compaction_log SET project_id = $1 WHERE project_id = $2", [toProjectId, fromProjectId])).rowCount ?? 0;
+	}
+	async moveCompactionLogsBySession(fromSessionId, toSessionId) {
+		await this.pool.query("UPDATE compaction_log SET session_id = $1 WHERE session_id = $2", [toSessionId, fromSessionId]);
+	}
+	async deleteCompactionLogsForProject(projectId) {
+		await this.pool.query("DELETE FROM compaction_log WHERE project_id = $1", [projectId]);
+	}
+	async planProjectMerge(fromSlug, intoSlug) {
+		if (fromSlug === intoSlug) throw new MergeError(`Cannot merge ${fromSlug} into itself.`);
+		const fromR = await this.pool.query("SELECT id, slug FROM projects WHERE slug = $1", [fromSlug]);
+		const intoR = await this.pool.query("SELECT id, slug FROM projects WHERE slug = $1", [intoSlug]);
+		const from = fromR.rows[0];
+		const into = intoR.rows[0];
+		if (!from) throw new MergeError(`No project with slug "${fromSlug}".`);
+		if (!into) throw new MergeError(`No project with slug "${intoSlug}".`);
+		let next = (await this.pool.query("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = $1", [into.id])).rows[0].n;
+		const sessions = (await this.pool.query("SELECT id, number FROM sessions WHERE project_id = $1 ORDER BY number ASC", [from.id])).rows.map((s) => ({
+			id: s.id,
+			from: s.number,
+			to: ++next
+		}));
+		const count = async (sql, ...args) => {
+			const r = await this.pool.query(sql, args);
+			return parseInt(r.rows[0].n, 10);
+		};
+		const aliasTaken = await count("SELECT COUNT(*)::text AS n FROM aliases WHERE alias = $1", from.slug) > 0 || await count("SELECT COUNT(*)::text AS n FROM projects WHERE slug = $1", from.slug) > 1;
+		return {
+			fromId: from.id,
+			fromSlug: from.slug,
+			intoId: into.id,
+			intoSlug: into.slug,
+			sessions,
+			tags: await count("SELECT COUNT(*)::text AS n FROM project_tags WHERE project_id = $1", from.id),
+			aliases: await count("SELECT COUNT(*)::text AS n FROM aliases WHERE project_id = $1", from.id),
+			compactions: await count("SELECT COUNT(*)::text AS n FROM compaction_log WHERE project_id = $1", from.id),
+			links: await count("SELECT COUNT(*)::text AS n FROM links WHERE target_project_id = $1", from.id),
+			aliasToAdd: aliasTaken ? void 0 : from.slug
+		};
+	}
+	async applyProjectMerge(plan) {
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			for (const s of plan.sessions) await client.query("UPDATE sessions SET project_id = $1, number = $2 WHERE id = $3", [
+				plan.intoId,
+				s.to,
+				s.id
+			]);
+			await client.query(`INSERT INTO project_tags (project_id, tag_id)
+         SELECT $1, tag_id FROM project_tags WHERE project_id = $2
+         ON CONFLICT (project_id, tag_id) DO NOTHING`, [plan.intoId, plan.fromId]);
+			await client.query("DELETE FROM project_tags WHERE project_id = $1", [plan.fromId]);
+			await client.query("UPDATE aliases SET project_id = $1 WHERE project_id = $2", [plan.intoId, plan.fromId]);
+			await client.query("UPDATE compaction_log SET project_id = $1 WHERE project_id = $2", [plan.intoId, plan.fromId]);
+			await client.query(`UPDATE links SET target_project_id = $1 WHERE target_project_id = $2
+           AND NOT EXISTS (
+             SELECT 1 FROM links l2 WHERE l2.session_id = links.session_id AND l2.target_project_id = $1
+           )`, [plan.intoId, plan.fromId]);
+			await client.query("DELETE FROM links WHERE target_project_id = $1", [plan.fromId]);
+			await client.query(`DELETE FROM links WHERE target_project_id = $1
+           AND session_id IN (SELECT id FROM sessions WHERE project_id = $2)`, [plan.intoId, plan.intoId]);
+			if (plan.aliasToAdd) await client.query("INSERT INTO aliases (alias, project_id) VALUES ($1, $2) ON CONFLICT (alias) DO NOTHING", [plan.aliasToAdd, plan.intoId]);
+			await client.query("DELETE FROM projects WHERE id = $1", [plan.fromId]);
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+	}
+};
+
+//#endregion
+//#region src/storage/sqlite/registry-schema.ts
+const SCHEMA_VERSION = 4;
+const CREATE_TABLES_SQL = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS projects (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  slug          TEXT    NOT NULL UNIQUE,
+  display_name  TEXT    NOT NULL,
+  root_path     TEXT    NOT NULL UNIQUE,
+  encoded_dir   TEXT    NOT NULL UNIQUE,
+  type          TEXT    NOT NULL DEFAULT 'local'
+                        CHECK(type IN ('local','central','obsidian-linked','external')),
+  status        TEXT    NOT NULL DEFAULT 'active'
+                        CHECK(status IN ('active','archived','migrating')),
+  parent_id       INTEGER,
+  obsidian_link   TEXT,
+  claude_notes_dir TEXT,
+  session_config  TEXT,
+  created_at      INTEGER NOT NULL,
+  updated_at      INTEGER NOT NULL,
+  archived_at     INTEGER,
+  FOREIGN KEY (parent_id) REFERENCES projects(id)
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id                INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id        INTEGER NOT NULL,
+  number            INTEGER NOT NULL,
+  date              TEXT    NOT NULL,
+  slug              TEXT    NOT NULL,
+  title             TEXT    NOT NULL,
+  filename          TEXT    NOT NULL,
+  status            TEXT    NOT NULL DEFAULT 'open'
+                            CHECK(status IN ('open','completed','compacted')),
+  claude_session_id TEXT,
+  token_count       INTEGER,
+  created_at        INTEGER NOT NULL,
+  closed_at         INTEGER,
+  UNIQUE (project_id, number),
+  FOREIGN KEY (project_id) REFERENCES projects(id)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  id   INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT    NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS project_tags (
+  project_id INTEGER NOT NULL,
+  tag_id     INTEGER NOT NULL,
+  PRIMARY KEY (project_id, tag_id),
+  FOREIGN KEY (project_id) REFERENCES projects(id),
+  FOREIGN KEY (tag_id)     REFERENCES tags(id)
+);
+
+CREATE TABLE IF NOT EXISTS session_tags (
+  session_id INTEGER NOT NULL,
+  tag_id     INTEGER NOT NULL,
+  PRIMARY KEY (session_id, tag_id),
+  FOREIGN KEY (session_id) REFERENCES sessions(id),
+  FOREIGN KEY (tag_id)     REFERENCES tags(id)
+);
+
+CREATE TABLE IF NOT EXISTS aliases (
+  alias      TEXT    PRIMARY KEY,
+  project_id INTEGER NOT NULL,
+  FOREIGN KEY (project_id) REFERENCES projects(id)
+);
+
+CREATE TABLE IF NOT EXISTS compaction_log (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id    INTEGER NOT NULL,
+  session_id    INTEGER,
+  trigger       TEXT    NOT NULL
+                        CHECK(trigger IN ('precompact','manual','end-session')),
+  files_written TEXT    NOT NULL,
+  token_count   INTEGER,
+  created_at    INTEGER NOT NULL,
+  FOREIGN KEY (project_id) REFERENCES projects(id),
+  FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+CREATE TABLE IF NOT EXISTS links (
+  id               INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id       INTEGER NOT NULL,
+  target_project_id INTEGER NOT NULL,
+  link_type        TEXT    NOT NULL DEFAULT 'related'
+                           CHECK(link_type IN ('related','follow-up','reference')),
+  created_at       INTEGER NOT NULL,
+  UNIQUE (session_id, target_project_id),
+  FOREIGN KEY (session_id)        REFERENCES sessions(id),
+  FOREIGN KEY (target_project_id) REFERENCES projects(id)
+);
+
+CREATE TABLE IF NOT EXISTS schema_version (
+  version    INTEGER PRIMARY KEY,
+  applied_at INTEGER NOT NULL
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_projects_slug    ON projects(slug);
+CREATE INDEX IF NOT EXISTS idx_projects_status  ON projects(status);
+CREATE INDEX IF NOT EXISTS idx_projects_type    ON projects(type);
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_date    ON sessions(date);
+CREATE INDEX IF NOT EXISTS idx_sessions_status  ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_claude  ON sessions(claude_session_id);
+CREATE INDEX IF NOT EXISTS idx_pc_project       ON project_tags(project_id);
+`;
+/**
+* Run the full DDL against an open database connection.
+*
+* The function is idempotent — every statement uses IF NOT EXISTS so it is
+* safe to call on an already-initialised database.  After creating the tables
+* it inserts the current SCHEMA_VERSION into schema_version if no row exists
+* yet.
+*/
+function initializeSchema(db) {
+	db.exec(CREATE_TABLES_SQL);
+	if (!db.prepare("SELECT version FROM schema_version WHERE version = ?").get(SCHEMA_VERSION)) db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, Date.now());
+}
+/**
+* Apply incremental schema migrations to an already-initialised database.
+*
+* Each migration is guarded by a version check so it is safe to call on
+* databases at any schema version — already-applied migrations are skipped.
+*/
+function runMigrations(db) {
+	const current = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get()?.version ?? 0;
+	if (current < 2) db.transaction(() => {
+		try {
+			db.exec("ALTER TABLE projects ADD COLUMN claude_notes_dir TEXT");
+		} catch {}
+		db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(2, Date.now());
+	})();
+	if (current < 3) db.transaction(() => {
+		try {
+			db.exec(`
+          CREATE TABLE IF NOT EXISTS links (
+            id               INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id       INTEGER NOT NULL,
+            target_project_id INTEGER NOT NULL,
+            link_type        TEXT    NOT NULL DEFAULT 'related'
+                                     CHECK(link_type IN ('related','follow-up','reference')),
+            created_at       INTEGER NOT NULL,
+            UNIQUE (session_id, target_project_id),
+            FOREIGN KEY (session_id)        REFERENCES sessions(id),
+            FOREIGN KEY (target_project_id) REFERENCES projects(id)
+          )
+        `);
+		} catch {}
+		db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(3, Date.now());
+	})();
+	if (current < 4) db.transaction(() => {
+		try {
+			db.exec("ALTER TABLE projects ADD COLUMN session_config TEXT");
+		} catch {}
+		db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(4, Date.now());
+	})();
+}
+
+//#endregion
+//#region src/storage/sqlite/registry-db.ts
+/**
+* Database connection helper for the PAI registry.
+*
+* Uses better-sqlite3 (synchronous API) to open or create registry.db.
+* On first open it runs the full DDL via initializeSchema().
+*/
+/** Old registry path, inside the ~/.pai/ directory (pre-2026-09-19). */
+function oldRegistryPath() {
+	return join(homedir(), ".pai", "registry.db");
+}
+/** Registry path: PAI_HOME/registry.db if present, else the old
+*  ~/.pai/registry.db (one-time stderr notice), else the new path. */
+function registryDbPath() {
+	return resolvePaiFile(paiHomePath("registry.db"), [oldRegistryPath()], "pai config migrate --registry");
+}
+/**
+* Open (or create) the PAI registry database.
+*
+* @param path  Absolute path to registry.db.  Defaults to PAI_HOME/registry.db
+*              (falling back to the pre-2026-09-19 ~/.pai/registry.db).
+* @returns     An open better-sqlite3 Database instance.
+*
+* Side effects on first call:
+*  - Creates the parent directory if it does not exist.
+*  - Enables WAL journal mode.
+*  - Runs initializeSchema() if schema_version is empty.
+*/
+function openRegistry(path = registryDbPath()) {
+	mkdirSync(dirname(path), { recursive: true });
+	const db = new BetterSqlite3(path);
+	db.pragma("journal_mode = WAL");
+	db.pragma("foreign_keys = ON");
+	if (!db.prepare(`SELECT name FROM sqlite_master
+       WHERE type = 'table' AND name = 'schema_version'`).get()) initializeSchema(db);
+	else if (!db.prepare("SELECT version FROM schema_version LIMIT 1").get()) initializeSchema(db);
+	runMigrations(db);
+	return db;
+}
+
+//#endregion
+//#region src/storage/sqlite/registry-merge.ts
+/**
+* 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/storage/registry-sqlite.ts
+var SQLiteRegistryBackend = class {
+	backendType = "sqlite";
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/** Expose the raw better-sqlite3 Database handle for not-yet-converted callers. */
+	getRawDb() {
+		return this.db;
+	}
+	async close() {
+		try {
+			this.db.close();
+		} catch {}
+	}
+	async resetRegistry() {
+		this.db.transaction(() => {
+			this.db.prepare("DELETE FROM links").run();
+			this.db.prepare("DELETE FROM compaction_log").run();
+			this.db.prepare("DELETE FROM session_tags").run();
+			this.db.prepare("DELETE FROM project_tags").run();
+			this.db.prepare("DELETE FROM aliases").run();
+			this.db.prepare("DELETE FROM sessions").run();
+			this.db.prepare("DELETE FROM tags").run();
+			this.db.prepare("DELETE FROM projects").run();
+		})();
+	}
+	async getProjectById(id) {
+		return this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id) ?? null;
+	}
+	async getProjectBySlug(slug, opts = {}) {
+		let sql = opts.caseInsensitive ? "SELECT * FROM projects WHERE lower(slug) = lower(?)" : "SELECT * FROM projects WHERE slug = ?";
+		const params = [slug];
+		if (opts.excludeId !== void 0) {
+			sql += " AND id != ?";
+			params.push(opts.excludeId);
+		}
+		return this.db.prepare(sql).get(...params) ?? null;
+	}
+	async getProjectByAlias(alias, opts = {}) {
+		const sql = opts.caseInsensitive ? "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE lower(a.alias) = lower(?)" : "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE a.alias = ?";
+		return this.db.prepare(sql).get(alias) ?? null;
+	}
+	async getProjectByRootPath(rootPath, opts = {}) {
+		let sql = "SELECT * FROM projects WHERE root_path = ?";
+		const params = [rootPath];
+		if (opts.excludeId !== void 0) {
+			sql += " AND id != ?";
+			params.push(opts.excludeId);
+		}
+		return this.db.prepare(sql).get(...params) ?? null;
+	}
+	async getProjectByEncodedDir(encodedDir, opts = {}) {
+		let sql = "SELECT * FROM projects WHERE encoded_dir = ?";
+		const params = [encodedDir];
+		if (opts.excludeId !== void 0) {
+			sql += " AND id != ?";
+			params.push(opts.excludeId);
+		}
+		return this.db.prepare(sql).get(...params) ?? null;
+	}
+	async findProjectByCwdPrefix(cwd) {
+		return this.db.prepare(`SELECT * FROM projects WHERE status = 'active' AND ? LIKE root_path || '%'
+         ORDER BY length(root_path) DESC LIMIT 1`).get(cwd) ?? null;
+	}
+	async listProjects(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.status) {
+			where.push("p.status = ?");
+			params.push(opts.status);
+		}
+		if (opts.excludeArchived) where.push("p.status != 'archived'");
+		if (opts.tagName) {
+			where.push("p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = ?)");
+			params.push(opts.tagName);
+		}
+		let sql = "SELECT p.* FROM projects p";
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		switch (opts.orderBy) {
+			case "updated_desc":
+				sql += " ORDER BY p.updated_at DESC";
+				break;
+			case "slug":
+				sql += " ORDER BY p.slug ASC";
+				break;
+			case "id":
+				sql += " ORDER BY p.id";
+				break;
+			default:
+				sql += " ORDER BY p.status ASC, p.updated_at DESC";
+				break;
+		}
+		if (opts.limit !== void 0) {
+			sql += " LIMIT ?";
+			params.push(opts.limit);
+		}
+		return this.db.prepare(sql).all(...params);
+	}
+	async listProjectsByPathLengthDesc(opts = {}) {
+		const where = opts.excludeArchived ? "WHERE status != 'archived'" : "";
+		return this.db.prepare(`SELECT * FROM projects ${where} ORDER BY LENGTH(root_path) DESC`).all();
+	}
+	async listProjectsWithSessionStats(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.status) {
+			where.push("p.status = ?");
+			params.push(opts.status);
+		}
+		if (opts.tagId !== void 0) {
+			where.push("p.id IN (SELECT project_id FROM project_tags WHERE tag_id = ?)");
+			params.push(opts.tagId);
+		}
+		let sql = `
+      SELECT p.*,
+        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count,
+        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
+      FROM projects p
+    `;
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		sql += opts.orderBy === "updated_desc" ? " ORDER BY p.updated_at DESC" : " ORDER BY p.status ASC, p.updated_at DESC";
+		return this.db.prepare(sql).all(...params);
+	}
+	async listNamedProjects(opts = {}) {
+		const sql = `
+      SELECT p.*, a.alias AS name,
+        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count,
+        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
+      FROM projects p
+      ${opts.includeUnnamed ? "LEFT JOIN" : "JOIN"} aliases a ON a.project_id = p.id
+      WHERE p.status = 'active'
+      ORDER BY p.updated_at DESC
+    `;
+		return this.db.prepare(sql).all();
+	}
+	async searchProjects(query, limit = 20) {
+		const q = `%${query}%`;
+		return this.db.prepare(`SELECT * FROM projects WHERE slug LIKE ? OR display_name LIKE ? OR root_path LIKE ?
+         ORDER BY updated_at DESC LIMIT ?`).all(q, q, q, limit);
+	}
+	async countProjects(opts = {}) {
+		const sql = opts.status ? "SELECT COUNT(*) AS n FROM projects WHERE status = ?" : "SELECT COUNT(*) AS n FROM projects";
+		return (opts.status ? this.db.prepare(sql).get(opts.status) : this.db.prepare(sql).get()).n;
+	}
+	async getMostRecentProjectUpdatedAt() {
+		return this.db.prepare("SELECT updated_at FROM projects ORDER BY updated_at DESC LIMIT 1").get()?.updated_at ?? null;
+	}
+	async countChildProjects(parentId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM projects WHERE parent_id = ?").get(parentId).n;
+	}
+	async findSiblingProjectsBySlugPattern(excludeProjectId, slug, limit = 3) {
+		return this.db.prepare(`SELECT p.slug, p.root_path, COUNT(s.id) AS session_count
+         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 session_count > 0 ORDER BY session_count DESC LIMIT ?`).all(excludeProjectId, slug, slug, slug, limit);
+	}
+	async createProject(input) {
+		const type = input.type ?? "local";
+		const status = input.status ?? "active";
+		const result = this.db.prepare(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.slug, input.displayName, input.rootPath, input.encodedDir, type, status, input.createdAt, input.updatedAt);
+		return await this.getProjectById(result.lastInsertRowid);
+	}
+	async createProjectWithSlugRetry(input) {
+		let slug = input.baseSlug;
+		let attempt = 0;
+		const insert = this.db.prepare(`INSERT OR IGNORE INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'local', 'active', ?, ?)`);
+		while (true) {
+			const info = insert.run(slug, input.displayName, input.rootPath, input.encodedDir, input.createdAt, input.updatedAt);
+			if (info.changes > 0) return {
+				id: info.lastInsertRowid,
+				slug,
+				created: true
+			};
+			const existing = this.db.prepare("SELECT id FROM projects WHERE root_path = ?").get(input.rootPath);
+			if (existing) return {
+				id: existing.id,
+				slug,
+				created: false
+			};
+			attempt++;
+			slug = `${input.baseSlug}-${attempt}`;
+		}
+	}
+	async updateProjectPath(id, patch, updatedAt) {
+		const sets = [];
+		const params = [];
+		if (patch.rootPath !== void 0) {
+			sets.push("root_path = ?");
+			params.push(patch.rootPath);
+		}
+		if (patch.encodedDir !== void 0) {
+			sets.push("encoded_dir = ?");
+			params.push(patch.encodedDir);
+		}
+		if (updatedAt !== void 0) {
+			sets.push("updated_at = ?");
+			params.push(updatedAt);
+		}
+		if (!sets.length) return;
+		params.push(id);
+		this.db.prepare(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+	}
+	async updateProjectStatus(id, status, opts = {}) {
+		const sets = ["status = ?"];
+		const params = [status];
+		if (opts.archivedAt !== void 0) {
+			sets.push("archived_at = ?");
+			params.push(opts.archivedAt);
+		}
+		if (opts.updatedAt !== void 0) {
+			sets.push("updated_at = ?");
+			params.push(opts.updatedAt);
+		}
+		let sql = `UPDATE projects SET ${sets.join(", ")} WHERE id = ?`;
+		params.push(id);
+		if (opts.requireCurrentStatus) {
+			sql += " AND status = ?";
+			params.push(opts.requireCurrentStatus);
+		}
+		this.db.prepare(sql).run(...params);
+	}
+	async updateProjectDisplayName(id, displayName, updatedAt) {
+		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET display_name = ?, updated_at = ? WHERE id = ?").run(displayName, updatedAt, id);
+		else this.db.prepare("UPDATE projects SET display_name = ? WHERE id = ?").run(displayName, id);
+	}
+	async updateProjectType(id, type, updatedAt) {
+		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET type = ?, updated_at = ? WHERE id = ?").run(type, updatedAt, id);
+		else this.db.prepare("UPDATE projects SET type = ? WHERE id = ?").run(type, id);
+	}
+	async updateProjectSessionConfig(id, config, updatedAt) {
+		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET session_config = ?, updated_at = ? WHERE id = ?").run(config, updatedAt, id);
+		else this.db.prepare("UPDATE projects SET session_config = ? WHERE id = ?").run(config, id);
+	}
+	async updateProjectClaudeNotesDir(id, dir, updatedAt) {
+		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET claude_notes_dir = ?, updated_at = ? WHERE id = ?").run(dir, updatedAt, id);
+		else this.db.prepare("UPDATE projects SET claude_notes_dir = ? WHERE id = ?").run(dir, id);
+	}
+	async updateProjectObsidianLink(id, link, updatedAt) {
+		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET obsidian_link = ?, updated_at = ? WHERE id = ?").run(link, updatedAt, id);
+		else this.db.prepare("UPDATE projects SET obsidian_link = ? WHERE id = ?").run(link, id);
+	}
+	async updateProjectSlug(id, slug, updatedAt) {
+		this.db.prepare("UPDATE projects SET slug = ?, updated_at = ? WHERE id = ?").run(slug, updatedAt, id);
+	}
+	async reassignProjectParent(fromParentId, toParentId) {
+		return this.db.prepare("UPDATE projects SET parent_id = ? WHERE parent_id = ?").run(toParentId, fromParentId).changes;
+	}
+	async deleteProject(id) {
+		this.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+	}
+	async deleteProjectCascade(id) {
+		this.db.transaction(() => {
+			this.db.prepare("DELETE FROM links WHERE target_project_id = ?").run(id);
+			this.db.prepare("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = ?)").run(id);
+			this.db.prepare("DELETE FROM compaction_log WHERE project_id = ?").run(id);
+			this.db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(id);
+			this.db.prepare("DELETE FROM aliases WHERE project_id = ?").run(id);
+			this.db.prepare("DELETE FROM sessions WHERE project_id = ?").run(id);
+			this.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+		})();
+	}
+	async listTagsForProject(projectId) {
+		return this.db.prepare("SELECT t.name FROM tags t JOIN project_tags pt ON pt.tag_id = t.id WHERE pt.project_id = ? ORDER BY t.name").all(projectId).map((r) => r.name);
+	}
+	async listAllTags() {
+		return this.db.prepare("SELECT id, name FROM tags ORDER BY name").all();
+	}
+	async upsertTag(name) {
+		this.db.prepare("INSERT OR IGNORE INTO tags (name) VALUES (?)").run(name);
+		return this.db.prepare("SELECT id FROM tags WHERE name = ?").get(name).id;
+	}
+	async addProjectTag(projectId, tagId) {
+		this.db.prepare("INSERT INTO project_tags (project_id, tag_id) VALUES (?, ?)").run(projectId, tagId);
+	}
+	async projectHasTag(projectId, tagId) {
+		return !!this.db.prepare("SELECT 1 FROM project_tags WHERE project_id = ? AND tag_id = ?").get(projectId, tagId);
+	}
+	async deleteProjectTag(projectId, tagId) {
+		this.db.prepare("DELETE FROM project_tags WHERE project_id = ? AND tag_id = ?").run(projectId, tagId);
+	}
+	async reassignProjectTag(fromProjectId, toProjectId, tagId) {
+		this.db.prepare("UPDATE project_tags SET project_id = ? WHERE project_id = ? AND tag_id = ?").run(toProjectId, fromProjectId, tagId);
+	}
+	async listProjectTagIds(projectId) {
+		return this.db.prepare("SELECT tag_id FROM project_tags WHERE project_id = ?").all(projectId).map((r) => r.tag_id);
+	}
+	async countProjectTagsForProject(projectId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM project_tags WHERE project_id = ?").get(projectId).n;
+	}
+	async copyProjectTags(fromProjectId, toProjectId) {
+		this.db.prepare("INSERT OR IGNORE INTO project_tags (project_id, tag_id) SELECT ?, tag_id FROM project_tags WHERE project_id = ?").run(toProjectId, fromProjectId);
+	}
+	async deleteProjectTagsForProject(projectId) {
+		this.db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(projectId);
+	}
+	async resolveAlias(alias) {
+		return this.db.prepare("SELECT project_id FROM aliases WHERE alias = ?").get(alias)?.project_id ?? null;
+	}
+	async listAliasesForProject(projectId) {
+		return this.db.prepare("SELECT alias FROM aliases WHERE project_id = ? ORDER BY alias").all(projectId).map((r) => r.alias);
+	}
+	async addAlias(alias, projectId) {
+		this.db.prepare("INSERT INTO aliases (alias, project_id) VALUES (?, ?)").run(alias, projectId);
+	}
+	async removeAlias(alias) {
+		this.db.prepare("DELETE FROM aliases WHERE alias = ?").run(alias);
+	}
+	async countAliasesForProject(projectId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM aliases WHERE project_id = ?").get(projectId).n;
+	}
+	async moveProjectAliases(fromProjectId, toProjectId) {
+		this.db.prepare("UPDATE aliases SET project_id = ? WHERE project_id = ?").run(toProjectId, fromProjectId);
+	}
+	async reassignAlias(alias, toProjectId) {
+		this.db.prepare("UPDATE aliases SET project_id = ? WHERE alias = ?").run(toProjectId, alias);
+	}
+	async listAliasMap() {
+		return this.db.prepare(`SELECT a.alias AS alias, p.slug AS slug, p.root_path AS root_path
+         FROM aliases a JOIN projects p ON p.id = a.project_id WHERE p.status != 'archived'`).all();
+	}
+	async getSessionById(id) {
+		return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id) ?? null;
+	}
+	async getSessionByNumber(projectId, number) {
+		return this.db.prepare("SELECT * FROM sessions WHERE project_id = ? AND number = ?").get(projectId, number) ?? null;
+	}
+	async getLatestSessionForProject(projectId) {
+		return this.db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(projectId) ?? null;
+	}
+	async getMaxSessionNumber(projectId) {
+		return this.db.prepare("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = ?").get(projectId).n;
+	}
+	async listSessionsForProject(projectId, opts = {}) {
+		let sql = `SELECT * FROM sessions WHERE project_id = ? ORDER BY ${opts.orderBy === "created_desc" ? "created_at DESC" : "number ASC"}`;
+		const params = [projectId];
+		if (opts.limit !== void 0) {
+			sql += " LIMIT ?";
+			params.push(opts.limit);
+		}
+		return this.db.prepare(sql).all(...params);
+	}
+	async listSessions(opts = {}) {
+		const where = [];
+		const params = [];
+		if (opts.projectId !== void 0) {
+			where.push("s.project_id = ?");
+			params.push(opts.projectId);
+		}
+		if (opts.status) {
+			where.push("s.status = ?");
+			params.push(opts.status);
+		}
+		let sql = `
+      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
+    `;
+		if (where.length) sql += " WHERE " + where.join(" AND ");
+		sql += " ORDER BY s.date DESC, s.number DESC";
+		const limit = opts.limit ?? 20;
+		sql += ` LIMIT ${limit}`;
+		return this.db.prepare(sql).all(...params);
+	}
+	async findSessionByFilename(projectId, filename) {
+		return this.db.prepare("SELECT id FROM sessions WHERE project_id = ? AND filename = ? LIMIT 1").get(projectId, filename) ?? null;
+	}
+	async sessionNumberTaken(projectId, number) {
+		return !!this.db.prepare("SELECT 1 FROM sessions WHERE project_id = ? AND number = ? LIMIT 1").get(projectId, number);
+	}
+	async createSession(input) {
+		const status = input.status ?? "completed";
+		const result = this.db.prepare(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.projectId, input.number, input.date, input.slug, input.title, input.filename, status, input.createdAt);
+		return await this.getSessionById(result.lastInsertRowid);
+	}
+	async upsertSessionIfAbsent(input) {
+		if (this.db.prepare("SELECT id FROM sessions WHERE project_id = ? AND number = ?").get(input.projectId, input.number)) return false;
+		const status = input.status ?? "completed";
+		this.db.prepare(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.projectId, input.number, input.date, input.slug, input.title, input.filename, status, input.createdAt);
+		return true;
+	}
+	async updateSessionMeta(id, patch) {
+		const sets = [];
+		const params = [];
+		if (patch.slug !== void 0) {
+			sets.push("slug = ?");
+			params.push(patch.slug);
+		}
+		if (patch.title !== void 0) {
+			sets.push("title = ?");
+			params.push(patch.title);
+		}
+		if (patch.filename !== void 0) {
+			sets.push("filename = ?");
+			params.push(patch.filename);
+		}
+		if (!sets.length) return;
+		params.push(id);
+		this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+	}
+	async updateSessionNumber(id, number, opts = {}) {
+		if (opts.filename !== void 0) this.db.prepare("UPDATE sessions SET number = ?, filename = ? WHERE id = ?").run(number, opts.filename, id);
+		else this.db.prepare("UPDATE sessions SET number = ? WHERE id = ?").run(number, id);
+	}
+	async updateSessionFilename(id, filename) {
+		this.db.prepare("UPDATE sessions SET filename = ? WHERE id = ?").run(filename, id);
+	}
+	async updateSessionStatus(id, status, opts = {}) {
+		if (opts.closedAt !== void 0) this.db.prepare("UPDATE sessions SET status = ?, closed_at = ? WHERE id = ?").run(status, opts.closedAt, id);
+		else this.db.prepare("UPDATE sessions SET status = ? WHERE id = ?").run(status, id);
+	}
+	async moveSessionToProject(id, projectId, opts = {}) {
+		if (opts.number !== void 0) this.db.prepare("UPDATE sessions SET project_id = ?, number = ? WHERE id = ?").run(projectId, opts.number, id);
+		else this.db.prepare("UPDATE sessions SET project_id = ? WHERE id = ?").run(projectId, id);
+	}
+	async deleteSession(id) {
+		this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+	}
+	async backfillFoldedSession(keepId, dropId) {
+		this.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);
+	}
+	async countSessionsForProject(projectId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?").get(projectId).n;
+	}
+	async countSessions() {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions").get().n;
+	}
+	async getMostRecentSessionDate(projectId) {
+		return this.db.prepare("SELECT date FROM sessions WHERE project_id = ? ORDER BY date DESC LIMIT 1").get(projectId)?.date ?? null;
+	}
+	async getMostRecentSessionCreatedAt() {
+		return this.db.prepare("SELECT created_at FROM sessions ORDER BY created_at DESC LIMIT 1").get()?.created_at ?? null;
+	}
+	async listSessionTagIds(sessionId) {
+		return this.db.prepare("SELECT tag_id FROM session_tags WHERE session_id = ?").all(sessionId).map((r) => r.tag_id);
+	}
+	async sessionHasTag(sessionId, tagId) {
+		return !!this.db.prepare("SELECT 1 FROM session_tags WHERE session_id = ? AND tag_id = ?").get(sessionId, tagId);
+	}
+	async addSessionTag(sessionId, tagId) {
+		this.db.prepare("INSERT INTO session_tags (session_id, tag_id) VALUES (?, ?)").run(sessionId, tagId);
+	}
+	async deleteSessionTag(sessionId, tagId) {
+		this.db.prepare("DELETE FROM session_tags WHERE session_id = ? AND tag_id = ?").run(sessionId, tagId);
+	}
+	async reassignSessionTag(fromSessionId, toSessionId, tagId) {
+		this.db.prepare("UPDATE session_tags SET session_id = ? WHERE session_id = ? AND tag_id = ?").run(toSessionId, fromSessionId, tagId);
+	}
+	async listTagsForSession(sessionId) {
+		return this.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);
+	}
+	async addLink(input) {
+		this.db.prepare("INSERT INTO links (session_id, target_project_id, link_type, created_at) VALUES (?, ?, ?, ?)").run(input.sessionId, input.targetProjectId, input.linkType, input.createdAt);
+	}
+	async listLinksForSession(sessionId) {
+		return this.db.prepare("SELECT id, target_project_id FROM links WHERE session_id = ?").all(sessionId);
+	}
+	async listLinksForProject(projectId) {
+		return this.db.prepare("SELECT id, session_id FROM links WHERE target_project_id = ?").all(projectId);
+	}
+	async linkExists(sessionId, targetProjectId) {
+		return !!this.db.prepare("SELECT 1 FROM links WHERE session_id = ? AND target_project_id = ? LIMIT 1").get(sessionId, targetProjectId);
+	}
+	async deleteLink(id) {
+		this.db.prepare("DELETE FROM links WHERE id = ?").run(id);
+	}
+	async deleteLinksTargetingProject(projectId) {
+		this.db.prepare("DELETE FROM links WHERE target_project_id = ?").run(projectId);
+	}
+	async deleteLinksFromProjectSessions(projectId) {
+		this.db.prepare("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = ?)").run(projectId);
+	}
+	async retargetLink(id, targetProjectId) {
+		this.db.prepare("UPDATE links SET target_project_id = ? WHERE id = ?").run(targetProjectId, id);
+	}
+	async moveLinkToSession(id, sessionId) {
+		this.db.prepare("UPDATE links SET session_id = ? WHERE id = ?").run(sessionId, id);
+	}
+	async reassignLinksTarget(fromProjectId, toProjectId) {
+		this.db.prepare("UPDATE OR IGNORE links SET target_project_id = ? WHERE target_project_id = ?").run(toProjectId, fromProjectId);
+	}
+	async countLinksForProject(projectId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM links WHERE target_project_id = ?").get(projectId).n;
+	}
+	async deleteSelfLinksForProject(projectId) {
+		this.db.prepare(`DELETE FROM links WHERE target_project_id = ?
+           AND session_id IN (SELECT id FROM sessions WHERE project_id = ?)`).run(projectId, projectId);
+	}
+	async appendCompactionLog(entry) {
+		this.db.prepare(`INSERT INTO compaction_log (project_id, session_id, trigger, files_written, token_count, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(entry.projectId, entry.sessionId, entry.trigger, entry.filesWritten, entry.tokenCount, entry.createdAt);
+	}
+	async countCompactionLogsForProject(projectId) {
+		return this.db.prepare("SELECT COUNT(*) AS n FROM compaction_log WHERE project_id = ?").get(projectId).n;
+	}
+	async moveCompactionLogsByProject(fromProjectId, toProjectId) {
+		return this.db.prepare("UPDATE compaction_log SET project_id = ? WHERE project_id = ?").run(toProjectId, fromProjectId).changes;
+	}
+	async moveCompactionLogsBySession(fromSessionId, toSessionId) {
+		this.db.prepare("UPDATE compaction_log SET session_id = ? WHERE session_id = ?").run(toSessionId, fromSessionId);
+	}
+	async deleteCompactionLogsForProject(projectId) {
+		this.db.prepare("DELETE FROM compaction_log WHERE project_id = ?").run(projectId);
+	}
+	async planProjectMerge(fromSlug, intoSlug) {
+		return planMerge(this.db, fromSlug, intoSlug);
+	}
+	async applyProjectMerge(plan) {
+		applyMerge(this.db, plan);
+	}
+};
+
+//#endregion
+//#region src/storage/factory.ts
+/** Backoff schedule (ms) for the bounded CLI retry path. */
+const CLI_RETRY_DELAYS_MS = [
+	500,
+	1e3,
+	2e3
+];
+/** Backoff cap (ms) for the daemon's infinite retry path. */
+const DAEMON_RETRY_CAP_MS = 15e3;
+/**
+* Create and return the configured StorageBackend.
+*
+* Auto-behaviour:
+*  - storageBackend = "sqlite"   → SQLiteBackend always
+*  - storageBackend = "postgres" → PostgresBackend (retried; never falls back)
+*/
+async function createStorageBackend(config, opts = {}) {
+	if (config.storageBackend === "postgres") return await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);
+	return createSQLiteBackend();
+}
+/**
+* Attempt a single Postgres connection (ensure DB + test). Returns the live
+* backend on success, or an error string describing why it failed.
+*/
+async function attemptPostgres(config) {
+	const pgConfig = config.postgres ?? {};
+	let backend = null;
+	try {
+		await PostgresBackend.ensureDatabase(pgConfig);
+		backend = new PostgresBackend(pgConfig);
+		const err = await backend.testConnection();
+		if (err) {
+			await backend.close().catch(() => {});
+			return { error: err };
+		}
+		return { backend };
+	} catch (e) {
+		if (backend) await backend.close().catch(() => {});
+		return { error: e instanceof Error ? e.message : String(e) };
+	}
+}
+/**
+* Consecutive failures before the outage is escalated to the user.
+*
+* Not the first failure: a container restarting, or the daemon starting before
+* Docker is up, recovers within a few seconds and is not worth a notification.
+* By the fifth attempt the backoff has already spent tens of seconds, which is
+* long enough that something is actually wrong.
+*/
+const ESCALATE_AFTER_ATTEMPTS = 5;
+/** Tell the user the backend is down, through whatever channels are configured. */
+async function notifyBackendDown(attempts, lastError) {
+	try {
+		await routeNotification({
+			event: "error",
+			title: "PAI: storage backend unreachable",
+			message: `Postgres has not answered in ${attempts} attempts (${lastError}). Indexing, session notes and the work queue are stalled until it returns. Check the container, then \`pai daemon status\`.`
+		}, loadConfig().notifications);
+	} catch {}
+}
+/** And say when it comes back, so the alert is not left hanging. */
+async function notifyBackendRecovered(attempts, since) {
+	try {
+		const mins = since ? Math.max(1, Math.round((Date.now() - since) / 6e4)) : null;
+		await routeNotification({
+			event: "completion",
+			title: "PAI: storage backend back",
+			message: `Postgres answered after ${attempts} attempts` + (mins ? `, ${mins} min down` : "") + `. The queue will drain on its own.`
+		}, loadConfig().notifications);
+	} catch {}
+}
+/**
+* Shared retry loop: attempt a connection, back off, escalate, repeat — used
+* by both the federation and registry Postgres connectors so the retry/outage
+* behaviour (§6, "never falls back to SQLite silently") stays in one place.
+*/
+async function retryConnect(attempt, waitForever, label) {
+	let attemptN = 0;
+	let outageSince = null;
+	let escalated = false;
+	while (true) {
+		attemptN++;
+		const result = await attempt();
+		if ("backend" in result) {
+			if (attemptN > 1) process.stderr.write(`[pai-daemon] Connected to ${label} (after ${attemptN} attempts).\n`);
+			clearBackendOutage();
+			if (escalated) notifyBackendRecovered(attemptN, outageSince);
+			return result.backend;
+		}
+		const lastError = result.error;
+		if (!waitForever && attemptN > CLI_RETRY_DELAYS_MS.length) throw new Error(`${label} unreachable after ${attemptN} attempts: ${lastError}. Is Docker Desktop / Postgres running? Refusing to fall back to SQLite (would split the corpus). Start Postgres and retry.`);
+		const delayMs = waitForever ? Math.min(DAEMON_RETRY_CAP_MS, 1e3 * 2 ** Math.min(attemptN - 1, 4)) : CLI_RETRY_DELAYS_MS[attemptN - 1];
+		process.stderr.write(`[pai-daemon] ${label} unavailable (${lastError}). Retry ${attemptN}${waitForever ? "" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} in ${delayMs}ms...\n`);
+		setBackendOutage({
+			backend: label,
+			since: outageSince ?? (outageSince = Date.now()),
+			attempts: attemptN,
+			lastError: String(lastError)
+		});
+		if (waitForever && attemptN === ESCALATE_AFTER_ATTEMPTS && !escalated) {
+			escalated = true;
+			notifyBackendDown(attemptN, String(lastError));
+		}
+		await new Promise((r) => setTimeout(r, delayMs));
+	}
+}
+async function connectPostgres(config, waitForever) {
+	return retryConnect(() => attemptPostgres(config), waitForever, "PostgreSQL backend");
+}
+/**
+* The process's one Postgres connection: storage and registry share a
+* single pg Pool (one connection budget) instead of each opening their own.
+* Whichever of createStorageBackend()/createRegistryBackend() runs first
+* creates it via connectPostgres()'s retry/outage handling; the other
+* reuses its pool through PostgresBackend.getPool(). Reset by closeStorage().
+*/
+let pgBackendPromise = null;
+function getSharedPostgresBackend(config, waitForever) {
+	if (!pgBackendPromise) pgBackendPromise = connectPostgres(config, waitForever);
+	return pgBackendPromise;
+}
+async function createSQLiteBackend() {
+	return new SQLiteBackend(openFederation());
+}
+/**
+* Create and return the configured RegistryBackend (projects, sessions,
+* tags, aliases, links, compaction_log). Same auto-behaviour and same
+* never-fall-back-to-SQLite rule as createStorageBackend().
+*/
+async function createRegistryBackend(config, opts = {}) {
+	if (config.storageBackend === "postgres") return new PostgresRegistryBackend((await getSharedPostgresBackend(config, opts.waitForPostgres ?? false)).getPool());
+	return createSQLiteRegistryBackend();
+}
+async function createSQLiteRegistryBackend() {
+	return new SQLiteRegistryBackend(openRegistry());
+}
+/**
+* Process-wide backend accessors.
+*
+* Callers across the codebase must get their StorageBackend/RegistryBackend
+* from here rather than constructing SQLite or Postgres directly — this is
+* the one place that decides which backend a process uses, and the one place
+* that closes it on exit.
+*/
+let storagePromise = null;
+let registryPromise = null;
+let beforeExitRegistered = false;
+function registerBeforeExit() {
+	if (beforeExitRegistered) return;
+	beforeExitRegistered = true;
+	process.once("beforeExit", () => {
+		closeStorage();
+	});
+}
+/**
+* Returns the process-wide StorageBackend, creating it on first call.
+*
+* The whole body up to and including the `storagePromise = (async () =>
+* ...)()` assignment must run synchronously (no `await` before it) — two
+* calls issued in the same tick (e.g. `Promise.all([get(), get()])`) must
+* both observe the same cached promise rather than each racing to create
+* their own backend.
+*/
+async function getStorageBackend() {
+	if (!storagePromise) storagePromise = (async () => {
+		registerBeforeExit();
+		return await createStorageBackend(loadConfig());
+	})();
+	return storagePromise;
+}
+/** Returns the process-wide RegistryBackend, creating it on first call. Same synchronous-caching requirement as getStorageBackend(). */
+async function getRegistryBackend() {
+	if (!registryPromise) registryPromise = (async () => {
+		registerBeforeExit();
+		return await createRegistryBackend(loadConfig());
+	})();
+	return registryPromise;
+}
+/** Closes any backends created via getStorageBackend()/getRegistryBackend(). Idempotent. */
+async function closeStorage() {
+	const pending = [storagePromise, registryPromise];
+	const pg = pgBackendPromise;
+	storagePromise = null;
+	registryPromise = null;
+	pgBackendPromise = null;
+	for (const p of pending) {
+		if (!p) continue;
+		try {
+			const backend = await p;
+			if (backend.backendType === "postgres") continue;
+			await backend.close();
+		} catch {}
+	}
+	if (pg) try {
+		await (await pg).close();
+	} catch {}
+}
+
+//#endregion
+export { getStorageBackend as a, MergeError as c, getBackendOutage as d, humanDuration as f, getRegistryBackend as i, federationDbPath as l, createRegistryBackend as n, oldRegistryPath as o, createStorageBackend as r, registryDbPath as s, closeStorage as t, oldFederationPath as u };
+//# sourceMappingURL=factory-Ypf8r0fK.mjs.map