@tekmidian/pai 0.42.5 → 0.43.0

package/dist/context-handover-cache-B9NKSjwR.mjs

@@ -0,0 +1,3242 @@
+import { a as paiHomePath, o as resolvePaiFile, r as migratePaiFile } from "./pai-home-ChAOupZc.mjs";
+import { _ as warn, c as ok, i as err, n as dim, r as encodeDir, s as now, t as bold } from "./utils-CJymHkYm.mjs";
+import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "./migrate-CfERwXhY.mjs";
+import { n as ensurePaiMarker, t as discoverPaiMarkers } from "./pai-marker-B20KqhA8.mjs";
+import { r as openFederation } from "./db-DJ8rk0VM.mjs";
+import { l as defaultWorkersConfig, v as readWorkersSection, y as resolveModelCapability } from "./config-DxMZjpvY.mjs";
+import { i as kgAdd, o as kgInvalidate, r as upsertKgEntity, s as kgQuery } from "./kg-entity-BSjM5xZh.mjs";
+import { _ as workersLogDir, f as ensureNoMcpConfig, i as buildRunEnv, n as ensureProxyRunning, t as DEFAULT_PROXY_PORT, u as resolveTarget } from "./server-Ch99xt5K.mjs";
+import { d as registryDb, k as storageBackend, n as daemonConfig } from "./state-PJrgfDLW.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { copyFileSync as copyFileSync$1, existsSync as existsSync$1, linkSync as linkSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { basename as basename$1, join as join$1, resolve as resolve$1 } from "path";
+import { homedir as homedir$1 } from "os";
+
+//#region src/registry/moved.ts
+/**
+* moved.ts — reconnect a project to transcripts that moved out from under it.
+*
+* The registry records an `encoded_dir`: the name Claude Code gave the folder
+* holding a project's transcripts. It is written once, when the project is
+* added, and nothing updates it when the project moves. So a project that has
+* been relocated points at a directory that is empty or gone, and every lookup
+* — checkpoints, handovers, session digests — quietly returns nothing.
+*
+* `resolveTranscriptDir` already re-derives the name from the project's current
+* root path, which fixes the case where the encoding is stale but the path is
+* right. It cannot fix the case where the ENCODING RULE itself does not
+* reproduce the folder name: iCloud paths with `~` in them, emoji segments, or
+* a folder Claude Code created under a path the project no longer has.
+*
+* This module answers that case by asking the transcripts instead of guessing.
+* Every transcript entry records the `cwd` it was written in, so the mapping
+* from a project root to its transcript folder is a fact sitting on disk rather
+* than something to be inferred from a naming convention. Reading it is slower
+* than a string transform and it is right, which is the correct trade for a
+* repair that runs on demand.
+*/
+/** Where Claude Code keeps per-project transcript folders. */
+function claudeProjectsDir() {
+	return join(homedir(), ".claude", "projects");
+}
+/**
+* Every transcript file for one project folder — live and archived.
+*
+* The archived half matters: `session-stop` moves all but the newest transcript
+* into `sessions/`, so a folder whose work is finished has an empty top level
+* and everything underneath. Counting only the top level reports a busy project
+* as unused, which is how an earlier audit of this same problem overstated the
+* breakage by a factor of three.
+*/
+function transcriptFiles(projectDir) {
+	const out = [];
+	for (const dir of [projectDir, join(projectDir, "sessions")]) {
+		if (!existsSync(dir)) continue;
+		try {
+			for (const entry of readdirSync(dir)) if (entry.endsWith(".jsonl")) out.push(join(dir, entry));
+		} catch {}
+	}
+	return out;
+}
+/**
+* The working directory a transcript was recorded in.
+*
+* Reads only the head of the file. `cwd` is present on the first entry and does
+* not change within a session, so scanning further would cost time to learn
+* nothing. Returns null rather than throwing: a truncated or half-written
+* transcript is normal for a session that is still running.
+*/
+function cwdOfTranscript(file, maxBytes = 64 * 1024) {
+	let head;
+	try {
+		head = readFileSync(file).subarray(0, maxBytes).toString("utf-8");
+	} catch {
+		return null;
+	}
+	for (const line of head.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const cwd = JSON.parse(line).cwd;
+			if (cwd) return cwd;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+/**
+* Map every working directory seen on disk to the folders that hold its
+* transcripts.
+*
+* A directory can legitimately map to more than one folder — Claude Code's
+* encoding is lossy, so two different paths can collide, and a project moved
+* and moved back leaves both. Callers pick; this reports.
+*/
+function scanTranscriptFolders(projectsDir = claudeProjectsDir(), sampleFilesPerFolder = 8) {
+	const byCwd = /* @__PURE__ */ new Map();
+	if (!existsSync(projectsDir)) return byCwd;
+	let entries;
+	try {
+		entries = readdirSync(projectsDir);
+	} catch {
+		return byCwd;
+	}
+	for (const name of entries) {
+		const dir = join(projectsDir, name);
+		try {
+			if (!statSync(dir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const files = transcriptFiles(dir);
+		if (files.length === 0) continue;
+		const mtimes = /* @__PURE__ */ new Map();
+		for (const f of files) try {
+			mtimes.set(f, statSync(f).mtimeMs);
+		} catch {
+			mtimes.set(f, 0);
+		}
+		const ordered = files.sort((a, b) => (mtimes.get(b) ?? 0) - (mtimes.get(a) ?? 0));
+		const newest = mtimes.get(ordered[0]) ?? 0;
+		const tally = /* @__PURE__ */ new Map();
+		let sampled = 0;
+		for (const f of ordered.slice(0, sampleFilesPerFolder)) {
+			const cwd = cwdOfTranscript(f);
+			if (!cwd) continue;
+			sampled++;
+			tally.set(cwd, (tally.get(cwd) ?? 0) + 1);
+		}
+		for (const [cwd, matching] of tally) {
+			const record = {
+				name,
+				count: files.length,
+				newest,
+				matching,
+				total: sampled
+			};
+			const list = byCwd.get(cwd);
+			if (list) list.push(record);
+			else byCwd.set(cwd, [record]);
+		}
+	}
+	return byCwd;
+}
+/**
+* Which projects point at the wrong transcript folder, and where they belong.
+*
+* A project is only reported when its stored folder yields nothing AND its root
+* path is recorded as a `cwd` somewhere else. Both halves matter: without the
+* first this would rewrite entries that work, and without the second it would
+* have nothing better to offer than the value already there.
+*
+* `resolvesNow` is supplied by the caller so this module does not have to
+* duplicate the resolver's fallback logic — a project the shipped resolver
+* already handles is not broken and must not be "repaired".
+*/
+function findMovedProjects(rows, byCwd, resolvesNow) {
+	const out = [];
+	for (const row of rows) {
+		if (resolvesNow(row)) continue;
+		const candidates = byCwd.get(row.root_path);
+		if (!candidates || candidates.length === 0) continue;
+		const owned = candidates.filter((c) => c.matching * 2 > c.total);
+		if (owned.length === 0) continue;
+		const best = [...owned].sort((a, b) => b.count - a.count || b.newest - a.newest)[0];
+		if (best.name === row.encoded_dir) continue;
+		out.push({
+			id: row.id,
+			slug: row.slug,
+			rootPath: row.root_path,
+			storedDir: row.encoded_dir,
+			correctDir: best.name,
+			transcripts: best.count,
+			sessions: row.sessions
+		});
+	}
+	return out.sort((a, b) => b.sessions - a.sessions || b.transcripts - a.transcripts);
+}
+
+//#endregion
+//#region src/cli/commands/registry/utils.ts
+/**
+* Would writing this encoded_dir replace a working one with a broken one?
+*
+* `encodeDir` is lossy: `~` and emoji do not survive it, so a value derived
+* from a project's path can name a folder Claude Code never created. Every
+* caller here derives its value that way, and this function is the single
+* point they all pass through.
+*
+* `pai registry reconnect` repairs those by reading the cwd recorded inside the
+* transcripts. Without this check the next scan silently reverts the repair —
+* and it reverts it in the most confusing possible way, because a read taken
+* straight after the repair still shows it. Observed twice on 2026-08-02:
+* three projects reconnected, verified, and rediscovered as broken within the
+* hour, with the repair command reporting success both times.
+*
+* Permits the write when the new value resolves to transcripts, or when the
+* existing one resolves to nothing — i.e. whenever it cannot make things worse.
+*/
+function worthWriting(db, projectId, encodedDir) {
+	if (transcriptFiles(join(claudeProjectsDir(), encodedDir)).length > 0) return true;
+	const current = db.prepare("SELECT encoded_dir FROM projects WHERE id = ?").get(projectId)?.encoded_dir;
+	if (!current) return true;
+	return transcriptFiles(join(claudeProjectsDir(), current)).length === 0;
+}
+/**
+* Upsert a project row. Returns { id, isNew }.
+*
+* Matching priority:
+*  1. root_path  — most reliable; handles slug collisions
+*  2. encoded_dir — Claude project dirs are canonical
+*  3. Insert with suffix-deduplication on slug collision
+*
+* display_name is set to basename(rootPath) on INSERT so that the unified
+* listing always shows a human-readable name rather than the kebab-case slug.
+*/
+function upsertProject(db, slug, rootPath, encodedDir) {
+	const ts = now();
+	const byPath = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
+	if (byPath) {
+		const encodedOwner = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir);
+		if ((!encodedOwner || encodedOwner.id === byPath.id) && worthWriting(db, byPath.id, encodedDir)) db.prepare("UPDATE projects SET encoded_dir = ?, updated_at = ? WHERE id = ?").run(encodedDir, ts, byPath.id);
+		return {
+			id: byPath.id,
+			isNew: false
+		};
+	}
+	const byEncoded = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir);
+	if (byEncoded) {
+		const pathOwner = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
+		if (!pathOwner || pathOwner.id === byEncoded.id) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(rootPath, ts, byEncoded.id);
+		return {
+			id: byEncoded.id,
+			isNew: false
+		};
+	}
+	let finalSlug = slug;
+	let attempt = 0;
+	while (true) {
+		if (!db.prepare("SELECT id FROM projects WHERE slug = ?").get(finalSlug)) break;
+		attempt++;
+		finalSlug = `${slug}-${attempt}`;
+	}
+	const displayName = basename(rootPath) || finalSlug;
+	const result = db.prepare(`INSERT OR IGNORE INTO projects
+         (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'local', 'active', ?, ?)`).run(finalSlug, displayName, rootPath, encodedDir, ts, ts);
+	if (result.changes === 0) {
+		const fallback = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(encodedDir) ?? db.prepare("SELECT id FROM projects WHERE root_path = ?").get(rootPath);
+		if (fallback) return {
+			id: fallback.id,
+			isNew: false
+		};
+		throw new Error(`upsertProject: INSERT OR IGNORE was suppressed but no matching row found for root_path=${rootPath} encoded_dir=${encodedDir}`);
+	}
+	return {
+		id: result.lastInsertRowid,
+		isNew: true
+	};
+}
+/** Upsert a session note. Returns true if newly inserted. */
+function upsertSession(db, projectId, number, date, slug, title, filename) {
+	if (db.prepare("SELECT id FROM sessions WHERE project_id = ? AND number = ?").get(projectId, number)) return false;
+	const ts = now();
+	db.prepare(`INSERT INTO sessions
+       (project_id, number, date, slug, title, filename, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'completed', ?)`).run(projectId, number, date, slug, title, filename, ts);
+	return true;
+}
+
+//#endregion
+//#region src/cli/commands/registry/scan.ts
+/** Registry scan command: walk ~/.claude/projects/ and populate the registry. */
+/**
+* Build a reverse map from encoded-dir → real path using the clc session
+* registry (~/.claude/session.json).
+*
+* The clc registry stores { sessions: [{ directory, ... }, ...] }. For each
+* entry with a resolvable directory, we encode the realpath and add it to
+* the map. This lets the scanner recover project paths that are not in
+* Claude's session-registry.json but were registered by clc.
+*/
+function buildClcDirMap() {
+	const map = /* @__PURE__ */ new Map();
+	const sessionFile = join(homedir(), ".claude", "session.json");
+	if (!existsSync(sessionFile)) return map;
+	try {
+		const raw = readFileSync(sessionFile, "utf8");
+		const parsed = JSON.parse(raw);
+		for (const entry of parsed.sessions ?? []) {
+			const dir = entry.directory;
+			if (!dir) continue;
+			try {
+				const real = realpathSync(dir);
+				if (!existsSync(real)) continue;
+				const encoded = encodeDir(real);
+				map.set(encoded, real);
+			} catch {}
+		}
+	} catch {}
+	return map;
+}
+const CLAUDE_PROJECTS_DIR$1 = join(homedir(), ".claude", "projects");
+/** Old registry-scan config path: ~/.pai/config.json (pre-2026-09-19). Named
+*  "config.json" there, but that name is taken at PAI_HOME by the daemon
+*  config, so the new location is registry-scan.json instead. */
+function oldScanConfigFile() {
+	return join(homedir(), ".pai", "config.json");
+}
+function scanConfigFilePath() {
+	return resolvePaiFile(paiHomePath("registry-scan.json"), [oldScanConfigFile()], "pai config migrate --registry-scan");
+}
+function migrateScanConfig(opts = {}) {
+	return migratePaiFile(paiHomePath("registry-scan.json"), [oldScanConfigFile()], opts);
+}
+function loadScanConfig() {
+	const file = scanConfigFilePath();
+	if (!existsSync(file)) return { scan_dirs: [] };
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return { scan_dirs: [] };
+	}
+}
+function saveScanConfig(config) {
+	const file = paiHomePath("registry-scan.json");
+	mkdirSync(paiHomePath(), { recursive: true });
+	writeFileSync(file, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+/**
+* Resolve a path to its canonical form, falling back to the input.
+*
+* Every path that becomes a `projects.root_path` must go through this. That
+* column is UNIQUE, so two spellings of one directory create two projects and
+* split session history between them. The spellings are not hypothetical: a
+* configured scan_dir of `~/dev/ai` (where `~/dev` is a symlink) makes every
+* project under it register under the symlinked path, while a session started
+* from the resolved path registers a rival row.
+*/
+function canonicalPath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return p;
+	}
+}
+function resolveHome(p) {
+	if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+	return resolve(p);
+}
+/**
+* Recursively find all .md files in a directory, including YYYY/MM subdirectories.
+* Returns filenames (basename only).
+*/
+function findNoteFiles(dir) {
+	const results = [];
+	if (!existsSync(dir)) return results;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isFile() && entry.name.endsWith(".md")) results.push(entry.name);
+	else if (entry.isDirectory() && /^\d{4}$/.test(entry.name)) {
+		const yearDir = join(dir, entry.name);
+		for (const monthEntry of readdirSync(yearDir, { withFileTypes: true })) if (monthEntry.isDirectory() && /^\d{2}$/.test(monthEntry.name)) {
+			const monthDir = join(yearDir, monthEntry.name);
+			for (const noteEntry of readdirSync(monthDir, { withFileTypes: true })) if (noteEntry.isFile() && noteEntry.name.endsWith(".md")) results.push(noteEntry.name);
+		}
+	}
+	return results;
+}
+function performScan(db) {
+	const result = {
+		projectsScanned: 0,
+		projectsNew: 0,
+		projectsUpdated: 0,
+		sessionsScanned: 0,
+		sessionsNew: 0,
+		skipped: []
+	};
+	if (!existsSync(CLAUDE_PROJECTS_DIR$1)) throw new Error(`Claude projects directory not found: ${CLAUDE_PROJECTS_DIR$1}`);
+	const entries = readdirSync(CLAUDE_PROJECTS_DIR$1).filter((name) => {
+		return statSync(join(CLAUDE_PROJECTS_DIR$1, name)).isDirectory();
+	});
+	const lookupMap = buildEncodedDirMap();
+	const clcMap = buildClcDirMap();
+	for (const encodedDir of entries) {
+		let rootPath = decodeEncodedDir(encodedDir, lookupMap);
+		if (!existsSync(rootPath) && clcMap.has(encodedDir)) {
+			const clcPath = clcMap.get(encodedDir);
+			if (existsSync(clcPath)) rootPath = clcPath;
+		}
+		if (!existsSync(rootPath)) {
+			result.skipped.push(`${encodedDir} (decoded: ${rootPath} — path not found on disk)`);
+			result.projectsScanned++;
+			continue;
+		}
+		rootPath = canonicalPath(rootPath);
+		const slug = slugify(basename(rootPath) || encodedDir);
+		const { id, isNew } = upsertProject(db, slug, rootPath, encodedDir);
+		result.projectsScanned++;
+		if (isNew) result.projectsNew++;
+		else result.projectsUpdated++;
+		try {
+			ensurePaiMarker(rootPath, slug);
+		} catch {}
+		const claudeNotesDir = join(CLAUDE_PROJECTS_DIR$1, encodedDir, "Notes");
+		if (existsSync(claudeNotesDir)) {
+			if (claudeNotesDir !== join(rootPath, "Notes")) db.prepare("UPDATE projects SET claude_notes_dir = ?, updated_at = ? WHERE id = ?").run(claudeNotesDir, Date.now(), id);
+		}
+		if (!existsSync(claudeNotesDir)) continue;
+		const noteFiles = findNoteFiles(claudeNotesDir);
+		for (const filename of noteFiles) {
+			const parsed = parseSessionFilename(filename);
+			if (!parsed) continue;
+			result.sessionsScanned++;
+			if (upsertSession(db, id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
+		}
+	}
+	{
+		const activeProjects = db.prepare("SELECT id, slug, root_path FROM projects WHERE status = 'active'").all();
+		for (const project of activeProjects) {
+			const notesDir = join(project.root_path, "Notes");
+			if (!existsSync(notesDir)) continue;
+			let files;
+			try {
+				files = findNoteFiles(notesDir);
+			} catch {
+				continue;
+			}
+			for (const filename of files) {
+				const parsed = parseSessionFilename(filename);
+				if (!parsed) continue;
+				result.sessionsScanned++;
+				if (upsertSession(db, project.id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
+			}
+		}
+	}
+	const config = loadScanConfig();
+	if (config.scan_dirs.length) for (const rawDir of config.scan_dirs) {
+		const scanDir = resolveHome(rawDir);
+		if (!existsSync(scanDir)) {
+			result.skipped.push(`${rawDir} (configured scan_dir not found)`);
+			continue;
+		}
+		const children = readdirSync(scanDir).filter((name) => {
+			if (name.startsWith(".")) return false;
+			const full = join(scanDir, name);
+			try {
+				return statSync(full).isDirectory();
+			} catch {
+				return false;
+			}
+		});
+		for (const child of children) {
+			const childPath = canonicalPath(join(scanDir, child));
+			const childSlug = slugify(child);
+			const childEncoded = encodeDir(childPath);
+			const existing = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(childPath);
+			if (existing) {
+				result.projectsScanned++;
+				result.projectsUpdated++;
+				try {
+					ensurePaiMarker(childPath, childSlug);
+				} catch {}
+				const notesDir = join(childPath, "Notes");
+				if (existsSync(notesDir)) {
+					const noteFiles = readdirSync(notesDir).filter((f) => f.endsWith(".md"));
+					for (const filename of noteFiles) {
+						const parsed = parseSessionFilename(filename);
+						if (!parsed) continue;
+						result.sessionsScanned++;
+						if (upsertSession(db, existing.id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
+					}
+				}
+				continue;
+			}
+			const { id, isNew } = upsertProject(db, childSlug, childPath, childEncoded);
+			result.projectsScanned++;
+			if (isNew) result.projectsNew++;
+			else result.projectsUpdated++;
+			try {
+				ensurePaiMarker(childPath, childSlug);
+			} catch {}
+			const notesDir = join(childPath, "Notes");
+			if (existsSync(notesDir)) {
+				const noteFiles = readdirSync(notesDir).filter((f) => f.endsWith(".md"));
+				for (const filename of noteFiles) {
+					const parsed = parseSessionFilename(filename);
+					if (!parsed) continue;
+					result.sessionsScanned++;
+					if (upsertSession(db, id, parsed.number, parsed.date, parsed.slug, parsed.title, parsed.filename)) result.sessionsNew++;
+				}
+			}
+		}
+	}
+	if (config.scan_dirs.length) {
+		const markers = discoverPaiMarkers(config.scan_dirs.map(resolveHome).filter(existsSync));
+		for (const marker of markers) {
+			const registeredRow = db.prepare("SELECT id, root_path, slug, encoded_dir FROM projects WHERE slug = ?").get(marker.slug);
+			if (!registeredRow) continue;
+			const markerRoot = canonicalPath(marker.projectRoot);
+			if (registeredRow.root_path !== markerRoot) {
+				const newEncoded = encodeDir(markerRoot);
+				const now4 = Date.now();
+				const encodedOwner = db.prepare("SELECT id FROM projects WHERE encoded_dir = ?").get(newEncoded);
+				const pathOwner = db.prepare("SELECT id FROM projects WHERE root_path = ?").get(markerRoot);
+				const encodedSafe = !encodedOwner || encodedOwner.id === registeredRow.id;
+				const pathSafe = !pathOwner || pathOwner.id === registeredRow.id;
+				const derivedResolves = transcriptFiles(join(claudeProjectsDir(), newEncoded)).length > 0;
+				const currentResolves = Boolean(registeredRow.encoded_dir) && transcriptFiles(join(claudeProjectsDir(), registeredRow.encoded_dir)).length > 0;
+				if (encodedSafe && pathSafe && (derivedResolves || !currentResolves)) db.prepare("UPDATE projects SET root_path = ?, encoded_dir = ?, updated_at = ? WHERE id = ?").run(markerRoot, newEncoded, now4, registeredRow.id);
+				else if (pathSafe) db.prepare("UPDATE projects SET root_path = ?, updated_at = ? WHERE id = ?").run(markerRoot, now4, registeredRow.id);
+			}
+		}
+	}
+	{
+		const stale = db.prepare("SELECT id, slug, root_path FROM projects WHERE display_name = slug AND root_path IS NOT NULL AND root_path != ''").all();
+		for (const row of stale) {
+			const name = basename(row.root_path);
+			if (name && name !== row.slug) db.prepare("UPDATE projects SET display_name = ?, updated_at = ? WHERE id = ?").run(name, Date.now(), row.id);
+		}
+	}
+	return result;
+}
+/**
+* Run the registry scan CLI command.
+*
+* @param opts.quick  When true, skips verbose output (same scan, less noise).
+*                    The underlying scan is always incremental via upsert —
+*                    this flag exists for hook/daemon-triggered invocations that
+*                    want minimal log output.
+*/
+function cmdScan(db, opts = {}) {
+	const config = loadScanConfig();
+	if (!opts.quick) {
+		console.log(dim("Scanning ~/.claude/projects/ ..."));
+		if (config.scan_dirs.length) console.log(dim(`Scanning ${config.scan_dirs.length} extra dir(s): ${config.scan_dirs.join(", ")}`));
+		console.log(dim("Scanning project-root Notes/ directories ..."));
+	}
+	let result;
+	try {
+		result = performScan(db);
+	} catch (e) {
+		console.error(err(String(e)));
+		process.exitCode = 1;
+		return;
+	}
+	if (!opts.quick) {
+		console.log(ok(`Scanned ${bold(String(result.projectsScanned))} projects, ${bold(String(result.sessionsScanned))} session notes.`));
+		console.log(dim(`  Projects: ${result.projectsNew} new, ${result.projectsUpdated} updated`));
+		console.log(dim(`  Sessions: ${result.sessionsNew} new`));
+		if (result.skipped.length) {
+			console.log();
+			console.log(warn(`  ${result.skipped.length} project(s) skipped (path not found on disk):`));
+			for (const s of result.skipped.slice(0, 10)) console.log(dim(`    ${s}`));
+			if (result.skipped.length > 10) console.log(dim(`    ... and ${result.skipped.length - 10} more`));
+		}
+	} else process.stderr.write(`[registry-scan] ${result.projectsScanned} projects, ${result.sessionsScanned} sessions (${result.projectsNew}+${result.sessionsNew} new).\n`);
+}
+
+//#endregion
+//#region src/hooks/ts/lib/pai-paths.ts
+/**
+* PAI Path Resolution - Single Source of Truth
+*
+* This module provides consistent path resolution across all PAI hooks.
+*
+* Two different things live here, and they must not be confused:
+*
+* - ADAPTER_DIR (~/.claude by default) is the Claude Code harness adapter —
+*   fixed, hardcoded paths the harness itself loads from (Hooks/, Skills/,
+*   Agents/, Commands/, settings.json, statusline-command.sh,
+*   tab-color-command.sh). It is harness-specific: a future harness would
+*   need its own adapter directory with its own conventions.
+* - PAI_HOME (~/.claude/pai by default — see ../../../config/pai-home.ts) is
+*   where PAI's own state lives: everything hooks WRITE (History/,
+*   agent-sessions.json, session-routing.json, ...) resolves there, with a
+*   fallback to the pre-2026-09-19 ADAPTER_DIR location and a one-time
+*   stderr notice, exactly like every other PAI_HOME file.
+*
+* ALSO loads .env file from ADAPTER_DIR so all hooks get environment
+* variables without relying on Claude Code's settings.json injection.
+*
+* Usage in hooks:
+*   import { ADAPTER_DIR, HOOKS_DIR, SKILLS_DIR, historyDir } from './lib/pai-paths';
+*/
+/**
+* Load .env file and inject into process.env
+* Must run BEFORE ADAPTER_DIR resolution so .env can set ADAPTER_DIR/PAI_DIR if needed
+*/
+function loadEnvFile() {
+	const possiblePaths = [resolve$1(process.env.ADAPTER_DIR || process.env.PAI_DIR || "", ".env"), resolve$1(homedir$1(), ".claude", ".env")];
+	for (const envPath of possiblePaths) if (existsSync$1(envPath)) try {
+		const content = readFileSync$1(envPath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex > 0) {
+				const key = trimmed.substring(0, eqIndex).trim();
+				let value = trimmed.substring(eqIndex + 1).trim();
+				if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+				value = value.replace(/\$HOME/g, homedir$1());
+				value = value.replace(/^~(?=\/|$)/, homedir$1());
+				if (process.env[key] === void 0) process.env[key] = value;
+			}
+		}
+		break;
+	} catch {}
+}
+loadEnvFile();
+function defaultAdapterDir() {
+	return resolve$1(homedir$1(), ".claude");
+}
+/**
+* Never print when stdout/stderr is a data channel, not a human: hook
+* bundles and worker-status-line.mjs set PAI_QUIET_NOTICES=1 via their
+* esbuild banner (scripts/build-hooks.mjs), and a `pai worker run
+* --output-format json` invocation is detected directly off argv since its
+* env can't be set before this module's static imports resolve.
+*/
+function suppressDeprecationNotices() {
+	if (process.env.PAI_QUIET_NOTICES === "1") return true;
+	const idx = process.argv.indexOf("--output-format");
+	return idx !== -1 && process.argv[idx + 1] === "json";
+}
+/**
+* At most once per process — a `globalThis` flag rather than a module-level
+* `let` because hooks and the CLI can end up with more than one instance of
+* this module loaded into the same process (separate bundles), each with its
+* own module scope; only a property on the shared global survives that.
+*/
+function warnPaiDirDeprecatedOnce(message) {
+	const g = globalThis;
+	if (g.__paiDirNoticePrinted || suppressDeprecationNotices()) return;
+	g.__paiDirNoticePrinted = true;
+	process.stderr.write(`pai: ${message}\n`);
+}
+/**
+* Smart ADAPTER_DIR detection with fallback
+* Priority:
+* 1. ADAPTER_DIR environment variable (if set) — warns once if PAI_DIR is
+*    ALSO set and resolves to a different path (naming both).
+* 2. PAI_DIR environment variable (deprecated alias, one release) — warns
+*    once only when it differs from the default adapter root; PAI_DIR set to
+*    the same value as the default is the operator's current, correct
+*    setting and stays silent.
+* 3. ~/.claude (standard location)
+*/
+function resolveAdapterDir() {
+	if (process.env.ADAPTER_DIR) {
+		const adapterDir = resolve$1(process.env.ADAPTER_DIR);
+		if (process.env.PAI_DIR) {
+			const paiDir = resolve$1(process.env.PAI_DIR);
+			if (paiDir !== adapterDir) warnPaiDirDeprecatedOnce(`ADAPTER_DIR (${adapterDir}) and PAI_DIR (${paiDir}) are both set and differ — ADAPTER_DIR wins. PAI_DIR still works for one release.`);
+		}
+		return adapterDir;
+	}
+	if (process.env.PAI_DIR) {
+		const paiDir = resolve$1(process.env.PAI_DIR);
+		if (paiDir !== defaultAdapterDir()) warnPaiDirDeprecatedOnce("PAI_DIR is deprecated — use ADAPTER_DIR for the harness adapter root (~/.claude). PAI_DIR still works for one release.");
+		return paiDir;
+	}
+	return defaultAdapterDir();
+}
+/** The Claude Code harness adapter root — NOT PAI's state home. See module doc above. */
+const ADAPTER_DIR = resolveAdapterDir();
+/**
+* Adapter directories — fixed paths the Claude Code harness itself loads
+* from. These stay under ADAPTER_DIR; they are not PAI state.
+*/
+const HOOKS_DIR = join$1(ADAPTER_DIR, "Hooks");
+const SKILLS_DIR = join$1(ADAPTER_DIR, "Skills");
+const AGENTS_DIR = join$1(ADAPTER_DIR, "Agents");
+const COMMANDS_DIR = join$1(ADAPTER_DIR, "Commands");
+/**
+* Validate PAI directory structure on first import
+* This fails fast with a clear error if PAI is misconfigured
+*/
+function validatePAIStructure() {
+	if (!existsSync$1(ADAPTER_DIR)) {
+		console.error(`ADAPTER_DIR does not exist: ${ADAPTER_DIR}`);
+		console.error(`   Expected ~/.claude or set ADAPTER_DIR environment variable`);
+		process.exit(1);
+	}
+	if (!existsSync$1(HOOKS_DIR)) {
+		console.error(`PAI hooks directory not found: ${HOOKS_DIR}`);
+		console.error(`   Your ADAPTER_DIR may be misconfigured`);
+		console.error(`   Current ADAPTER_DIR: ${ADAPTER_DIR}`);
+		process.exit(1);
+	}
+}
+validatePAIStructure();
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/paths.ts
+/**
+* Path utilities — encoding, Notes/Sessions directory discovery and creation.
+*/
+const PROJECTS_DIR = join$1(ADAPTER_DIR, "projects");
+/**
+* Encode a path the same way Claude Code does:
+* - Replace / with -
+* - Replace . with -
+* - Replace space with -
+*/
+function encodePath(path) {
+	return path.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+}
+/** Get the project directory for a given working directory. */
+function getProjectDir(cwd) {
+	return join$1(PROJECTS_DIR, encodePath(cwd));
+}
+/** Get the Notes directory for a project (central location). */
+function getNotesDir(cwd) {
+	return join$1(getProjectDir(cwd), "Notes");
+}
+/**
+* Find Notes directory — checks local first, falls back to central.
+* Does NOT create the directory.
+*/
+function findNotesDir$1(cwd) {
+	if (basename$1(cwd).toLowerCase() === "notes" && existsSync$1(cwd)) return {
+		path: cwd,
+		isLocal: true
+	};
+	const localPaths = [
+		join$1(cwd, "Notes"),
+		join$1(cwd, "notes"),
+		join$1(cwd, ".claude", "Notes")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return {
+		path,
+		isLocal: true
+	};
+	return {
+		path: getNotesDir(cwd),
+		isLocal: false
+	};
+}
+/** Get the sessions/ directory from a project directory path. */
+function getSessionsDirFromProjectDir(projectDir) {
+	return join$1(projectDir, "sessions");
+}
+/** Ensure the sessions/ directory exists (from project dir path). */
+function ensureSessionsDirFromProjectDir(projectDir) {
+	const sessionsDir = getSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(sessionsDir)) {
+		mkdirSync$1(sessionsDir, { recursive: true });
+		console.error(`Created sessions directory: ${sessionsDir}`);
+	}
+	return sessionsDir;
+}
+/**
+* Publish every project-root .jsonl into sessions/ as well, WITHOUT removing it.
+*
+* This used to renameSync, and that is how PAI destroyed its users' sessions.
+*
+* `claude --resume <uuid>` finds a transcript only at the project root. Move it
+* into sessions/ and the session becomes permanently unresumable — measured
+* 2026-08-04: `claude --resume b3462801` (867 KB of real work, sessions/ only)
+* answers "No conversation found with session ID", while a top-level id is found
+* fine. Nothing warned; the id still looked valid everywhere PAI displayed it.
+*
+* The damage was not occasional. This ran from a UserPromptSubmit hook excluding
+* only the CURRENT session, so every prompt anyone typed unresumed every other
+* session in the project. One PAI project measured 1 transcript at top level
+* against 52 underneath. Among the casualties was 046bb712 — the exact id PAI's
+* own handover tells the user to resume.
+*
+* A hardlink satisfies both sides, which is why this is a two-line fix rather
+* than a redesign: the archive genuinely has consumers that read sessions/
+* (session-summary-worker, registry/moved, session/autosave), and `--resume`
+* needs the root path. One inode, two names, no copy, no window where the file
+* is missing from either place.
+*
+* Never unlink the source. Tidying up another tool's store was the whole
+* mistake; a stale duplicate is free, a lost session is not. Every caller of
+* `transcriptFiles()` was checked before choosing this — they all test emptiness
+* (`.length > 0`), never count, so the duplicate cannot skew a project's stats.
+*
+* `excludeFile` keeps a hook from archiving the transcript it is itself watching
+* being written. It is not a "finished sessions only" guard and must not be read
+* as one: it excludes exactly one file, the caller's own, so with two sessions
+* live in one project each still archives the other mid-turn. A consumer that
+* needs "finished only" has to enforce that itself — this function cannot know
+* what is live.
+*
+* Returns the number of files newly archived.
+*/
+function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
+	const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(projectDir)) return 0;
+	const files = readdirSync$1(projectDir);
+	let archivedCount = 0;
+	for (const file of files) {
+		if (!file.endsWith(".jsonl") || file === excludeFile) continue;
+		const sourcePath = join$1(projectDir, file);
+		const destPath = join$1(sessionsDir, file);
+		if (existsSync$1(destPath)) continue;
+		try {
+			linkSync$1(sourcePath, destPath);
+			if (!silent) console.error(`Archived ${file} → sessions/ (still resumable)`);
+			archivedCount++;
+		} catch (error) {
+			try {
+				copyFileSync$1(sourcePath, destPath);
+				if (!silent) console.error(`Copied ${file} → sessions/ (hardlink unavailable)`);
+				archivedCount++;
+			} catch {
+				if (!silent) console.error(`Could not archive ${file}: ${error}`);
+			}
+		}
+	}
+	return archivedCount;
+}
+/** Find TODO.md — check local first, fallback to central. */
+function findTodoPath(cwd) {
+	const localPaths = [
+		join$1(cwd, "TODO.md"),
+		join$1(cwd, "notes", "TODO.md"),
+		join$1(cwd, "Notes", "TODO.md"),
+		join$1(cwd, ".claude", "TODO.md")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return path;
+	return join$1(getNotesDir(cwd), "TODO.md");
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/session-notes.ts
+/**
+* Session note creation, editing, checkpointing, renaming, and finalization.
+*/
+/** Get or create the YYYY/MM subdirectory for the current month inside notesDir. */
+function getMonthDir(notesDir) {
+	const now = /* @__PURE__ */ new Date();
+	const monthDir = join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0"));
+	if (!existsSync$1(monthDir)) mkdirSync$1(monthDir, { recursive: true });
+	return monthDir;
+}
+/**
+* Get the next note number (4-digit format: 0001, 0002, etc.).
+* Numbers are scoped per YYYY/MM directory.
+*/
+function getNextNoteNumber(notesDir) {
+	const files = readdirSync$1(getMonthDir(notesDir)).filter((f) => f.match(/^\d{3,4}[\s_-]/)).sort();
+	if (files.length === 0) return "0001";
+	let maxNumber = 0;
+	for (const file of files) {
+		const digitMatch = file.match(/^(\d+)/);
+		if (digitMatch) {
+			const num = parseInt(digitMatch[1], 10);
+			if (num > maxNumber) maxNumber = num;
+		}
+	}
+	return String(maxNumber + 1).padStart(4, "0");
+}
+/**
+* Get the current (latest) note file path, or null if none exists.
+* Searches current month → previous month → flat notesDir (legacy).
+*/
+function getCurrentNotePath(notesDir) {
+	if (!existsSync$1(notesDir)) return null;
+	const findLatestIn = (dir) => {
+		if (!existsSync$1(dir)) return null;
+		const files = readdirSync$1(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] || "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] || "0", 10);
+		});
+		if (files.length === 0) return null;
+		return join$1(dir, files[files.length - 1]);
+	};
+	const now = /* @__PURE__ */ new Date();
+	const found = findLatestIn(join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (found) return found;
+	const prevDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findLatestIn(join$1(notesDir, String(prevDate.getFullYear()), String(prevDate.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findLatestIn(notesDir);
+}
+/**
+* Create a new session note.
+* Format: "NNNN - YYYY-MM-DD - New Session.md" filed into YYYY/MM subdirectory.
+* Claude MUST rename at session end with a meaningful description.
+*/
+function createSessionNote(notesDir, description) {
+	const noteNumber = getNextNoteNumber(notesDir);
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const monthDir = getMonthDir(notesDir);
+	const filename = `${noteNumber} - ${date} - New Session.md`;
+	const filepath = join$1(monthDir, filename);
+	writeFileSync$1(filepath, `# Session ${noteNumber}: ${description}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+<!-- PAI will add completed work here during session -->
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`);
+	console.error(`Created session note: ${filename}`);
+	return filepath;
+}
+/** Append a checkpoint to the current session note. */
+function appendCheckpoint(notePath, checkpoint) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found, recreating: ${notePath}`);
+		try {
+			const parentDir = join$1(notePath, "..");
+			if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+			const noteFilename = basename$1(notePath);
+			const numberMatch = noteFilename.match(/^(\d+)/);
+			writeFileSync$1(notePath, `# Session ${numberMatch ? numberMatch[1] : "0000"}: Recovered\n\n**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}\n**Status:** In Progress\n\n---\n\n## Work Done\n\n<!-- PAI will add completed work here during session -->\n\n---\n\n## Next Steps\n\n<!-- To be filled at session end -->\n\n---\n\n**Tags:** #Session\n`);
+			console.error(`Recreated session note: ${noteFilename}`);
+		} catch (err) {
+			console.error(`Failed to recreate note: ${err}`);
+			return;
+		}
+	}
+	const content = readFileSync$1(notePath, "utf-8");
+	const checkpointText = `\n### Checkpoint ${(/* @__PURE__ */ new Date()).toISOString()}\n\n${checkpoint}\n`;
+	const nextStepsIndex = content.indexOf("## Next Steps");
+	writeFileSync$1(notePath, nextStepsIndex !== -1 ? content.substring(0, nextStepsIndex) + checkpointText + content.substring(nextStepsIndex) : content + checkpointText);
+	console.error(`Checkpoint added to: ${basename$1(notePath)}`);
+}
+/** Add work items to the "Work Done" section of a session note. */
+function addWorkToSessionNote(notePath, workItems, sectionTitle) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	let workText = "";
+	if (sectionTitle) workText += `\n### ${sectionTitle}\n\n`;
+	for (const item of workItems) {
+		const checkbox = item.completed !== false ? "[x]" : "[ ]";
+		workText += `- ${checkbox} **${item.title}**\n`;
+		if (item.details && item.details.length > 0) for (const detail of item.details) workText += `  - ${detail}\n`;
+	}
+	const workDoneMatch = content.match(/## Work Done\n\n(<!-- .*? -->)?/);
+	if (workDoneMatch) {
+		const insertPoint = content.indexOf(workDoneMatch[0]) + workDoneMatch[0].length;
+		content = content.substring(0, insertPoint) + workText + content.substring(insertPoint);
+	} else {
+		const nextStepsIndex = content.indexOf("## Next Steps");
+		if (nextStepsIndex !== -1) content = content.substring(0, nextStepsIndex) + workText + "\n" + content.substring(nextStepsIndex);
+	}
+	writeFileSync$1(notePath, content);
+	console.error(`Added ${workItems.length} work item(s) to: ${basename$1(notePath)}`);
+}
+/** Sanitize a string for use in a filename. */
+function sanitizeForFilename(str) {
+	return str.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+/**
+* Return true if the candidate string should be rejected as a meaningful name.
+* Rejects file paths, shebangs, timestamps, system noise, XML tags, hashes, etc.
+*/
+function isMeaninglessCandidate(text) {
+	const t = text.trim();
+	if (!t) return true;
+	if (t.length < 5) return true;
+	if (t.startsWith("/") || t.startsWith("~")) return true;
+	if (t.startsWith("#!")) return true;
+	if (t.includes("[object Object]")) return true;
+	if (/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]+)?$/.test(t)) return true;
+	if (/^\d{1,2}:\d{2}(:\d{2})?(\s*(AM|PM))?$/i.test(t)) return true;
+	if (/^<[a-z-]+[\s/>]/i.test(t)) return true;
+	if (/^[0-9a-f]{10,}$/i.test(t)) return true;
+	if (/^Exit code \d+/i.test(t)) return true;
+	if (/^Error:/i.test(t)) return true;
+	if (/^This session is being continued/i.test(t)) return true;
+	if (/^\(Bash completed/i.test(t)) return true;
+	if (/^Task Notification$/i.test(t)) return true;
+	if (/^New Session$/i.test(t)) return true;
+	if (/^Recovered Session$/i.test(t)) return true;
+	if (/^Continued Session$/i.test(t)) return true;
+	if (/^Untitled Session$/i.test(t)) return true;
+	if (/^Context Compression$/i.test(t)) return true;
+	if (/^[A-Fa-f0-9]{8,}\s+Output$/i.test(t)) return true;
+	return false;
+}
+/**
+* Extract a meaningful name from session note content and summary.
+* Looks at Work Done section headers, bold text, and summary.
+*/
+function extractMeaningfulName(noteContent, summary) {
+	const workDoneMatch = noteContent.match(/## Work Done\n\n([\s\S]*?)(?=\n---|\n## Next)/);
+	if (workDoneMatch) {
+		const workDoneSection = workDoneMatch[1];
+		const subheadings = workDoneSection.match(/### ([^\n]+)/g);
+		if (subheadings && subheadings.length > 0) {
+			const firstHeading = subheadings[0].replace("### ", "").trim();
+			if (!isMeaninglessCandidate(firstHeading) && firstHeading.length > 5 && firstHeading.length < 60) return sanitizeForFilename(firstHeading);
+		}
+		const boldMatches = workDoneSection.match(/\*\*([^*]+)\*\*/g);
+		if (boldMatches && boldMatches.length > 0) {
+			const firstBold = boldMatches[0].replace(/\*\*/g, "").trim();
+			if (!isMeaninglessCandidate(firstBold) && firstBold.length > 3 && firstBold.length < 50) return sanitizeForFilename(firstBold);
+		}
+		const numberedItems = workDoneSection.match(/^\d+\.\s+\*\*([^*]+)\*\*/m);
+		if (numberedItems && !isMeaninglessCandidate(numberedItems[1])) return sanitizeForFilename(numberedItems[1]);
+	}
+	if (summary && summary.length > 5 && summary !== "Session completed." && !isMeaninglessCandidate(summary)) {
+		const cleanSummary = summary.replace(/[^\w\s-]/g, " ").trim().split(/\s+/).slice(0, 5).join(" ");
+		if (cleanSummary.length > 3 && !isMeaninglessCandidate(cleanSummary)) return sanitizeForFilename(cleanSummary);
+	}
+	return "";
+}
+/**
+* Rename a session note with a meaningful name.
+* Always uses "NNNN - YYYY-MM-DD - Description.md" format.
+* Returns the new path, or original path if rename fails.
+*/
+function renameSessionNote(notePath, meaningfulName) {
+	if (!meaningfulName || !existsSync$1(notePath)) return notePath;
+	const dir = join$1(notePath, "..");
+	const oldFilename = basename$1(notePath);
+	const correctMatch = oldFilename.match(/^(\d{3,4}) - (\d{4}-\d{2}-\d{2}) - .*\.md$/);
+	const legacyMatch = oldFilename.match(/^(\d{3,4})_(\d{4}-\d{2}-\d{2})_.*\.md$/);
+	const match = correctMatch || legacyMatch;
+	if (!match) return notePath;
+	const [, noteNumber, date] = match;
+	const titleCaseName = meaningfulName.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
+	const newFilename = `${noteNumber.padStart(4, "0")} - ${date} - ${titleCaseName}.md`;
+	const newPath = join$1(dir, newFilename);
+	if (newFilename === oldFilename) return notePath;
+	try {
+		renameSync$1(notePath, newPath);
+		console.error(`Renamed note: ${oldFilename} → ${newFilename}`);
+		return newPath;
+	} catch (error) {
+		console.error(`Could not rename note: ${error}`);
+		return notePath;
+	}
+}
+/**
+* Finalize session note — mark as complete, add summary, rename with meaningful name.
+* IDEMPOTENT: subsequent calls are no-ops if already finalized.
+* Returns the final path (may be renamed).
+*/
+function finalizeSessionNote(notePath, summary) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return notePath;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	if (content.includes("**Status:** Completed")) {
+		console.error(`Note already finalized: ${basename$1(notePath)}`);
+		return notePath;
+	}
+	content = content.replace("**Status:** In Progress", "**Status:** Completed");
+	if (!content.includes("**Completed:**")) {
+		const completionTime = (/* @__PURE__ */ new Date()).toISOString();
+		content = content.replace("---\n\n## Work Done", `**Completed:** ${completionTime}\n\n---\n\n## Work Done`);
+	}
+	const nextStepsMatch = content.match(/## Next Steps\n\n(<!-- .*? -->)/);
+	if (nextStepsMatch) content = content.replace(nextStepsMatch[0], `## Next Steps\n\n${summary || "Session completed."}`);
+	writeFileSync$1(notePath, content);
+	console.error(`Session note finalized: ${basename$1(notePath)}`);
+	const meaningfulName = extractMeaningfulName(content, summary);
+	if (meaningfulName) return renameSessionNote(notePath, meaningfulName);
+	return notePath;
+}
+
+//#endregion
+//#region src/session/checkpoint-block.ts
+/**
+* Shared "## Continue" checkpoint logic for a project's TODO.md.
+*
+* WHY THIS MODULE EXISTS
+* ----------------------
+* Before this, `pause.ts` and `handover.ts` each carried their own copy of
+* findProjectTodo / stripContinueSection / block-builder. Both wrote the same
+* fixed four-line block, and both stripped any existing ## Continue section
+* unconditionally. The consequence was that a rich, model-authored checkpoint
+* could never survive:
+*
+*   1. `pai pause` had no way to accept a body, so the model printed its
+*      checkpoint to the terminal and it was lost.
+*   2. Even if a body had been written by hand, the session-stop hook runs
+*      `pai session handover` on every clean exit, which regenerated the
+*      generic block and erased it.
+*
+* So there are two jobs here:
+*
+*   - AUTHORED writes (`pai pause --body-file`) carry the model's markdown
+*     verbatim, wrapped in explicit start/end markers.
+*   - AUTO writes (hooks) must never destroy an authored checkpoint belonging
+*     to the *same* session. They may replace a stale one left by an earlier
+*     session, otherwise TODO.md would show a checkpoint that no longer
+*     describes where the work stands.
+*
+* PARSING
+* -------
+* A rich body can legitimately contain `---` rules and `##` headings, which the
+* old heuristic scanner treated as section terminators. Authored blocks are
+* therefore delimited by an explicit HTML-comment pair; the legacy heuristic is
+* kept only as a fallback for blocks written before this change.
+*/
+/** Locations searched for a project TODO.md, in priority order. */
+const TODO_LOCATIONS = [
+	"Notes/TODO.md",
+	".claude/Notes/TODO.md",
+	"tasks/todo.md",
+	"TODO.md"
+];
+const MARKER_OPEN = "<!-- pai:checkpoint";
+const MARKER_CLOSE = "<!-- /pai:checkpoint -->";
+/**
+* Markers for a handover that has been superseded but not thrown away.
+*
+* Deliberately NOT `pai:checkpoint`: `locateContinue` scans for that marker and
+* for the `## Continue` heading, so an archived block written verbatim would be
+* found as the live section and rewritten in place of it. Archived entries are
+* inert by construction — different marker, no heading.
+*/
+const ARCHIVE_OPEN = "<!-- pai:archived-handover";
+const ARCHIVE_CLOSE = "<!-- /pai:archived-handover -->";
+const ARCHIVE_HEADING = "## Previous handovers";
+/**
+* How many superseded handovers TODO.md keeps.
+*
+* Enough that a handover survives a run of sessions that each end without
+* pausing, which is the sequence that destroyed one on 2026-08-04. Not
+* unbounded: TODO.md is read by a human at the top of every session, and a file
+* that grows without limit stops being read, which is its own kind of loss.
+*/
+const ARCHIVE_LIMIT = 5;
+const CONTINUE_HEADING = "## Continue";
+function findProjectTodo(rootPath) {
+	for (const rel of TODO_LOCATIONS) {
+		const full = join(rootPath, rel);
+		if (existsSync(full)) try {
+			return {
+				path: full,
+				content: readFileSync(full, "utf8")
+			};
+		} catch {}
+	}
+	return null;
+}
+/**
+* Resolve the TODO.md to write to, creating Notes/ if nothing exists yet.
+* Returns null only when the directory could not be created.
+*/
+function resolveTodoTarget(rootPath, opts = {}) {
+	const found = findProjectTodo(rootPath);
+	if (found) return found;
+	const notesDir = join(rootPath, "Notes");
+	if (opts.create !== false) try {
+		if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
+	} catch {
+		return null;
+	}
+	return {
+		path: join(notesDir, "TODO.md"),
+		content: ""
+	};
+}
+/**
+* Parse a `<!-- pai:checkpoint key="value" ... -->` marker line.
+* Returns null when the line is not a marker.
+*/
+function parseMarker(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith(MARKER_OPEN)) return null;
+	const attrs = {};
+	for (const m of trimmed.matchAll(/([a-zA-Z][\w-]*)="([^"]*)"/g)) attrs[m[1]] = m[2];
+	return {
+		authored: attrs.authored === "model" ? "model" : "auto",
+		session: attrs.session || void 0,
+		sessionId: attrs["session-id"] || void 0,
+		ts: attrs.ts || void 0
+	};
+}
+/**
+* Lines an auto-generated block is made of. Anything else in a section is
+* content somebody put there deliberately.
+*
+* The blockquote marker is optional on every pattern. These lines appear
+* quoted when the block builder emits them as its header, and unquoted when a
+* caller passes the same text as a BODY — which the session-stop hook does: it
+* builds `Working directory: ${cwd}` and hands it over as state. Matching only
+* the quoted form made such a body read as content, which is how a session
+* that did no work at all overwrote a real handover on 2026-08-04. A line that
+* merely restates the generated header is boilerplate wherever it sits.
+*/
+const BOILERPLATE_PATTERNS = [
+	/^##\s+Continue$/,
+	/^<!--\s*\/?pai:checkpoint/,
+	/^>?\s*\*\*Last session:\*\*/,
+	/^>?\s*\*\*Paused at:\*\*/,
+	/^>?\s*Working directory:/,
+	/^>?\s*Resume with:/,
+	/^>?\s*_No checkpoint body was recorded/,
+	/^-{3,}$/
+];
+/** A blank line, with or without a blockquote marker. */
+const BLANK_LINE = /^>?\s*$/;
+/**
+* True when a section contains nothing but generated header lines.
+*
+* This is the guard that stops an auto write from destroying content it did
+* not author. A session that hit the old clobbering bug may have worked around
+* it by hand — writing its state into a subsection underneath the generated
+* header lines, in an unmarked block. Those blocks predate the marker, so
+* authorship cannot be read off them; the only safe signal is whether anything
+* beyond boilerplate is present.
+*/
+function isBoilerplateOnly(lines) {
+	return lines.every((line) => {
+		const t = line.trim();
+		return BLANK_LINE.test(t) || BOILERPLATE_PATTERNS.some((re) => re.test(t));
+	});
+}
+/**
+* True when a checkpoint body says something the generated header does not.
+*
+* "Has a body" and "has something to say" are not the same question, and the
+* preservation rules care only about the second. An unattended writer that
+* emits a single line restating the working directory has produced a body by
+* any string test and a handover by none.
+*/
+function hasSubstance(body) {
+	const text = (body ?? "").trim();
+	if (!text) return false;
+	return !isBoilerplateOnly(text.split("\n"));
+}
+/**
+* Extract the non-boilerplate content of a section, or "" if there is none.
+*
+* Interior blank lines are kept. They are not decoration — in Markdown they
+* are what separates a paragraph from the table or list that follows, so
+* dropping them (as this did while it treated every blank line as boilerplate)
+* silently welds a checkpoint body into one unreadable run.
+*/
+function extractSectionContent(lines) {
+	const kept = [];
+	for (const line of lines) {
+		const t = line.trim();
+		if (BOILERPLATE_PATTERNS.some((re) => re.test(t))) continue;
+		kept.push(line);
+	}
+	return trimBlankEdges(collapseBlankRuns(kept)).join("\n");
+}
+/** Drop leading and trailing blank lines, leaving interior spacing alone. */
+function trimBlankEdges(lines) {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && BLANK_LINE.test(lines[start].trim())) start += 1;
+	while (end > start && BLANK_LINE.test(lines[end - 1].trim())) end -= 1;
+	return lines.slice(start, end);
+}
+/**
+* Collapse runs of blank lines to a single blank.
+*
+* Removing a boilerplate line leaves the blank that surrounded it behind, so
+* stripping the header can open a three-line gap in the middle of the body.
+* One blank line is all Markdown needs.
+*/
+function collapseBlankRuns(lines) {
+	const out = [];
+	let lastWasBlank = false;
+	for (const line of lines) {
+		const isBlank = BLANK_LINE.test(line.trim());
+		if (isBlank && lastWasBlank) continue;
+		out.push(line);
+		lastWasBlank = isBlank;
+	}
+	return out;
+}
+/**
+* Locate the existing ## Continue section.
+*
+* When the section carries an explicit marker pair, the close marker defines
+* the end — this is what lets a rich body contain `---` and `##` safely.
+* Otherwise the legacy heuristic applies: stop at the first `---` or the next
+* `##` heading.
+*/
+function locateContinue(content) {
+	const lines = content.split("\n");
+	const startIdx = lines.findIndex((l) => l.trim() === CONTINUE_HEADING);
+	if (startIdx === -1) return null;
+	let meta = null;
+	let markerIdx = -1;
+	for (let i = startIdx + 1; i < Math.min(startIdx + 6, lines.length); i++) {
+		const parsed = parseMarker(lines[i]);
+		if (parsed) {
+			meta = parsed;
+			markerIdx = i;
+			break;
+		}
+		if (lines[i].trim() !== "") break;
+	}
+	let endIdx = lines.length;
+	if (markerIdx !== -1) {
+		const closeIdx = lines.findIndex((l, i) => i > markerIdx && l.trim() === MARKER_CLOSE);
+		if (closeIdx !== -1) endIdx = closeIdx + 1;
+		else endIdx = heuristicEnd(lines, startIdx);
+	} else endIdx = heuristicEnd(lines, startIdx);
+	let trailingEnd = endIdx;
+	while (trailingEnd < lines.length && lines[trailingEnd].trim() === "") trailingEnd += 1;
+	if (trailingEnd < lines.length && lines[trailingEnd].trim() === "---") trailingEnd += 1;
+	else trailingEnd = endIdx;
+	return {
+		startIdx,
+		endIdx: trailingEnd,
+		meta,
+		lines: lines.slice(startIdx, trailingEnd)
+	};
+}
+/**
+* Legacy scanner for blocks written before checkpoint markers existed.
+*
+* Terminates on a horizontal rule or the next level-1 or level-2 heading. Note
+* the `(?!#)` — `###` is a *subsection* of `## Continue`, not a terminator. The
+* original scanner stopped at any run of `#`, which meant a `### Restored
+* state` subsection fell outside the section entirely and could not be seen,
+* let alone carried forward.
+*
+* `#{1,2}` rather than `##`, because matching only `##` did not stop at an H1
+* and therefore ATE IT. A TODO.md whose `## Continue` block precedes its
+* `# TODO` title had the title absorbed into the section and destroyed on the
+* next regenerate — reported independently by three sessions on 2026-08-03,
+* one of which lost it three times and recovered from git each time.
+*
+* An H1 is a document-level heading. It can never be part of a `## Continue`
+* section, so treating it as a terminator is not a heuristic improvement but a
+* structural fact.
+*/
+function heuristicEnd(lines, startIdx) {
+	for (let i = startIdx + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed === "---" || /^#{1,2}(?!#)/.test(trimmed) && trimmed !== CONTINUE_HEADING) return i;
+	}
+	return lines.length;
+}
+/** Remove the ## Continue section, returning the remainder of the document. */
+function stripContinue(content) {
+	const found = locateContinue(content);
+	if (!found) return content;
+	const lines = content.split("\n");
+	const before = lines.slice(0, found.startIdx);
+	const after = lines.slice(found.endIdx);
+	while (after.length > 0 && after[0].trim() === "") after.shift();
+	return [...before, ...after].join("\n");
+}
+function escapeAttr(value) {
+	return value.replace(/"/g, "'");
+}
+function buildContinueBlock(opts) {
+	const ts = opts.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+	const attrs = [
+		`authored="${opts.authored}"`,
+		`session="${escapeAttr(opts.sessionLine)}"`,
+		opts.sessionId ? `session-id="${escapeAttr(opts.sessionId)}"` : null,
+		`ts="${ts}"`
+	].filter(Boolean).join(" ");
+	const header = [
+		`> **Last session:** ${opts.sessionLine}`,
+		`> **Paused at:** ${ts}`,
+		">",
+		`> Working directory: ${opts.cwd}`
+	];
+	if (opts.sessionId) header.push(">", `> Resume with: \`claude --resume ${opts.sessionId}\``);
+	const body = (opts.body ?? "").trim();
+	const parts = [
+		CONTINUE_HEADING,
+		"",
+		`${MARKER_OPEN} ${attrs} -->`,
+		"",
+		...header
+	];
+	if (body) parts.push("", body);
+	else parts.push(">", "> _No checkpoint body was recorded — see the latest session note._");
+	parts.push("", MARKER_CLOSE, "", "---", "");
+	return parts.join("\n");
+}
+/**
+* Write the ## Continue block, honouring the preservation rules.
+*
+* An AUTO write is unattended — it fires from the session-stop and pre-compact
+* hooks — so it operates under one governing rule: **never destroy content it
+* did not author.** Three cases follow from that:
+*
+*   1. An authored checkpoint for the SAME session is left untouched. The hooks
+*      fire after the model has already recorded the real state; overwriting it
+*      with metadata is the bug this module exists to fix.
+*
+*      "Same session" is decided by the Claude session UUID whenever both sides
+*      know it, and only falls back to the human-readable session line when one
+*      of them does not. The line is derived from the session note filename,
+*      and `session-stop.sh` *renames and renumbers that file* — via `session
+*      slug --apply` and `session cleanup --execute` — before it reaches the
+*      handover step. So the key the hook computes at exit is not the key the
+*      model wrote seconds earlier, and a filename-keyed comparison mismatches
+*      by construction. Observed live on 2026-08-01: notes renumbered twice
+*      within a single session. The UUID is the only identifier that holds
+*      still.
+*   2. An authored checkpoint from an EARLIER session is stale — TODO.md would
+*      otherwise keep pointing at the wrong session — so it is replaced. Its
+*      content is not lost: `pai pause` mirrors every authored body into the
+*      session note.
+*   3. An UNMARKED block predates the marker, so authorship cannot be read off
+*      it. If it is nothing but generated header lines it is replaced. If it
+*      carries anything else, that content was put there deliberately — quite
+*      possibly as a hand-rolled workaround for the very clobbering this fixes —
+*      and is carried forward into the new block rather than dropped.
+*
+* A MODEL write always replaces: the model is authoring the checkpoint, and a
+* newer one supersedes an older one.
+*/
+/**
+* Do an existing checkpoint and an incoming write describe the same session?
+*
+* The UUID is authoritative when both sides carry one: it is assigned by Claude
+* Code and never changes for the life of the session. The session line is a
+* derived, mutable label and is only consulted when there is no UUID to compare
+* — a checkpoint written before `--session-id` was threaded through, or an auto
+* write from a caller that was not given one.
+*/
+function isSameSession(meta, opts) {
+	if (meta.sessionId && opts.sessionId) return meta.sessionId === opts.sessionId;
+	return meta.session === opts.sessionLine;
+}
+/**
+* How long a model-authored checkpoint is protected from automated overwriting.
+*
+* Sized for the race, not for the session: the gap between a model writing its
+* checkpoint and a hook firing is seconds to minutes, and an hour covers even a
+* slow checkpoint on a loaded machine. Anything genuinely from an earlier
+* session is hours or days old and still falls through to case 2, which is what
+* keeps TODO.md from freezing on a checkpoint nobody will ever replace.
+*/
+const AUTHORED_GRACE_MS = 3600 * 1e3;
+/** Was this checkpoint written recently enough to still belong to the run in progress? */
+function isRecent(meta, now) {
+	if (!meta.ts) return false;
+	const then = Date.parse(meta.ts);
+	if (Number.isNaN(then)) return false;
+	const nowMs = now ? Date.parse(now) : Date.now();
+	if (Number.isNaN(nowMs)) return false;
+	return nowMs - then < AUTHORED_GRACE_MS;
+}
+/**
+* Turn a live checkpoint block into an inert archive entry.
+*
+* Two things have to go: the `## Continue` heading and the `pai:checkpoint`
+* marker. Both are what `locateContinue` looks for, so leaving either in place
+* would let a later write treat the archive as the live section — and the next
+* one after that would then archive the archive. Everything else is kept
+* verbatim, because the body is the whole reason this exists.
+*/
+function toArchiveEntry(lines, meta) {
+	const out = [];
+	const label = meta?.session ?? "Unknown session";
+	const stamp = meta?.ts ? ` — checkpointed ${meta.ts}` : "";
+	out.push(`${ARCHIVE_OPEN} session="${label}"${meta?.ts ? ` ts="${meta.ts}"` : ""} -->`);
+	out.push("");
+	out.push(`### ${label}${stamp}`);
+	out.push("");
+	for (const line of lines) {
+		if (line.trim() === CONTINUE_HEADING) continue;
+		if (line.trim().startsWith(MARKER_OPEN)) continue;
+		if (line.trim() === MARKER_CLOSE) continue;
+		if (line.trim() === "---") continue;
+		out.push(line);
+	}
+	while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
+	out.push("");
+	out.push(ARCHIVE_CLOSE);
+	return out;
+}
+/**
+* Put a superseded handover into the archive section, newest first.
+*
+* `rest` is the document with the Continue section already stripped. The
+* archive lives immediately below it so a reader meets the current handover
+* first and the previous ones directly after, rather than hunting for them at
+* the bottom of a file that also holds the project's open work.
+*/
+function archiveInto(rest, entry) {
+	const lines = rest.split("\n");
+	const headingIdx = lines.findIndex((l) => l.trim() === ARCHIVE_HEADING);
+	if (headingIdx === -1) return [
+		ARCHIVE_HEADING,
+		"",
+		...entry,
+		"",
+		"---",
+		"",
+		rest.trimStart()
+	].join("\n");
+	const before = lines.slice(0, headingIdx + 1);
+	const after = lines.slice(headingIdx + 1);
+	while (after.length > 0 && after[0].trim() === "") after.shift();
+	const merged = [
+		...entry,
+		"",
+		...after
+	];
+	const kept = [];
+	let seen = 0;
+	for (let i = 0; i < merged.length; i++) {
+		if (merged[i].trim().startsWith(ARCHIVE_OPEN)) {
+			seen += 1;
+			if (seen > ARCHIVE_LIMIT) {
+				while (i < merged.length && merged[i].trim() !== ARCHIVE_CLOSE) i++;
+				continue;
+			}
+		}
+		kept.push(merged[i]);
+	}
+	return [
+		...before,
+		"",
+		...kept
+	].join("\n");
+}
+function applyContinue(opts) {
+	const target = resolveTodoTarget(opts.rootPath, { create: !opts.dryRun });
+	if (!target) return {
+		action: "failed",
+		path: null,
+		block: buildContinueBlock(opts),
+		error: "Could not resolve or create a TODO.md target"
+	};
+	const existing = locateContinue(target.content);
+	let carriedForward = false;
+	let effectiveBody = opts.body;
+	let archiveEntry = null;
+	if (opts.authored === "auto" && existing) {
+		if (existing.meta?.authored === "model" && isSameSession(existing.meta, opts)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta
+		};
+		if (existing.meta && !hasSubstance(opts.body) && !isBoilerplateOnly(existing.lines)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta ?? void 0
+		};
+		if (existing.meta?.authored === "model" && isRecent(existing.meta, opts.timestamp) && !isBoilerplateOnly(existing.lines)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta
+		};
+		if (existing.meta?.authored === "model" && !isBoilerplateOnly(existing.lines) && !isSameSession(existing.meta, opts)) archiveEntry = toArchiveEntry(existing.lines, existing.meta);
+		if (!existing.meta && !isBoilerplateOnly(existing.lines)) {
+			const salvaged = extractSectionContent(existing.lines);
+			if (salvaged) {
+				effectiveBody = [
+					"_Carried forward from the previous checkpoint (author unknown — this",
+					"block predates checkpoint authorship markers):_",
+					"",
+					salvaged
+				].join("\n");
+				carriedForward = true;
+			}
+		}
+	}
+	const block = buildContinueBlock({
+		...opts,
+		body: effectiveBody
+	});
+	if (opts.dryRun) return {
+		action: "written",
+		path: target.path,
+		block,
+		carriedForward,
+		archived: !!archiveEntry
+	};
+	const rest = stripContinue(target.content).trimStart();
+	const newContent = block + (archiveEntry ? archiveInto(rest, archiveEntry) : rest);
+	const tmpPath = `${target.path}.continue.tmp`;
+	try {
+		writeFileSync(tmpPath, newContent, "utf8");
+		renameSync(tmpPath, target.path);
+	} catch (err) {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+		} catch {}
+		return {
+			action: "failed",
+			path: target.path,
+			block,
+			error: String(err)
+		};
+	}
+	return {
+		action: "written",
+		path: target.path,
+		block,
+		carriedForward,
+		archived: !!archiveEntry
+	};
+}
+/** ADAPTER_DIR (harness adapter root) — mirrors pai-paths.ts's resolveAdapterDir(),
+*  kept self-contained here to avoid importing pai-paths.ts's process.exit(1)
+*  validation side effect. PAI_DIR is the deprecated alias, same as there. */
+function getPaiDir() {
+	const envDir = process.env.ADAPTER_DIR || process.env.PAI_DIR;
+	if (envDir) try {
+		return realpathSync(envDir);
+	} catch {
+		return envDir;
+	}
+	return join(homedir(), ".claude");
+}
+/**
+* Find the notes directory for a project — local first, then the central
+* ~/.claude/projects/<encoded>/Notes fallback. Never creates.
+*/
+function findNotesDir(rootPath, encodedDir) {
+	for (const rel of [
+		"Notes",
+		"notes",
+		".claude/Notes"
+	]) {
+		const p = join(rootPath, rel);
+		if (existsSync(p)) return p;
+	}
+	const central = join(getPaiDir(), "projects", encodedDir, "Notes");
+	if (existsSync(central)) return central;
+	return null;
+}
+/**
+* Find the current (highest-numbered) session note: current month, then the
+* previous month, then a flat notesDir as legacy fallback.
+*/
+function findLatestNote(notesDir) {
+	const findIn = (dir) => {
+		if (!existsSync(dir)) return null;
+		let files;
+		try {
+			files = readdirSync(dir);
+		} catch {
+			return null;
+		}
+		const notes = files.filter((f) => /^\d{3,4}[\s_-].*\.md$/.test(f)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] ?? "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] ?? "0", 10);
+		});
+		return notes.length > 0 ? join(dir, notes[notes.length - 1]) : null;
+	};
+	const now = /* @__PURE__ */ new Date();
+	const current = findIn(join(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (current) return current;
+	const prev = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findIn(join(notesDir, String(prev.getFullYear()), String(prev.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findIn(notesDir);
+}
+/**
+* Append the checkpoint body to a session note.
+*
+* TODO.md's ## Continue is a single slot that every later checkpoint
+* overwrites. The session note is the durable record, so the body goes to both.
+* Idempotent per timestamp: re-running with the same stamp will not duplicate.
+*/
+function appendCheckpointToNote(notePath, body, timestamp) {
+	const heading = `## Pause Checkpoint — ${timestamp ?? (/* @__PURE__ */ new Date()).toISOString()}`;
+	let existing;
+	try {
+		existing = readFileSync(notePath, "utf8");
+	} catch (err) {
+		return {
+			appended: false,
+			error: String(err)
+		};
+	}
+	if (existing.includes(heading)) return { appended: false };
+	const block = `\n\n---\n\n${heading}\n\n${body.trim()}\n`;
+	const tmpPath = `${notePath}.checkpoint.tmp`;
+	try {
+		writeFileSync(tmpPath, existing.trimEnd() + block, "utf8");
+		renameSync(tmpPath, notePath);
+	} catch (err) {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+		} catch {}
+		return {
+			appended: false,
+			error: String(err)
+		};
+	}
+	return { appended: true };
+}
+/** Read a checkpoint body from a file, or from stdin when path is "-". */
+function readBodyFile(path) {
+	if (path === "-") return readFileSync(0, "utf8");
+	return readFileSync(path, "utf8");
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/todo.ts
+/**
+* TODO.md management — creation, task updates, checkpoints, and Continue section.
+*/
+/**
+* Ensure TODO.md exists. Creates it with default structure if missing.
+* Returns the path to the TODO.md file.
+*/
+function ensureTodoMd(cwd) {
+	const todoPath = findTodoPath(cwd);
+	if (!existsSync$1(todoPath)) {
+		const parentDir = join$1(todoPath, "..");
+		if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+		writeFileSync$1(todoPath, `# TODO
+
+## Current Session
+
+- [ ] (Tasks will be tracked here)
+
+## Backlog
+
+- [ ] (Future tasks)
+
+---
+
+*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`);
+		console.error(`Created TODO.md: ${todoPath}`);
+	}
+	return todoPath;
+}
+/**
+* The Claude Code session UUID, read off the transcript path.
+*
+* Claude Code names a transcript `<session-uuid>.jsonl`, so the hooks that
+* receive a transcript path are holding the session's identity without knowing
+* it. Both session-end writers had one available and neither used it.
+*
+* Shape-checked rather than trusted: only a UUID is returned, so a renamed,
+* archived or otherwise unexpected filename yields undefined and the caller
+* falls back to the session line rather than writing a `session-id` that
+* identifies nothing. A wrong id is worse than none — it would make two
+* different sessions compare equal.
+*/
+function sessionIdFromTranscript(transcriptPath) {
+	if (!transcriptPath) return void 0;
+	const base = basename$1(transcriptPath).replace(/\.jsonl$/, "");
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(base) ? base : void 0;
+}
+/**
+* Update the ## Continue section at the top of TODO.md.
+*
+* This is the unattended writer: the pre-compact hook and the daemon's
+* work-queue worker both come through here. It used to build its own block and
+* strip the existing section with `/## Continue\n[\s\S]*?\n---\n+/` — a
+* non-greedy match to the first `---`, which cuts a rich checkpoint in half at
+* the first horizontal rule inside its body and leaves the remainder orphaned
+* in the document.
+*
+* More importantly it was the writer that actually destroyed model-authored
+* checkpoints: `pai pause` wrote one, then this ran seconds later on session
+* end and replaced it with `Working directory: … Check the latest session note
+* for details.`
+*
+* It now delegates to the shared checkpoint module in "auto" mode, which means
+* it inherits the preservation rules rather than reimplementing them. Guarding
+* here rather than at each of the three call sites is deliberate: any future
+* caller inherits the behaviour without knowing it exists.
+*/
+function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
+	ensureTodoMd(cwd);
+	const result = applyContinue({
+		rootPath: cwd,
+		authored: "auto",
+		sessionLine: noteFilename.replace(/\.md$/, ""),
+		sessionId,
+		cwd,
+		body: state?.trim() || void 0
+	});
+	if (result.action === "preserved") {
+		console.error("TODO.md ## Continue left intact — authored checkpoint for this session");
+		return;
+	}
+	if (result.action === "failed") {
+		console.error(`TODO.md ## Continue update failed: ${result.error}`);
+		return;
+	}
+	try {
+		const todoPath = result.path;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let content = readFileSync$1(todoPath, "utf-8");
+		content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
+		content = content.trimEnd() + `\n\n---\n\n*Last updated: ${now}*\n`;
+		writeFileSync$1(todoPath, content);
+	} catch {}
+	console.error(result.carriedForward ? "TODO.md ## Continue section updated (previous content carried forward)" : "TODO.md ## Continue section updated");
+}
+
+//#endregion
+//#region src/daemon/templates/session-summary-prompt.ts
+/**
+* Build the prompt string to send to the summarizer model.
+*
+* Returns a single string suitable for piping to `claude --model <model> --print`.
+*/
+function buildSessionSummaryPrompt(params) {
+	const { userMessages, gitLog, cwd, date, filesModified, existingNote } = params;
+	const userSection = userMessages.length > 0 ? userMessages.map((m, i) => `[${i + 1}] ${m}`).join("\n\n") : "(No user messages extracted)";
+	const gitSection = gitLog.trim() || "(No git commits during this session)";
+	const filesSection = filesModified && filesModified.length > 0 ? filesModified.map((f) => `- ${f}`).join("\n") : "";
+	return `You are summarizing a coding session. Given the user messages and git commits below, write a session note.
+
+Project directory: ${cwd}
+Date: ${date}
+
+Focus on:
+- What problems were encountered and how they were solved
+- Key architectural decisions and their rationale
+- What was built (reference actual files and code patterns)
+- What was left unfinished or needs follow-up
+
+Do NOT include:
+- Mechanical metadata (token counts, checkpoint timestamps)
+- System messages or tool results verbatim
+- Generic descriptions — be specific about what happened
+- Markdown frontmatter or YAML headers
+${existingNote ? `\nAn existing session note is provided below. Merge the new information into it,
+preserving what was already written. Add new work items and update the summary.
+Do NOT duplicate existing content.
+
+EXISTING NOTE:
+${existingNote}
+` : ""}
+Format your response EXACTLY as follows (no extra text before or after):
+
+TOPIC: [A short topic label, max 60 characters, describing the WORK DONE — not quoting user messages. Format as "Topic1, Topic2, and Topic3" if multiple themes. Example: "Session Summary Worker, Topic Detection"]
+
+# Session: [Descriptive title summarizing what was ACCOMPLISHED, max 60 characters. Describe the work done, not the user's request. Bad: "Dark Mode Button Does Nothing". Good: "Dark Mode Toggle, Keyboard IPC, and Audio Fix"]
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+[Organize by theme, not chronologically. Group related work under descriptive bullet points.
+Use checkbox format: - [x] for completed items, - [ ] for incomplete items.
+Include specific file names, function names, and technical details.]
+
+## Key Decisions
+
+[List important choices made during the session with brief rationale.
+Skip this section entirely if no significant decisions were made.]
+
+## Known Issues
+
+[What was left unfinished, bugs discovered, or follow-up items needed.
+Skip this section entirely if nothing is pending.]
+
+---
+
+USER MESSAGES:
+${userSection}
+
+GIT COMMITS:
+${gitSection}
+${filesSection ? `\nFILES MODIFIED:\n${filesSection}` : ""}`;
+}
+
+//#endregion
+//#region src/daemon/templates/triple-extraction-prompt.ts
+/**
+* triple-extraction-prompt.ts — Prompt template for KG triple extraction.
+*
+* Used by the session-summary-worker to extract structured facts from
+* a completed session summary and store them in the temporal knowledge graph.
+*/
+function buildTripleExtractionPrompt(params) {
+	return `Extract structured entities and relations from this coding session.
+
+Output a single JSON object with two arrays: "entities" and "relations".
+
+Entity types: project | person | concept | tool | file | version | decision | technology | organization
+
+Rules:
+- Be SPECIFIC: entity names must be concrete (e.g., "FSRS", "Glidr", "the owner")
+- Use snake_case relation verb phrases (e.g., "uses_algorithm", "decided_to", "shipped_version")
+- Skip opinions, speculation, and "we should" statements
+- Skip entities obvious from project metadata unless they have a meaningful relation
+- Maximum 15 relations per session — pick the most important
+- Each entity should have a brief description (1 sentence, what it is in this context)
+- Each relation must reference entity names that appear in the entities array
+
+Example output:
+{
+  "entities": [
+    {"name": "Glidr", "type": "project", "description": "Flashcard app using FSRS spaced repetition"},
+    {"name": "FSRS", "type": "concept", "description": "Free Spaced Repetition Scheduler algorithm"},
+    {"name": "the owner", "type": "person", "description": "Developer of Glidr and Quassl"},
+    {"name": "Quassl", "type": "project", "description": "iOS app being rewritten in Flutter"},
+    {"name": "Flutter", "type": "technology", "description": "Cross-platform mobile framework"}
+  ],
+  "relations": [
+    {"source": "Glidr", "relation": "uses_algorithm", "target": "FSRS"},
+    {"source": "Glidr", "relation": "shipped_version", "target": "1.0.5"},
+    {"source": "the owner", "relation": "decided_to_rewrite", "target": "Quassl"},
+    {"source": "Quassl", "relation": "migrating_to", "target": "Flutter"}
+  ]
+}
+
+PROJECT: ${params.projectSlug}
+
+SESSION CONTENT:
+${params.sessionContent}
+
+GIT COMMITS:
+${params.gitLog}
+
+Output ONLY the JSON object with no surrounding prose, no code fences, no trailing commas, and no comments.
+
+JSON object (entities + relations):`;
+}
+
+//#endregion
+//#region src/workers/daemon-llm.ts
+/**
+* daemon-llm.ts — provider-routed LLM spawns for daemon-side background calls.
+*
+* Session summaries, context handovers and KG extraction used to spawn a bare
+* `claude --model <tier>` with the ambient environment: on a machine whose
+* only login is a worker provider that spawn either dies (no Anthropic
+* credentials) or bills Anthropic outside the provider abstraction. This
+* module routes those spawns through the same registry and env build the
+* worker runner uses (`buildRunEnv`), resolving the tier alias to the
+* provider's concrete model id. With no usable provider configured it falls
+* back to the historical behaviour: the tier alias itself, ambient env minus
+* the Anthropic API key.
+*/
+/** Timeout per tier (ms) — a class-appropriate budget, not a per-model one. */
+const LLM_TIMEOUT_MS = {
+	haiku: 6e4,
+	sonnet: 12e4,
+	opus: 3e5
+};
+/** Resolve a tier to the provider's concrete model id: the fast capability
+*  for the cheap tier, the default model for the middle and top tiers. */
+function tierModel(provider, tier) {
+	return resolveModelCapability(provider, tier === "haiku" ? "fast" : "default");
+}
+/**
+* Containment every daemon-side LLM spawn carries. These calls are
+* text-in/text-out: the prompt carries the context, the answer is the
+* product, and nothing about summarizing a session justifies a tool. An
+* unrestricted background summarizer was observed on 2026-09-18 (01:33-01:51)
+* rewriting the live config with a schema-shaped dump while the daemon ran;
+* with the tool grant empty and MCP strictly empty, that class of damage is
+* structurally impossible rather than merely unlikely.
+*/
+function containmentArgs(logDir) {
+	return [
+		"--strict-mcp-config",
+		"--mcp-config",
+		ensureNoMcpConfig(logDir),
+		"--allowedTools",
+		"",
+		"--tools",
+		""
+	];
+}
+/** The historical fallback: tier alias as the model id, ambient env with the
+*  Anthropic API key stripped (so the CLI uses its interactive login). */
+function legacyPlan(tier, config) {
+	const { ANTHROPIC_API_KEY: _drop, ...env } = process.env;
+	return {
+		model: tier,
+		args: [
+			"--model",
+			tier,
+			...containmentArgs(workersLogDir(config ?? defaultWorkersConfig())),
+			"-p",
+			"--no-session-persistence"
+		],
+		env,
+		timeoutMs: LLM_TIMEOUT_MS[tier],
+		provider: null
+	};
+}
+/**
+* Plan a daemon-side LLM spawn for a tier. Provider resolution failures (no
+* config, workers off, no usable provider) fall back to the tier-alias path;
+* a configured-but-broken provider (unreadable key file) throws, because
+* silently degrading to Anthropic billing is worse than a failed summary.
+*/
+async function planLlmSpawn(tier, configPath) {
+	let provider = null;
+	let providerName = null;
+	let config = null;
+	try {
+		const { workers } = readWorkersSection(configPath);
+		config = workers;
+		if (workers.enabled) {
+			const target = resolveTarget(workers, workersLogDir(workers), {});
+			provider = target.provider;
+			providerName = target.providerName;
+		}
+	} catch {
+		provider = null;
+		providerName = null;
+	}
+	if (!provider || !providerName || !config) return legacyPlan(tier, config);
+	const logDir = workersLogDir(config);
+	let proxyUrl;
+	if (provider.protocol === "openai") {
+		mkdirSync(logDir, { recursive: true });
+		proxyUrl = `${await ensureProxyRunning(DEFAULT_PROXY_PORT, logDir)}/${providerName}`;
+	}
+	const model = tierModel(provider, tier);
+	return {
+		model,
+		args: [
+			"--model",
+			model,
+			...containmentArgs(logDir),
+			"-p",
+			"--no-session-persistence"
+		],
+		env: buildRunEnv(provider, true, proxyUrl),
+		timeoutMs: LLM_TIMEOUT_MS[tier],
+		provider: providerName
+	};
+}
+
+//#endregion
+//#region src/memory/kg-extraction.ts
+/**
+* kg-extraction.ts — Shared KG triple extraction logic.
+*
+* Extracted from session-summary-worker.ts so both the worker and the
+* CLI backfill (`pai kg backfill`) can use the same code path.
+*
+* Provides:
+*   - findClaudeBinary()       — locate the claude CLI
+*   - spawnClaude()            — generic prompt -> response runner (provider-routed)
+*   - extractAndStoreTriples() — run the extractor prompt and persist triples to Postgres
+*/
+/**
+* Find the `claude` CLI binary. Checks common installation locations first
+* (launchd PATH is minimal so bare "claude" often won't resolve).
+*/
+function findClaudeBinary$1() {
+	const candidates = [
+		join(homedir(), ".local", "bin", "claude"),
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude"
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return "claude";
+}
+/**
+* Spawn the claude CLI with a prompt on stdin and return stdout.
+*
+* Routed through the provider registry (planLlmSpawn): the tier resolves to
+* the configured provider's model id and the env carries its base URL and
+* token. With no provider configured it degrades to the historical behaviour
+* — the tier alias itself, ambient env minus ANTHROPIC_API_KEY.
+*/
+async function spawnClaude(prompt, tier = "sonnet") {
+	const claudeBin = findClaudeBinary$1();
+	if (!claudeBin) {
+		process.stderr.write("[kg-extraction] claude CLI not found.\n");
+		return null;
+	}
+	let plan;
+	try {
+		plan = await planLlmSpawn(tier);
+	} catch (e) {
+		process.stderr.write(`[kg-extraction] could not plan ${tier} spawn: ${e}\n`);
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const child = spawn(claudeBin, plan.args, {
+			env: plan.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			process.stderr.write(`[kg-extraction] ${plan.model} spawn error: ${err.message}\n`);
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (code !== 0) {
+				process.stderr.write(`[kg-extraction] ${plan.model} exited ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[kg-extraction] ${plan.model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, plan.timeoutMs);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Slice text down to the outermost JSON structure, dropping any surrounding
+* prose or code-fence artifacts the LLM added around the JSON object/array.
+* Returns the input unchanged if no opening brace/bracket is found.
+*/
+function extractJsonSpan(text) {
+	const firstBrace = text.indexOf("{");
+	const firstBracket = text.indexOf("[");
+	let start = -1;
+	let closeChar = "";
+	if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+		start = firstBrace;
+		closeChar = "}";
+	} else if (firstBracket !== -1) {
+		start = firstBracket;
+		closeChar = "]";
+	}
+	if (start === -1) return text;
+	const end = text.lastIndexOf(closeChar);
+	if (end === -1 || end <= start) return text;
+	return text.slice(start, end + 1);
+}
+/**
+* Extract structured KG triples from a session summary and store them in
+* Postgres. Idempotent: if a (subject, predicate) pair already has the same
+* object, no new row is added; if the object differs, the old triple is
+* invalidated (valid_to = NOW()) and a new one is inserted.
+*
+* Best-effort: per-triple errors are caught and logged but never thrown.
+* Returns a small stats object so callers can report progress.
+*/
+async function extractAndStoreTriples$1(pool, params) {
+	const stats = {
+		extracted: 0,
+		added: 0,
+		superseded: 0
+	};
+	const jsonOutput = await spawnClaude(buildTripleExtractionPrompt({
+		sessionContent: params.summaryText,
+		projectSlug: params.projectSlug,
+		gitLog: params.gitLog ?? ""
+	}), params.model ?? "sonnet");
+	if (!jsonOutput) return stats;
+	let cleaned = jsonOutput.replace(/^```json\s*/m, "").replace(/^```\s*/m, "").replace(/\s*```$/m, "").trim();
+	cleaned = extractJsonSpan(cleaned);
+	let triples;
+	try {
+		const parsed = JSON.parse(cleaned);
+		if (Array.isArray(parsed)) triples = parsed;
+		else if (parsed && typeof parsed === "object" && Array.isArray(parsed.relations)) {
+			const newFmt = parsed;
+			if (params.federationDb && Array.isArray(newFmt.entities)) {
+				const tenantId = params.tenantId ?? "default";
+				for (const entity of newFmt.entities) {
+					if (!entity.name) continue;
+					try {
+						upsertKgEntity(params.federationDb, {
+							name: entity.name,
+							type: entity.type ?? "unknown",
+							description: entity.description,
+							tenantId
+						});
+					} catch (entityErr) {
+						process.stderr.write(`[kg-extraction] entity upsert error (${entity.name}): ${entityErr}\n`);
+					}
+				}
+			}
+			triples = newFmt.relations.map((r) => ({
+				subject: r.source,
+				predicate: r.relation,
+				object: r.target
+			}));
+		} else {
+			process.stderr.write(`[kg-extraction] Unexpected JSON shape — neither array nor {entities,relations}\n`);
+			return stats;
+		}
+	} catch (e) {
+		const collapse = (s) => s.replace(/\s+/g, " ").trim();
+		const head200 = collapse(jsonOutput.slice(0, 200));
+		const tail200 = collapse(jsonOutput.slice(-200));
+		process.stderr.write(`[kg-extraction] JSON parse failed: ${e}. head200="${head200}" tail200="${tail200}"\n`);
+		return stats;
+	}
+	if (!Array.isArray(triples)) return stats;
+	stats.extracted = triples.length;
+	for (const t of triples) {
+		if (!t.subject || !t.predicate || !t.object) continue;
+		try {
+			const existing = await kgQuery(pool, {
+				subject: t.subject,
+				predicate: t.predicate,
+				project_id: params.projectId ?? void 0
+			});
+			if (existing.find((e) => e.object === t.object && !e.valid_to)) continue;
+			const supersedes = existing.find((e) => e.object !== t.object && !e.valid_to);
+			if (supersedes) {
+				await kgInvalidate(pool, supersedes.id);
+				stats.superseded++;
+			}
+			await kgAdd(pool, {
+				subject: t.subject,
+				predicate: t.predicate,
+				object: t.object,
+				project_id: params.projectId ?? void 0,
+				source_session: params.sessionId,
+				confidence: "EXTRACTED"
+			});
+			stats.added++;
+		} catch (tripleErr) {
+			process.stderr.write(`[kg-extraction] store error (${t.subject}): ${tripleErr}\n`);
+		}
+	}
+	return stats;
+}
+
+//#endregion
+//#region src/daemon/session-summary-worker.ts
+/**
+* session-summary-worker.ts — AI-powered session note generation
+*
+* Processes `session-summary` work items by:
+*   1. Finding the current session's JSONL transcript
+*   2. Extracting user messages and assistant context
+*   3. Gathering git commits from the session period
+*   4. Spawning Claude (sonnet for compaction, opus for session end) to generate a structured summary
+*   5. Comparing the new topic against the existing note's topic
+*   6. Creating a NEW note if the topic shifted, or updating the existing one
+*
+* Topic detection: the summarizer outputs a TOPIC: line as the first line of
+* its response. This is compared against the existing note's title using word
+* overlap. If overlap is below ~30%, a new note is created.
+*
+* Designed to run inside the daemon's work queue worker. All errors are
+* thrown (not swallowed) so the work queue retry logic handles them.
+*/
+/** Minimum interval between summaries for the same project (ms). */
+const SUMMARY_COOLDOWN_MS = 1800 * 1e3;
+/** Maximum JSONL content to feed to the summarizer (characters). */
+/** Max JSONL chars per model. Opus/Sonnet can handle much more than Haiku. */
+const MAX_JSONL_CHARS = {
+	haiku: 5e4,
+	sonnet: 2e5,
+	opus: 5e5
+};
+/** Maximum user messages to include in the prompt. */
+const MAX_USER_MESSAGES = 30;
+/** File tracking last summary timestamps per project — resolved under
+*  PAI_HOME, falling back to the pre-2026-09-19 ~/.config/pai location. */
+function oldCooldownFile() {
+	return join(homedir(), ".config", "pai", "summary-cooldowns.json");
+}
+function cooldownFilePath() {
+	return resolvePaiFile(paiHomePath("summary-cooldowns.json"), [oldCooldownFile()], "pai config migrate");
+}
+function migrateSummaryCooldowns(opts = {}) {
+	return migratePaiFile(paiHomePath("summary-cooldowns.json"), [oldCooldownFile()], opts);
+}
+/** Claude Code projects directory. */
+const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+function loadCooldowns() {
+	try {
+		const file = cooldownFilePath();
+		if (existsSync(file)) return JSON.parse(readFileSync(file, "utf-8"));
+	} catch {}
+	return {};
+}
+function saveCooldowns(cooldowns) {
+	try {
+		const file = paiHomePath("summary-cooldowns.json");
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(file, JSON.stringify(cooldowns, null, 2), "utf-8");
+	} catch {}
+}
+function isOnCooldown(cwd) {
+	const lastRun = loadCooldowns()[cwd];
+	if (!lastRun) return false;
+	return Date.now() - lastRun < SUMMARY_COOLDOWN_MS;
+}
+function markCooldown(cwd) {
+	const cooldowns = loadCooldowns();
+	cooldowns[cwd] = Date.now();
+	const cutoff = Date.now() - 1440 * 60 * 1e3;
+	for (const key of Object.keys(cooldowns)) if (cooldowns[key] < cutoff) delete cooldowns[key];
+	saveCooldowns(cooldowns);
+}
+/**
+* Encode a cwd path the same way Claude Code does for its project directories.
+* Replaces /, space, dot, and hyphen with -.
+*/
+function encodeProjectPath(cwd) {
+	return cwd.replace(/[\/\s.\-]/g, "-");
+}
+/**
+* Find the most recently modified JSONL file for the given project.
+*
+* Claude Code stores transcripts in:
+*   ~/.claude/projects/<encoded-path>/sessions/*.jsonl
+*   ~/.claude/projects/<encoded-path>/<uuid>.jsonl (legacy)
+*/
+function findLatestJsonl(cwd) {
+	const projectDir = join(CLAUDE_PROJECTS_DIR, encodeProjectPath(cwd));
+	if (!existsSync(projectDir)) {
+		process.stderr.write(`[session-summary] No Claude project dir found: ${projectDir}\n`);
+		return null;
+	}
+	const candidates = [];
+	const sessionsDir = join(projectDir, "sessions");
+	if (existsSync(sessionsDir)) try {
+		for (const f of readdirSync(sessionsDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(sessionsDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	try {
+		for (const f of readdirSync(projectDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(projectDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	if (candidates.length === 0) {
+		process.stderr.write(`[session-summary] No JSONL files found in ${projectDir}\n`);
+		return null;
+	}
+	candidates.sort((a, b) => b.mtime - a.mtime);
+	return candidates[0].path;
+}
+/**
+* Parse a JSONL transcript and extract relevant content.
+* Filters noise, truncates to model-appropriate size from the end of the file.
+*/
+function extractFromJsonl(jsonlPath, tier = "sonnet") {
+	const result = {
+		userMessages: [],
+		filesModified: [],
+		sessionStartTime: ""
+	};
+	let raw;
+	try {
+		raw = readFileSync(jsonlPath, "utf-8");
+	} catch (e) {
+		throw new Error(`Could not read JSONL at ${jsonlPath}: ${e}`);
+	}
+	const maxChars = MAX_JSONL_CHARS[tier] ?? 2e5;
+	if (raw.length > maxChars) {
+		const truncPoint = raw.indexOf("\n", raw.length - maxChars);
+		raw = truncPoint >= 0 ? raw.slice(truncPoint + 1) : raw.slice(-MAX_JSONL_CHARS);
+	}
+	const lines = raw.trim().split("\n");
+	const seenMessages = /* @__PURE__ */ new Set();
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry.timestamp && !result.sessionStartTime) result.sessionStartTime = String(entry.timestamp);
+		if (entry.type === "user") {
+			const msg = entry.message;
+			if (msg?.content) {
+				const text = contentToText(msg.content);
+				if (text && !isNoise(text) && !seenMessages.has(text)) {
+					seenMessages.add(text);
+					result.userMessages.push(text.slice(0, 500));
+				}
+			}
+		}
+		if (entry.type === "assistant") {
+			const msg = entry.message;
+			if (msg?.content && Array.isArray(msg.content)) {
+				for (const block of msg.content) if (block.type === "tool_use") {
+					const name = block.name;
+					const input = block.input;
+					if ((name === "Edit" || name === "Write") && input?.file_path) {
+						const fp = String(input.file_path);
+						if (!result.filesModified.includes(fp)) result.filesModified.push(fp);
+					}
+				}
+			}
+		}
+	}
+	if (result.userMessages.length > MAX_USER_MESSAGES) result.userMessages = result.userMessages.slice(-MAX_USER_MESSAGES);
+	return result;
+}
+/** Convert Claude content (string or content block array) to plain text. */
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		if (typeof c === "string") return c;
+		const block = c;
+		if (block?.text) return String(block.text);
+		if (block?.content) return String(block.content);
+		return "";
+	}).join(" ").trim();
+	return "";
+}
+/** Filter out noise entries that shouldn't be included in the summary. */
+function isNoise(text) {
+	if (!text || text.length < 3) return true;
+	if (text.includes("<task-notification>")) return true;
+	if (text.includes("[object Object]")) return true;
+	if (text.startsWith("<system-reminder>")) return true;
+	if (/^(yes|ok|sure|go|continue|weiter|thanks|thank you)\.?$/i.test(text.trim())) return true;
+	if (text.startsWith("Tool Result:") || text.startsWith("tool_result")) return true;
+	return false;
+}
+/**
+* Get git log for the session period.
+* Falls back gracefully if git is not available or the dir is not a repo.
+*/
+async function getGitContext(cwd, sinceTime) {
+	let since = "6 hours ago";
+	if (sinceTime) {
+		const asNum = Number(sinceTime);
+		if (!isNaN(asNum) && asNum > 1e9) since = (/* @__PURE__ */ new Date(asNum * 1e3)).toISOString();
+		else since = sinceTime;
+	}
+	try {
+		const { execFile: execFileCb } = await import("node:child_process");
+		const { promisify } = await import("node:util");
+		const { stdout } = await promisify(execFileCb)("git", [
+			"log",
+			"--format=%h %ai %s",
+			`--since=${since}`,
+			"--stat",
+			"--no-color"
+		], {
+			cwd,
+			timeout: 1e4,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Find the `claude` CLI binary.
+* Checks PATH first, then common installation locations.
+*/
+function findClaudeBinary() {
+	const candidates = [
+		join(homedir(), ".local", "bin", "claude"),
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude"
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return "claude";
+}
+/**
+* Spawn a Claude model via the CLI to generate a session summary.
+* Pipes the prompt via stdin. Tier selection (resolved to the configured
+* provider's model id, falling back to the tier alias when no provider is
+* configured — see planLlmSpawn):
+*   - opus: session end (best quality for final summary, runs once)
+*   - sonnet: auto-compaction (good quality for incremental checkpoints, runs often)
+*   - haiku: fallback / budget mode
+* Returns the generated text, or null if spawning fails.
+*/
+async function spawnSummarizer(prompt, tier = "sonnet") {
+	const claudeBin = findClaudeBinary();
+	if (!claudeBin) {
+		process.stderr.write("[session-summary] Claude CLI not found in PATH or common locations.\n");
+		return null;
+	}
+	let plan;
+	try {
+		plan = await planLlmSpawn(tier);
+	} catch (e) {
+		process.stderr.write(`[session-summary] could not plan ${tier} spawn: ${e}\n`);
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const child = spawn(claudeBin, plan.args, {
+			env: plan.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			process.stderr.write(`[session-summary] ${plan.model} spawn error: ${err.message}\n`);
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (code !== 0) {
+				process.stderr.write(`[session-summary] ${plan.model} exited with code ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[session-summary] ${plan.model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, plan.timeoutMs);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Extract the TOPIC: line from the summarizer output.
+* Returns the topic string, or null if not found.
+*/
+function extractTopic(summaryText) {
+	const match = summaryText.match(/^TOPIC:\s*(.+)$/m);
+	if (!match) return null;
+	return match[1].trim();
+}
+/**
+* Extract the topic from an existing session note.
+* First checks for a <!-- TOPIC: ... --> comment (stored by previous summaries).
+* Falls back to the H1 "# Session NNNN: Title" line.
+*
+* The HTML comment is the reliable source because the H1 gets renamed by
+* renameSessionNote, which can add/change words and cause false topic shifts.
+*/
+function extractExistingNoteTitle(notePath) {
+	try {
+		const content = readFileSync(notePath, "utf-8");
+		const topicComment = content.match(/<!-- TOPIC:\s*(.+?)\s*-->/);
+		if (topicComment) return topicComment[1].trim();
+		const match = content.match(/^# Session \d+:\s*(.+)$/m);
+		if (match) return match[1].trim();
+	} catch {}
+	return null;
+}
+/**
+* Compute word overlap ratio between two topic strings.
+* Returns a value in [0, 1] — 1.0 means identical word sets.
+*
+* Uses lowercased, normalized words. Stop words and very short words
+* are excluded to avoid false positives on common terms.
+*/
+function computeTopicOverlap(topicA, topicB) {
+	const stopWords = new Set([
+		"a",
+		"an",
+		"the",
+		"and",
+		"or",
+		"but",
+		"in",
+		"on",
+		"at",
+		"to",
+		"for",
+		"of",
+		"with",
+		"by",
+		"from",
+		"is",
+		"was",
+		"are",
+		"were",
+		"be",
+		"been",
+		"being",
+		"have",
+		"has",
+		"had",
+		"do",
+		"does",
+		"did",
+		"will",
+		"would",
+		"could",
+		"should",
+		"may",
+		"might",
+		"can",
+		"shall",
+		"this",
+		"that",
+		"these",
+		"those",
+		"it",
+		"its",
+		"new",
+		"session",
+		"work",
+		"done"
+	]);
+	const normalize = (text) => {
+		const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+		return new Set(words);
+	};
+	const wordsA = normalize(topicA);
+	const wordsB = normalize(topicB);
+	if (wordsA.size === 0 || wordsB.size === 0) return 0;
+	let intersection = 0;
+	for (const w of wordsA) if (wordsB.has(w)) intersection++;
+	const union = new Set([...wordsA, ...wordsB]).size;
+	return union > 0 ? intersection / union : 0;
+}
+/** Threshold: below this overlap ratio, we consider topics different. */
+const TOPIC_OVERLAP_THRESHOLD = .15;
+/**
+* Write (or update) the session note with the AI-generated summary.
+*
+* Strategy:
+*   - Find the current month's latest note
+*   - If it's from today, compare topics:
+*     - Same topic (overlap >= 30%) → update existing note
+*     - Different topic (overlap < 30%) → create a NEW note
+*   - If it's from a different day, create a new note
+*/
+/**
+* Return true if the summarizer output has a meaningful body — i.e. content
+* beyond the TOPIC:/title/metadata/horizontal-rule scaffolding.
+*
+* A summary that is only headers (no Work Done items) must NOT create or update
+* a note: doing so births an empty-bodied scaffold that later rename/finalize
+* can strip to a footer-only stub. This is the born-stub failure mode.
+*/
+function summaryHasContent(summaryText) {
+	return summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*(Date|Status|Completed):\*\*.*$/gm, "").replace(/^#{1,6}\s.*$/gm, "").replace(/^---$/gm, "").replace(/<!--[\s\S]*?-->/g, "").trim().length > 0;
+}
+function writeSessionNote(cwd, summaryText, filesModified, sessionId) {
+	if (!summaryHasContent(summaryText)) {
+		process.stderr.write(`[session-summary] Summary has no meaningful body — skipping note write.\n`);
+		return null;
+	}
+	const notesInfo = findNotesDir$1(cwd);
+	let notePath = sessionId && findNoteBySessionId(notesInfo.path, sessionId) || getCurrentNotePath(notesInfo.path);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const newTopic = extractTopic(summaryText);
+	if (notePath) {
+		const noteFilename = basename(notePath);
+		const dateMatch = noteFilename.match(/(\d{4}-\d{2}-\d{2})/);
+		if ((dateMatch ? dateMatch[1] : "") === today) {
+			const existingTitle = extractExistingNoteTitle(notePath);
+			let topicShifted = false;
+			if (newTopic && existingTitle) {
+				const overlap = computeTopicOverlap(newTopic, existingTitle);
+				process.stderr.write(`[session-summary] Topic overlap: ${(overlap * 100).toFixed(1)}% (new="${newTopic}", existing="${existingTitle}")\n`);
+				if (overlap < TOPIC_OVERLAP_THRESHOLD) {
+					topicShifted = true;
+					process.stderr.write(`[session-summary] Topic shift detected (word overlap) — creating new note.\n`);
+				}
+			}
+			if (!topicShifted) {
+				const boundaryPath = join(notesInfo.path, "topic-boundary.json");
+				if (existsSync(boundaryPath)) try {
+					const boundary = JSON.parse(readFileSync(boundaryPath, "utf-8"));
+					if (boundary.timestamp) {
+						if (Date.now() - new Date(boundary.timestamp).getTime() < 1800 * 1e3) {
+							topicShifted = true;
+							process.stderr.write(`[session-summary] Topic shift detected (boundary marker) — ${boundary.previousProject} → ${boundary.suggestedProject}\n`);
+						}
+					}
+					unlinkSync(boundaryPath);
+				} catch {}
+			}
+			if (topicShifted) notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+			else {
+				updateNoteWithSummary(notePath, summaryText);
+				process.stderr.write(`[session-summary] Updated existing note: ${noteFilename}\n`);
+			}
+		} else notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+	} else notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+	if (notePath) {
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		if (titleMatch) {
+			const title = titleMatch[1].trim();
+			if (title.length > 5 && title.length < 80) {
+				const newPath = renameSessionNote(notePath, title);
+				if (newPath !== notePath) notePath = newPath;
+			}
+		}
+	}
+	return notePath;
+}
+/**
+* Update an existing session note's Work Done section with AI-generated content.
+*/
+function updateNoteWithSummary(notePath, summaryText) {
+	if (!existsSync(notePath)) return;
+	let content = readFileSync(notePath, "utf-8");
+	const newTopic = extractTopic(summaryText);
+	if (newTopic) if (content.includes("<!-- TOPIC:")) content = content.replace(/<!-- TOPIC:.*?-->/, `<!-- TOPIC: ${newTopic} -->`);
+	else content = content.replace(/^(# Session .+)$/m, `$1\n<!-- TOPIC: ${newTopic} -->`);
+	const workDoneMatch = summaryText.match(/## Work Done\n\n([\s\S]*?)(?=\n## Key Decisions|\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (workDoneMatch) {
+		const aiWorkContent = workDoneMatch[1].trim();
+		const sectionHeader = `\n### AI Summary (${(/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0]})\n\n${aiWorkContent}\n`;
+		const nextStepsIdx = content.indexOf("## Next Steps");
+		const knownIssuesIdx = content.indexOf("## Known Issues");
+		const insertBefore = knownIssuesIdx !== -1 ? knownIssuesIdx : nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+		content = content.slice(0, insertBefore) + sectionHeader + "\n" + content.slice(insertBefore);
+	}
+	const decisionsMatch = summaryText.match(/## Key Decisions\n\n([\s\S]*?)(?=\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (decisionsMatch) {
+		const decisions = decisionsMatch[1].trim();
+		if (decisions && !content.includes("## Key Decisions")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Key Decisions\n\n${decisions}\n\n` + content.slice(insertAt);
+		}
+	}
+	const issuesMatch = summaryText.match(/## Known Issues\n\n([\s\S]*?)(?=\n\*\*Tags|\n$)/);
+	if (issuesMatch) {
+		const issues = issuesMatch[1].trim();
+		if (issues && !content.includes("## Known Issues")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Known Issues\n\n${issues}\n\n` + content.slice(insertAt);
+		}
+	}
+	writeFileSync(notePath, content, "utf-8");
+}
+/**
+* Create a brand new session note from the AI summary.
+*/
+/**
+* Find the note this session already owns, by the marker its first write left.
+*
+* The previous resolver, getCurrentNotePath, returned the numerically highest
+* note in the month directory. That is a position, not an identity, and it is
+* why one session produced many notes: whenever a session's own note was not
+* the current maximum — two sessions in one project, or a number collision, of
+* which one corpus had 110 — the lookup missed and the checkpoint created a
+* new file instead of updating. Measured consequence in that corpus: 303 of
+* 407 notes sat in 31 same-title groups, 48 of them sharing a single title.
+*
+* Matching on the session id makes the answer exact: a session either has a
+* note or it does not, regardless of what else the directory contains.
+*/
+function findNoteBySessionId(notesDir, sessionId) {
+	if (!sessionId || !existsSync(notesDir)) return null;
+	const marker = `<!-- SESSION: ${sessionId} -->`;
+	const now = /* @__PURE__ */ new Date();
+	const dirs = [0, -1].map((delta) => {
+		const d = new Date(now.getFullYear(), now.getMonth() + delta, 1);
+		return join(notesDir, String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, "0"));
+	});
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		for (const f of readdirSync(dir)) {
+			if (!f.endsWith(".md")) continue;
+			const p = join(dir, f);
+			try {
+				if (readFileSync(p, "utf-8").includes(marker)) return p;
+			} catch {}
+		}
+	}
+	return null;
+}
+function createNoteFromSummary(notesDir, summaryText, sessionId) {
+	try {
+		const notePath = createSessionNote(notesDir, "New Session");
+		const noteFilename = basename(notePath);
+		const numberMatch = noteFilename.match(/^(\d+)/);
+		const noteNumber = numberMatch ? numberMatch[1] : "0000";
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		const title = titleMatch ? titleMatch[1].trim() : "New Session";
+		const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+		const topic = extractTopic(summaryText);
+		const aiBody = summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*Date:\*\*.*$/m, "").replace(/^\*\*Status:\*\*.*$/m, "").replace(/^---$/m, "").trim();
+		writeFileSync(notePath, `# Session ${noteNumber}: ${title}
+${topic ? `<!-- TOPIC: ${topic} -->` : ""}${sessionId ? `\n<!-- SESSION: ${sessionId} -->` : ""}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+${aiBody}
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`, "utf-8");
+		process.stderr.write(`[session-summary] Created AI-powered note: ${noteFilename}\n`);
+		return notePath;
+	} catch (e) {
+		process.stderr.write(`[session-summary] Failed to create note: ${e}\n`);
+		return null;
+	}
+}
+/**
+* Look up the integer project_id from the registry DB for a given slug.
+* Returns null if not found or registryDb is not yet initialized.
+*/
+function lookupProjectId(slug) {
+	try {
+		if (!registryDb) return null;
+		return registryDb.prepare("SELECT id FROM projects WHERE slug = ? LIMIT 1").get(slug)?.id ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract structured KG triples from a session summary and store them.
+*
+* This is best-effort: any error is logged but never propagated.
+* Requires Postgres backend — silently no-ops on SQLite.
+*/
+async function extractAndStoreTriples(params) {
+	try {
+		if (!storageBackend || storageBackend.backendType !== "postgres") return;
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			process.stderr.write("[session-summary] Triple extraction: no pool available.\n");
+			return;
+		}
+		const cfg = daemonConfig;
+		if (cfg && cfg.kg_extraction_enabled === false) {
+			process.stderr.write("[session-summary] Triple extraction disabled via kg_extraction_enabled=false.\n");
+			return;
+		}
+		const federationDb = openFederation();
+		let result;
+		try {
+			result = await extractAndStoreTriples$1(pool, {
+				summaryText: params.summaryText,
+				projectSlug: params.projectSlug,
+				projectId: params.projectId,
+				sessionId: params.sessionId,
+				gitLog: params.gitLog,
+				model: "sonnet",
+				federationDb
+			});
+		} finally {
+			federationDb.close();
+		}
+		process.stderr.write(`[session-summary] Triple extraction complete: ${result.extracted} extracted, ${result.added} added, ${result.superseded} superseded.\n`);
+	} catch (err) {
+		process.stderr.write(`[session-summary] Triple extraction failed: ${err}\n`);
+	}
+}
+/**
+* Process a `session-summary` work item.
+*
+* This is the main function called by work-queue-worker.ts.
+* Throws on fatal errors (work queue will retry with backoff).
+*/
+async function handleSessionSummary(payload) {
+	const { cwd, sessionId, projectSlug, transcriptPath, force } = payload;
+	if (!cwd) throw new Error("session-summary payload missing cwd");
+	process.stderr.write(`[session-summary] Starting for ${cwd}${sessionId ? ` (session=${sessionId})` : ""}${force ? " (force=true)" : ""}\n`);
+	if (!force && isOnCooldown(cwd)) {
+		process.stderr.write("[session-summary] Skipping — last summary was less than 30 minutes ago.\n");
+		return;
+	}
+	let jsonlPath = transcriptPath || null;
+	if (jsonlPath && !existsSync(jsonlPath)) {
+		process.stderr.write(`[session-summary] Provided transcript path not found: ${jsonlPath}\n`);
+		jsonlPath = null;
+	}
+	if (!jsonlPath) jsonlPath = findLatestJsonl(cwd);
+	if (!jsonlPath) {
+		process.stderr.write("[session-summary] No JSONL transcript found — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Using transcript: ${jsonlPath}\n`);
+	const selectedModel = payload.model ?? (force ? "haiku" : "sonnet");
+	const extracted = extractFromJsonl(jsonlPath, selectedModel);
+	if (extracted.userMessages.length === 0) {
+		process.stderr.write("[session-summary] No user messages found in transcript — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Extracted ${extracted.userMessages.length} user messages, ${extracted.filesModified.length} modified files.\n`);
+	const gitLog = await getGitContext(cwd, extracted.sessionStartTime);
+	if (gitLog) process.stderr.write(`[session-summary] Got git context (${gitLog.split("\n").length} lines).\n`);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const existingNotePath = getCurrentNotePath(findNotesDir$1(cwd).path);
+	let existingNote;
+	if (existingNotePath) {
+		const dateMatch = basename(existingNotePath).match(/(\d{4}-\d{2}-\d{2})/);
+		if (dateMatch && dateMatch[1] === today) try {
+			existingNote = readFileSync(existingNotePath, "utf-8");
+		} catch {}
+	}
+	const prompt = buildSessionSummaryPrompt({
+		userMessages: extracted.userMessages,
+		gitLog,
+		cwd,
+		date: today,
+		filesModified: extracted.filesModified,
+		existingNote
+	});
+	process.stderr.write(`[session-summary] Sending ${prompt.length} char prompt to ${selectedModel}...\n`);
+	const summaryText = await spawnSummarizer(prompt, selectedModel);
+	if (!summaryText) {
+		process.stderr.write(`[session-summary] ${selectedModel} did not produce output — falling back to mechanical checkpoint.\n`);
+		markCooldown(cwd);
+		return;
+	}
+	process.stderr.write(`[session-summary] ${selectedModel} produced ${summaryText.length} char summary.\n`);
+	const notePath = writeSessionNote(cwd, summaryText, extracted.filesModified, sessionId);
+	if (notePath) process.stderr.write(`[session-summary] Session note written: ${basename(notePath)}\n`);
+	await extractAndStoreTriples({
+		summaryText,
+		projectSlug: projectSlug ?? basename(cwd),
+		projectId: projectSlug ? lookupProjectId(projectSlug) : null,
+		sessionId: sessionId ?? cwd,
+		gitLog,
+		model: selectedModel
+	});
+	markCooldown(cwd);
+	process.stderr.write("[session-summary] Done.\n");
+}
+
+//#endregion
+//#region src/daemon/work-queue.ts
+/**
+* work-queue.ts — Persistent work queue for the PAI Daemon
+*
+* Provides a durable, file-backed queue that survives daemon restarts.
+* Items are processed sequentially to avoid concurrent writes to the same
+* session note. Failed items are retried with exponential backoff.
+*
+* Queue file: under PAI_HOME (~/.claude/pai/work-queue.json), falling back
+* to the pre-2026-09-19 ~/.config/pai/work-queue.json location.
+* Written atomically (write temp → rename) to prevent corruption.
+*/
+function oldQueueFile() {
+	return join(homedir(), ".config", "pai", "work-queue.json");
+}
+const QUEUE_FILE = resolvePaiFile(paiHomePath("work-queue.json"), [oldQueueFile()], "pai config migrate");
+function migrateWorkQueue(opts = {}) {
+	return migratePaiFile(paiHomePath("work-queue.json"), [oldQueueFile()], opts);
+}
+const MAX_QUEUE_SIZE = 1e3;
+const MAX_QUEUE_FILE_BYTES = 1024 * 1024;
+const COMPLETED_TTL_MS = 3600 * 1e3;
+const FAILED_TTL_MS = 1440 * 60 * 1e3;
+/** Backoff delays in ms by attempt number (0-indexed). */
+const BACKOFF_MS = [
+	5e3,
+	3e4,
+	3e5
+];
+let _queue = [];
+let _dirty = false;
+/** Load queue from disk. Call once at daemon startup. */
+function loadQueue() {
+	if (!existsSync(QUEUE_FILE)) {
+		_queue = [];
+		return;
+	}
+	try {
+		const raw = readFileSync(QUEUE_FILE, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) {
+			process.stderr.write("[work-queue] Invalid queue file format — starting empty.\n");
+			_queue = [];
+			return;
+		}
+		_queue = parsed.map((item) => {
+			if (item.status === "processing") return {
+				...item,
+				status: "pending"
+			};
+			return item;
+		});
+		const stats = getStats();
+		process.stderr.write(`[work-queue] Loaded ${_queue.length} items from disk (pending=${stats.pending}, failed=${stats.failed}).\n`);
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not load queue file: ${e}\n`);
+		_queue = [];
+	}
+}
+/** Persist queue to disk atomically. */
+function saveQueue() {
+	const dir = dirname(QUEUE_FILE);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmpFile = QUEUE_FILE + ".tmp";
+	try {
+		writeFileSync(tmpFile, JSON.stringify(_queue, null, 2), "utf-8");
+		renameSync(tmpFile, QUEUE_FILE);
+		_dirty = false;
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not persist queue: ${e}\n`);
+	}
+}
+/** Persist only if there are unsaved changes. */
+function saveIfDirty() {
+	if (_dirty) saveQueue();
+}
+/**
+* Enforce the maximum queue size cap.
+* Strategy: first drop oldest completed, then oldest low-priority pending.
+*/
+function enforceMaxSize() {
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const excess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropCompleted = _queue.filter((i) => i.status === "completed").sort((a, b) => a.createdAt.localeCompare(b.createdAt)).slice(0, excess);
+	const dropIds = new Set(toDropCompleted.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropIds.has(i.id));
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const remainingExcess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropLow = _queue.filter((i) => i.status === "pending" && i.priority >= 4).sort((a, b) => a.priority - b.priority || a.createdAt.localeCompare(b.createdAt)).slice(0, remainingExcess);
+	const dropLowIds = new Set(toDropLow.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropLowIds.has(i.id));
+	process.stderr.write(`[work-queue] Pruned queue to ${_queue.length} items (cap=${MAX_QUEUE_SIZE}).\n`);
+}
+/**
+* Add a new work item to the queue.
+* Returns the created WorkItem.
+*/
+function enqueue(params) {
+	const item = {
+		id: randomUUID(),
+		type: params.type,
+		priority: params.priority ?? 3,
+		payload: params.payload,
+		status: "pending",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		attempts: 0,
+		maxAttempts: params.maxAttempts ?? 3
+	};
+	_queue.push(item);
+	enforceMaxSize();
+	_dirty = true;
+	saveIfDirty();
+	process.stderr.write(`[work-queue] Enqueued ${item.type} (id=${item.id}, priority=${item.priority}).\n`);
+	return item;
+}
+/**
+* Pick the next pending item that is ready to process (respects nextRetryAt).
+* Returns null if no eligible item exists.
+* Highest priority (lowest number) is processed first; ties broken by createdAt.
+*/
+function dequeue() {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const eligible = _queue.filter((i) => {
+		if (i.status !== "pending") return false;
+		if (i.nextRetryAt && i.nextRetryAt > now) return false;
+		return true;
+	}).sort((a, b) => {
+		if (a.priority !== b.priority) return a.priority - b.priority;
+		return a.createdAt.localeCompare(b.createdAt);
+	});
+	if (eligible.length === 0) return null;
+	const item = eligible[0];
+	item.status = "processing";
+	item.attempts += 1;
+	_dirty = true;
+	saveIfDirty();
+	return item;
+}
+/**
+* Mark an item as completed.
+*/
+function markCompleted(id) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.status = "completed";
+	item.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+	item.error = void 0;
+	_dirty = true;
+	saveIfDirty();
+}
+/**
+* Mark an item as failed.
+* If attempts < maxAttempts, schedules a retry with exponential backoff.
+* Otherwise, leaves status as 'failed'.
+*/
+function markFailed(id, errorMsg) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.error = errorMsg;
+	if (item.attempts < item.maxAttempts) {
+		const backoffMs = BACKOFF_MS[item.attempts - 1] ?? BACKOFF_MS[BACKOFF_MS.length - 1];
+		item.status = "pending";
+		item.nextRetryAt = new Date(Date.now() + backoffMs).toISOString();
+		process.stderr.write(`[work-queue] Item ${id} failed (attempt ${item.attempts}/${item.maxAttempts}), retry in ${backoffMs / 1e3}s: ${errorMsg}\n`);
+	} else {
+		item.status = "failed";
+		process.stderr.write(`[work-queue] Item ${id} exhausted retries (${item.maxAttempts} attempts): ${errorMsg}\n`);
+	}
+	_dirty = true;
+	saveIfDirty();
+}
+function getStats() {
+	const stats = {
+		pending: 0,
+		processing: 0,
+		completed: 0,
+		failed: 0,
+		total: _queue.length
+	};
+	for (const item of _queue) stats[item.status]++;
+	return stats;
+}
+/**
+* Returns true if any pending or processing item of the given type exists.
+* Used for debouncing work items that are expensive to run concurrently.
+*/
+function hasPendingOrProcessingOfType(type) {
+	return _queue.some((i) => i.type === type && (i.status === "pending" || i.status === "processing"));
+}
+/**
+* Remove completed and permanently-failed items older than their TTL.
+* Also force-cleans all completed items if the queue file exceeds 1 MB.
+*/
+function cleanup() {
+	const now = Date.now();
+	const before = _queue.length;
+	let forceCleanCompleted = false;
+	try {
+		if (existsSync(QUEUE_FILE)) {
+			const { size } = statSync(QUEUE_FILE);
+			if (size > MAX_QUEUE_FILE_BYTES) {
+				forceCleanCompleted = true;
+				process.stderr.write(`[work-queue] Queue file exceeds 1 MB (${size} bytes) — force-cleaning completed items.\n`);
+			}
+		}
+	} catch {}
+	_queue = _queue.filter((item) => {
+		if (item.status === "completed") {
+			if (forceCleanCompleted) return false;
+			return now - (item.completedAt ? new Date(item.completedAt).getTime() : 0) < COMPLETED_TTL_MS;
+		}
+		if (item.status === "failed") return now - new Date(item.createdAt).getTime() < FAILED_TTL_MS;
+		return true;
+	});
+	const removed = before - _queue.length;
+	const stats = getStats();
+	if (removed > 0 || before === 0) process.stderr.write(`[work-queue] Cleanup: removed ${removed} items. Queue stats: pending=${stats.pending}, processing=${stats.processing}, completed=${stats.completed}, failed=${stats.failed}.\n`);
+	_dirty = removed > 0;
+	saveIfDirty();
+}
+
+//#endregion
+//#region src/hooks/ts/lib/context-handover-cache.ts
+/**
+* context-handover-cache.ts — the well-known file where the threshold-
+* triggered pre-compaction handover (see ../../../daemon/context-handover-
+* worker.ts) is written, and where context-compression-hook.ts looks for it
+* at compaction time.
+*
+* Deliberately dependency-light (fs/os/path only). The daemon worker that
+* WRITES this file needs the heavier machinery in session-summary-worker.ts
+* (spawning Claude, git log, etc.), but the PreCompact hook that READS it
+* runs as a short-lived process on every compaction and must not drag in
+* daemon state, database pools, or anything else that module graph carries —
+* this file is the shared seam so neither side has to.
+*/
+function contextHandoverCachePath(sessionId) {
+	return join(tmpdir(), `pai-context-handover-${sessionId}.json`);
+}
+function readContextHandoverCache(sessionId) {
+	const path = contextHandoverCachePath(sessionId);
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeContextHandoverCache(cache) {
+	writeFileSync(contextHandoverCachePath(cache.sessionId), JSON.stringify(cache, null, 2), "utf-8");
+}
+
+//#endregion
+export { archiveSessionFilesToSessionsDir as A, claudeProjectsDir as B, findLatestNote as C, appendCheckpoint as D, addWorkToSessionNote as E, performScan as F, scanTranscriptFolders as H, resolveHome as I, saveScanConfig as L, cmdScan as M, loadScanConfig as N, finalizeSessionNote as O, migrateScanConfig as P, upsertProject as R, applyContinue as S, readBodyFile as T, transcriptFiles as U, findMovedProjects as V, spawnSummarizer as _, enqueue as a, updateTodoContinue as b, loadQueue as c, migrateWorkQueue as d, contentToText as f, migrateSummaryCooldowns as g, handleSessionSummary as h, dequeue as i, findNotesDir$1 as j, getCurrentNotePath as k, markCompleted as l, getGitContext as m, writeContextHandoverCache as n, getStats as o, findLatestJsonl as p, cleanup as r, hasPendingOrProcessingOfType as s, readContextHandoverCache as t, markFailed as u, extractAndStoreTriples$1 as v, findNotesDir as w, appendCheckpointToNote as x, sessionIdFromTranscript as y, upsertSession as z };
+//# sourceMappingURL=context-handover-cache-B9NKSjwR.mjs.map