@tekmidian/pai 0.42.5 → 0.43.0

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

@@ -1,1548 +0,0 @@
-import { _ as warn, c as ok, i as err, n as dim, r as encodeDir, s as now, t as bold } from "./utils-9Err2RBW.mjs";
-import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "./migrate-Cjzeefn9.mjs";
-import { n as ensurePaiMarker, t as discoverPaiMarkers } from "./pai-marker-CHtbJMwJ.mjs";
-import { _ as readWorkersSection, l as defaultWorkersConfig, v as resolveModelCapability } from "./config-_lQI_W08.mjs";
-import { i as kgAdd, o as kgInvalidate, r as upsertKgEntity, s as kgQuery } from "./kg-entity-r8duqhi9.mjs";
-import { _ as workersLogDir, f as ensureNoMcpConfig, i as buildRunEnv, n as ensureProxyRunning, t as DEFAULT_PROXY_PORT, u as resolveTarget } from "./server-D4vAieF4.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { basename, join, resolve } from "node:path";
-
-//#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 = join(homedir(), ".claude", "projects");
-const PAI_CONFIG_DIR = join(homedir(), ".pai");
-const PAI_CONFIG_FILE = join(PAI_CONFIG_DIR, "config.json");
-function loadScanConfig() {
-	if (!existsSync(PAI_CONFIG_FILE)) return { scan_dirs: [] };
-	try {
-		return JSON.parse(readFileSync(PAI_CONFIG_FILE, "utf8"));
-	} catch {
-		return { scan_dirs: [] };
-	}
-}
-function saveScanConfig(config) {
-	mkdirSync(PAI_CONFIG_DIR, { recursive: true });
-	writeFileSync(PAI_CONFIG_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)) throw new Error(`Claude projects directory not found: ${CLAUDE_PROJECTS_DIR}`);
-	const entries = readdirSync(CLAUDE_PROJECTS_DIR).filter((name) => {
-		return statSync(join(CLAUDE_PROJECTS_DIR, 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, 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/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}
-
-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",
-		""
-	];
-}
-/** 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() {
-	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();
-	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();
-	});
-}
-/**
-* 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(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;
-	const cleaned = jsonOutput.replace(/^```json\s*/m, "").replace(/^```\s*/m, "").replace(/\s*```$/m, "").trim();
-	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) {
-		process.stderr.write(`[kg-extraction] JSON parse failed: ${e}\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/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
-	};
-}
-/** PAI_DIR — mirrors pai-paths.ts resolution. */
-function getPaiDir() {
-	const envDir = 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/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 { claudeProjectsDir as _, findLatestNote as a, transcriptFiles as b, extractAndStoreTriples as c, loadScanConfig as d, performScan as f, upsertSession as g, upsertProject as h, applyContinue as i, planLlmSpawn as l, saveScanConfig as m, writeContextHandoverCache as n, findNotesDir as o, resolveHome as p, appendCheckpointToNote as r, readBodyFile as s, readContextHandoverCache as t, cmdScan as u, findMovedProjects as v, scanTranscriptFolders as y };
-//# sourceMappingURL=context-handover-cache-pNFdBNrU.mjs.map