@tekmidian/pai 0.26.0 → 0.27.1

package/dist/checkpoint-block-o6WA_04D.mjs

@@ -0,0 +1,1263 @@
+import { _ as warn, c as ok, i as err, n as dim, r as encodeDir, s as now, t as bold } from "./utils-BAxjW3j8.mjs";
+import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "./migrate-fLD6rAdO.mjs";
+import { n as ensurePaiMarker, t as discoverPaiMarkers } from "./pai-marker-B20KqhA8.mjs";
+import { i as kgAdd, o as kgInvalidate, r as upsertKgEntity, s as kgQuery } from "./kg-entity-r8duqhi9.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } 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.exit(1);
+	}
+	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", "Matthias")
+- 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": "Matthias", "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": "Matthias", "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/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 (strips ANTHROPIC_API_KEY)
+*   - 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";
+}
+const CLAUDE_TIMEOUT_MS = {
+	haiku: 6e4,
+	sonnet: 12e4,
+	opus: 3e5
+};
+/**
+* Spawn the claude CLI with a prompt on stdin and return stdout.
+*
+* IMPORTANT: ANTHROPIC_API_KEY is stripped from the spawned environment so
+* the CLI uses the user's Max plan (free) instead of billing the API key.
+*/
+async function spawnClaude(prompt, model = "sonnet") {
+	const claudeBin = findClaudeBinary();
+	if (!claudeBin) {
+		process.stderr.write("[kg-extraction] claude CLI not found.\n");
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const { ANTHROPIC_API_KEY: _drop, ...envWithoutApiKey } = process.env;
+		const child = spawn(claudeBin, [
+			"--model",
+			model,
+			"-p",
+			"--no-session-persistence"
+		], {
+			env: envWithoutApiKey,
+			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] ${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] ${model} exited ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[kg-extraction] ${model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, CLAUDE_TIMEOUT_MS[model] ?? 12e4);
+		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 -->";
+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.
+*/
+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));
+	});
+}
+/**
+* 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;
+}
+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;
+	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 && !(opts.body ?? "").trim() && !isBoilerplateOnly(existing.lines)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta ?? void 0
+		};
+		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
+	};
+	const newContent = block + stripContinue(target.content).trimStart();
+	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
+	};
+}
+/** 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
+export { transcriptFiles as _, readBodyFile as a, loadScanConfig as c, saveScanConfig as d, upsertProject as f, scanTranscriptFolders as g, findMovedProjects as h, findNotesDir as i, performScan as l, claudeProjectsDir as m, applyContinue as n, extractAndStoreTriples as o, upsertSession as p, findLatestNote as r, cmdScan as s, appendCheckpointToNote as t, resolveHome as u };
+//# sourceMappingURL=checkpoint-block-o6WA_04D.mjs.map