@tekmidian/pai 0.19.0 → 0.20.1

package/dist/work-queue-worker-CEMpy89q.mjs

@@ -0,0 +1,1856 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as openFederation } from "./db-CYmBWcjh.mjs";
+import { l as performScan, n as applyContinue, o as extractAndStoreTriples$1 } from "./checkpoint-block-Cloxmin5.mjs";
+import { O as storageBackend, t as daemonConfig, u as registryDb } from "./state-DTvy-jRB.mjs";
+import { t as detectTopicShift } from "./detector-BGw8SNWe.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { basename as basename$1, join as join$1, resolve as resolve$1 } from "path";
+import { homedir as homedir$1 } from "os";
+
+//#region src/daemon/work-queue.ts
+/**
+* work-queue.ts — Persistent work queue for the PAI Daemon
+*
+* Provides a durable, file-backed queue that survives daemon restarts.
+* Items are processed sequentially to avoid concurrent writes to the same
+* session note. Failed items are retried with exponential backoff.
+*
+* Queue file: ~/.config/pai/work-queue.json
+* Written atomically (write temp → rename) to prevent corruption.
+*/
+const QUEUE_FILE = join(homedir(), ".config", "pai", "work-queue.json");
+const MAX_QUEUE_SIZE = 1e3;
+const MAX_QUEUE_FILE_BYTES = 1024 * 1024;
+const COMPLETED_TTL_MS = 3600 * 1e3;
+const FAILED_TTL_MS = 1440 * 60 * 1e3;
+/** Backoff delays in ms by attempt number (0-indexed). */
+const BACKOFF_MS = [
+	5e3,
+	3e4,
+	3e5
+];
+let _queue = [];
+let _dirty = false;
+/** Load queue from disk. Call once at daemon startup. */
+function loadQueue() {
+	if (!existsSync(QUEUE_FILE)) {
+		_queue = [];
+		return;
+	}
+	try {
+		const raw = readFileSync(QUEUE_FILE, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) {
+			process.stderr.write("[work-queue] Invalid queue file format — starting empty.\n");
+			_queue = [];
+			return;
+		}
+		_queue = parsed.map((item) => {
+			if (item.status === "processing") return {
+				...item,
+				status: "pending"
+			};
+			return item;
+		});
+		const stats = getStats();
+		process.stderr.write(`[work-queue] Loaded ${_queue.length} items from disk (pending=${stats.pending}, failed=${stats.failed}).\n`);
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not load queue file: ${e}\n`);
+		_queue = [];
+	}
+}
+/** Persist queue to disk atomically. */
+function saveQueue() {
+	const dir = dirname(QUEUE_FILE);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmpFile = QUEUE_FILE + ".tmp";
+	try {
+		writeFileSync(tmpFile, JSON.stringify(_queue, null, 2), "utf-8");
+		renameSync(tmpFile, QUEUE_FILE);
+		_dirty = false;
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not persist queue: ${e}\n`);
+	}
+}
+/** Persist only if there are unsaved changes. */
+function saveIfDirty() {
+	if (_dirty) saveQueue();
+}
+/**
+* Enforce the maximum queue size cap.
+* Strategy: first drop oldest completed, then oldest low-priority pending.
+*/
+function enforceMaxSize() {
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const excess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropCompleted = _queue.filter((i) => i.status === "completed").sort((a, b) => a.createdAt.localeCompare(b.createdAt)).slice(0, excess);
+	const dropIds = new Set(toDropCompleted.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropIds.has(i.id));
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const remainingExcess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropLow = _queue.filter((i) => i.status === "pending" && i.priority >= 4).sort((a, b) => a.priority - b.priority || a.createdAt.localeCompare(b.createdAt)).slice(0, remainingExcess);
+	const dropLowIds = new Set(toDropLow.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropLowIds.has(i.id));
+	process.stderr.write(`[work-queue] Pruned queue to ${_queue.length} items (cap=${MAX_QUEUE_SIZE}).\n`);
+}
+/**
+* Add a new work item to the queue.
+* Returns the created WorkItem.
+*/
+function enqueue(params) {
+	const item = {
+		id: randomUUID(),
+		type: params.type,
+		priority: params.priority ?? 3,
+		payload: params.payload,
+		status: "pending",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		attempts: 0,
+		maxAttempts: params.maxAttempts ?? 3
+	};
+	_queue.push(item);
+	enforceMaxSize();
+	_dirty = true;
+	saveIfDirty();
+	process.stderr.write(`[work-queue] Enqueued ${item.type} (id=${item.id}, priority=${item.priority}).\n`);
+	return item;
+}
+/**
+* Pick the next pending item that is ready to process (respects nextRetryAt).
+* Returns null if no eligible item exists.
+* Highest priority (lowest number) is processed first; ties broken by createdAt.
+*/
+function dequeue() {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const eligible = _queue.filter((i) => {
+		if (i.status !== "pending") return false;
+		if (i.nextRetryAt && i.nextRetryAt > now) return false;
+		return true;
+	}).sort((a, b) => {
+		if (a.priority !== b.priority) return a.priority - b.priority;
+		return a.createdAt.localeCompare(b.createdAt);
+	});
+	if (eligible.length === 0) return null;
+	const item = eligible[0];
+	item.status = "processing";
+	item.attempts += 1;
+	_dirty = true;
+	saveIfDirty();
+	return item;
+}
+/**
+* Mark an item as completed.
+*/
+function markCompleted(id) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.status = "completed";
+	item.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+	item.error = void 0;
+	_dirty = true;
+	saveIfDirty();
+}
+/**
+* Mark an item as failed.
+* If attempts < maxAttempts, schedules a retry with exponential backoff.
+* Otherwise, leaves status as 'failed'.
+*/
+function markFailed(id, errorMsg) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.error = errorMsg;
+	if (item.attempts < item.maxAttempts) {
+		const backoffMs = BACKOFF_MS[item.attempts - 1] ?? BACKOFF_MS[BACKOFF_MS.length - 1];
+		item.status = "pending";
+		item.nextRetryAt = new Date(Date.now() + backoffMs).toISOString();
+		process.stderr.write(`[work-queue] Item ${id} failed (attempt ${item.attempts}/${item.maxAttempts}), retry in ${backoffMs / 1e3}s: ${errorMsg}\n`);
+	} else {
+		item.status = "failed";
+		process.stderr.write(`[work-queue] Item ${id} exhausted retries (${item.maxAttempts} attempts): ${errorMsg}\n`);
+	}
+	_dirty = true;
+	saveIfDirty();
+}
+function getStats() {
+	const stats = {
+		pending: 0,
+		processing: 0,
+		completed: 0,
+		failed: 0,
+		total: _queue.length
+	};
+	for (const item of _queue) stats[item.status]++;
+	return stats;
+}
+/**
+* Returns true if any pending or processing item of the given type exists.
+* Used for debouncing work items that are expensive to run concurrently.
+*/
+function hasPendingOrProcessingOfType(type) {
+	return _queue.some((i) => i.type === type && (i.status === "pending" || i.status === "processing"));
+}
+/**
+* Remove completed and permanently-failed items older than their TTL.
+* Also force-cleans all completed items if the queue file exceeds 1 MB.
+*/
+function cleanup() {
+	const now = Date.now();
+	const before = _queue.length;
+	let forceCleanCompleted = false;
+	try {
+		if (existsSync(QUEUE_FILE)) {
+			const { size } = statSync(QUEUE_FILE);
+			if (size > MAX_QUEUE_FILE_BYTES) {
+				forceCleanCompleted = true;
+				process.stderr.write(`[work-queue] Queue file exceeds 1 MB (${size} bytes) — force-cleaning completed items.\n`);
+			}
+		}
+	} catch {}
+	_queue = _queue.filter((item) => {
+		if (item.status === "completed") {
+			if (forceCleanCompleted) return false;
+			return now - (item.completedAt ? new Date(item.completedAt).getTime() : 0) < COMPLETED_TTL_MS;
+		}
+		if (item.status === "failed") return now - new Date(item.createdAt).getTime() < FAILED_TTL_MS;
+		return true;
+	});
+	const removed = before - _queue.length;
+	const stats = getStats();
+	if (removed > 0 || before === 0) process.stderr.write(`[work-queue] Cleanup: removed ${removed} items. Queue stats: pending=${stats.pending}, processing=${stats.processing}, completed=${stats.completed}, failed=${stats.failed}.\n`);
+	_dirty = removed > 0;
+	saveIfDirty();
+}
+
+//#endregion
+//#region src/hooks/ts/lib/pai-paths.ts
+/**
+* PAI Path Resolution - Single Source of Truth
+*
+* This module provides consistent path resolution across all PAI hooks.
+* It handles PAI_DIR detection whether set explicitly or defaulting to ~/.claude
+*
+* ALSO loads .env file from PAI_DIR so all hooks get environment variables
+* without relying on Claude Code's settings.json injection.
+*
+* Usage in hooks:
+*   import { PAI_DIR, HOOKS_DIR, SKILLS_DIR } from './lib/pai-paths';
+*/
+/**
+* Load .env file and inject into process.env
+* Must run BEFORE PAI_DIR resolution so .env can set PAI_DIR if needed
+*/
+function loadEnvFile() {
+	const possiblePaths = [resolve$1(process.env.PAI_DIR || "", ".env"), resolve$1(homedir$1(), ".claude", ".env")];
+	for (const envPath of possiblePaths) if (existsSync$1(envPath)) try {
+		const content = readFileSync$1(envPath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex > 0) {
+				const key = trimmed.substring(0, eqIndex).trim();
+				let value = trimmed.substring(eqIndex + 1).trim();
+				if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+				value = value.replace(/\$HOME/g, homedir$1());
+				value = value.replace(/^~(?=\/|$)/, homedir$1());
+				if (process.env[key] === void 0) process.env[key] = value;
+			}
+		}
+		break;
+	} catch {}
+}
+loadEnvFile();
+/**
+* Smart PAI_DIR detection with fallback
+* Priority:
+* 1. PAI_DIR environment variable (if set)
+* 2. ~/.claude (standard location)
+*/
+const PAI_DIR = process.env.PAI_DIR ? resolve$1(process.env.PAI_DIR) : resolve$1(homedir$1(), ".claude");
+/**
+* Common PAI directories
+*/
+const HOOKS_DIR = join$1(PAI_DIR, "Hooks");
+const SKILLS_DIR = join$1(PAI_DIR, "Skills");
+const AGENTS_DIR = join$1(PAI_DIR, "Agents");
+const HISTORY_DIR = join$1(PAI_DIR, "History");
+const COMMANDS_DIR = join$1(PAI_DIR, "Commands");
+/**
+* Validate PAI directory structure on first import
+* This fails fast with a clear error if PAI is misconfigured
+*/
+function validatePAIStructure() {
+	if (!existsSync$1(PAI_DIR)) {
+		console.error(`PAI_DIR does not exist: ${PAI_DIR}`);
+		console.error(`   Expected ~/.claude or set PAI_DIR environment variable`);
+		process.exit(1);
+	}
+	if (!existsSync$1(HOOKS_DIR)) {
+		console.error(`PAI hooks directory not found: ${HOOKS_DIR}`);
+		console.error(`   Your PAI_DIR may be misconfigured`);
+		console.error(`   Current PAI_DIR: ${PAI_DIR}`);
+		process.exit(1);
+	}
+}
+validatePAIStructure();
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/paths.ts
+/**
+* Path utilities — encoding, Notes/Sessions directory discovery and creation.
+*/
+const PROJECTS_DIR = join$1(PAI_DIR, "projects");
+/**
+* Encode a path the same way Claude Code does:
+* - Replace / with -
+* - Replace . with -
+* - Replace space with -
+*/
+function encodePath(path) {
+	return path.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+}
+/** Get the project directory for a given working directory. */
+function getProjectDir(cwd) {
+	return join$1(PROJECTS_DIR, encodePath(cwd));
+}
+/** Get the Notes directory for a project (central location). */
+function getNotesDir(cwd) {
+	return join$1(getProjectDir(cwd), "Notes");
+}
+/**
+* Find Notes directory — checks local first, falls back to central.
+* Does NOT create the directory.
+*/
+function findNotesDir(cwd) {
+	if (basename$1(cwd).toLowerCase() === "notes" && existsSync$1(cwd)) return {
+		path: cwd,
+		isLocal: true
+	};
+	const localPaths = [
+		join$1(cwd, "Notes"),
+		join$1(cwd, "notes"),
+		join$1(cwd, ".claude", "Notes")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return {
+		path,
+		isLocal: true
+	};
+	return {
+		path: getNotesDir(cwd),
+		isLocal: false
+	};
+}
+/** Get the sessions/ directory from a project directory path. */
+function getSessionsDirFromProjectDir(projectDir) {
+	return join$1(projectDir, "sessions");
+}
+/** Ensure the sessions/ directory exists (from project dir path). */
+function ensureSessionsDirFromProjectDir(projectDir) {
+	const sessionsDir = getSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(sessionsDir)) {
+		mkdirSync$1(sessionsDir, { recursive: true });
+		console.error(`Created sessions directory: ${sessionsDir}`);
+	}
+	return sessionsDir;
+}
+/**
+* Move all .jsonl session files from project root to sessions/ subdirectory.
+* Returns the number of files moved.
+*/
+function moveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
+	const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(projectDir)) return 0;
+	const files = readdirSync$1(projectDir);
+	let movedCount = 0;
+	for (const file of files) if (file.endsWith(".jsonl") && file !== excludeFile) {
+		const sourcePath = join$1(projectDir, file);
+		const destPath = join$1(sessionsDir, file);
+		try {
+			renameSync$1(sourcePath, destPath);
+			if (!silent) console.error(`Moved ${file} → sessions/`);
+			movedCount++;
+		} catch (error) {
+			if (!silent) console.error(`Could not move ${file}: ${error}`);
+		}
+	}
+	return movedCount;
+}
+/** Find TODO.md — check local first, fallback to central. */
+function findTodoPath(cwd) {
+	const localPaths = [
+		join$1(cwd, "TODO.md"),
+		join$1(cwd, "notes", "TODO.md"),
+		join$1(cwd, "Notes", "TODO.md"),
+		join$1(cwd, ".claude", "TODO.md")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return path;
+	return join$1(getNotesDir(cwd), "TODO.md");
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/session-notes.ts
+/**
+* Session note creation, editing, checkpointing, renaming, and finalization.
+*/
+/** Get or create the YYYY/MM subdirectory for the current month inside notesDir. */
+function getMonthDir(notesDir) {
+	const now = /* @__PURE__ */ new Date();
+	const monthDir = join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0"));
+	if (!existsSync$1(monthDir)) mkdirSync$1(monthDir, { recursive: true });
+	return monthDir;
+}
+/**
+* Get the next note number (4-digit format: 0001, 0002, etc.).
+* Numbers are scoped per YYYY/MM directory.
+*/
+function getNextNoteNumber(notesDir) {
+	const files = readdirSync$1(getMonthDir(notesDir)).filter((f) => f.match(/^\d{3,4}[\s_-]/)).sort();
+	if (files.length === 0) return "0001";
+	let maxNumber = 0;
+	for (const file of files) {
+		const digitMatch = file.match(/^(\d+)/);
+		if (digitMatch) {
+			const num = parseInt(digitMatch[1], 10);
+			if (num > maxNumber) maxNumber = num;
+		}
+	}
+	return String(maxNumber + 1).padStart(4, "0");
+}
+/**
+* Get the current (latest) note file path, or null if none exists.
+* Searches current month → previous month → flat notesDir (legacy).
+*/
+function getCurrentNotePath(notesDir) {
+	if (!existsSync$1(notesDir)) return null;
+	const findLatestIn = (dir) => {
+		if (!existsSync$1(dir)) return null;
+		const files = readdirSync$1(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] || "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] || "0", 10);
+		});
+		if (files.length === 0) return null;
+		return join$1(dir, files[files.length - 1]);
+	};
+	const now = /* @__PURE__ */ new Date();
+	const found = findLatestIn(join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (found) return found;
+	const prevDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findLatestIn(join$1(notesDir, String(prevDate.getFullYear()), String(prevDate.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findLatestIn(notesDir);
+}
+/**
+* Create a new session note.
+* Format: "NNNN - YYYY-MM-DD - New Session.md" filed into YYYY/MM subdirectory.
+* Claude MUST rename at session end with a meaningful description.
+*/
+function createSessionNote(notesDir, description) {
+	const noteNumber = getNextNoteNumber(notesDir);
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const monthDir = getMonthDir(notesDir);
+	const filename = `${noteNumber} - ${date} - New Session.md`;
+	const filepath = join$1(monthDir, filename);
+	writeFileSync$1(filepath, `# Session ${noteNumber}: ${description}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+<!-- PAI will add completed work here during session -->
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`);
+	console.error(`Created session note: ${filename}`);
+	return filepath;
+}
+/** Append a checkpoint to the current session note. */
+function appendCheckpoint(notePath, checkpoint) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found, recreating: ${notePath}`);
+		try {
+			const parentDir = join$1(notePath, "..");
+			if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+			const noteFilename = basename$1(notePath);
+			const numberMatch = noteFilename.match(/^(\d+)/);
+			writeFileSync$1(notePath, `# Session ${numberMatch ? numberMatch[1] : "0000"}: Recovered\n\n**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}\n**Status:** In Progress\n\n---\n\n## Work Done\n\n<!-- PAI will add completed work here during session -->\n\n---\n\n## Next Steps\n\n<!-- To be filled at session end -->\n\n---\n\n**Tags:** #Session\n`);
+			console.error(`Recreated session note: ${noteFilename}`);
+		} catch (err) {
+			console.error(`Failed to recreate note: ${err}`);
+			return;
+		}
+	}
+	const content = readFileSync$1(notePath, "utf-8");
+	const checkpointText = `\n### Checkpoint ${(/* @__PURE__ */ new Date()).toISOString()}\n\n${checkpoint}\n`;
+	const nextStepsIndex = content.indexOf("## Next Steps");
+	writeFileSync$1(notePath, nextStepsIndex !== -1 ? content.substring(0, nextStepsIndex) + checkpointText + content.substring(nextStepsIndex) : content + checkpointText);
+	console.error(`Checkpoint added to: ${basename$1(notePath)}`);
+}
+/** Add work items to the "Work Done" section of a session note. */
+function addWorkToSessionNote(notePath, workItems, sectionTitle) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	let workText = "";
+	if (sectionTitle) workText += `\n### ${sectionTitle}\n\n`;
+	for (const item of workItems) {
+		const checkbox = item.completed !== false ? "[x]" : "[ ]";
+		workText += `- ${checkbox} **${item.title}**\n`;
+		if (item.details && item.details.length > 0) for (const detail of item.details) workText += `  - ${detail}\n`;
+	}
+	const workDoneMatch = content.match(/## Work Done\n\n(<!-- .*? -->)?/);
+	if (workDoneMatch) {
+		const insertPoint = content.indexOf(workDoneMatch[0]) + workDoneMatch[0].length;
+		content = content.substring(0, insertPoint) + workText + content.substring(insertPoint);
+	} else {
+		const nextStepsIndex = content.indexOf("## Next Steps");
+		if (nextStepsIndex !== -1) content = content.substring(0, nextStepsIndex) + workText + "\n" + content.substring(nextStepsIndex);
+	}
+	writeFileSync$1(notePath, content);
+	console.error(`Added ${workItems.length} work item(s) to: ${basename$1(notePath)}`);
+}
+/** Sanitize a string for use in a filename. */
+function sanitizeForFilename(str) {
+	return str.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+/**
+* Return true if the candidate string should be rejected as a meaningful name.
+* Rejects file paths, shebangs, timestamps, system noise, XML tags, hashes, etc.
+*/
+function isMeaninglessCandidate(text) {
+	const t = text.trim();
+	if (!t) return true;
+	if (t.length < 5) return true;
+	if (t.startsWith("/") || t.startsWith("~")) return true;
+	if (t.startsWith("#!")) return true;
+	if (t.includes("[object Object]")) return true;
+	if (/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]+)?$/.test(t)) return true;
+	if (/^\d{1,2}:\d{2}(:\d{2})?(\s*(AM|PM))?$/i.test(t)) return true;
+	if (/^<[a-z-]+[\s/>]/i.test(t)) return true;
+	if (/^[0-9a-f]{10,}$/i.test(t)) return true;
+	if (/^Exit code \d+/i.test(t)) return true;
+	if (/^Error:/i.test(t)) return true;
+	if (/^This session is being continued/i.test(t)) return true;
+	if (/^\(Bash completed/i.test(t)) return true;
+	if (/^Task Notification$/i.test(t)) return true;
+	if (/^New Session$/i.test(t)) return true;
+	if (/^Recovered Session$/i.test(t)) return true;
+	if (/^Continued Session$/i.test(t)) return true;
+	if (/^Untitled Session$/i.test(t)) return true;
+	if (/^Context Compression$/i.test(t)) return true;
+	if (/^[A-Fa-f0-9]{8,}\s+Output$/i.test(t)) return true;
+	return false;
+}
+/**
+* Extract a meaningful name from session note content and summary.
+* Looks at Work Done section headers, bold text, and summary.
+*/
+function extractMeaningfulName(noteContent, summary) {
+	const workDoneMatch = noteContent.match(/## Work Done\n\n([\s\S]*?)(?=\n---|\n## Next)/);
+	if (workDoneMatch) {
+		const workDoneSection = workDoneMatch[1];
+		const subheadings = workDoneSection.match(/### ([^\n]+)/g);
+		if (subheadings && subheadings.length > 0) {
+			const firstHeading = subheadings[0].replace("### ", "").trim();
+			if (!isMeaninglessCandidate(firstHeading) && firstHeading.length > 5 && firstHeading.length < 60) return sanitizeForFilename(firstHeading);
+		}
+		const boldMatches = workDoneSection.match(/\*\*([^*]+)\*\*/g);
+		if (boldMatches && boldMatches.length > 0) {
+			const firstBold = boldMatches[0].replace(/\*\*/g, "").trim();
+			if (!isMeaninglessCandidate(firstBold) && firstBold.length > 3 && firstBold.length < 50) return sanitizeForFilename(firstBold);
+		}
+		const numberedItems = workDoneSection.match(/^\d+\.\s+\*\*([^*]+)\*\*/m);
+		if (numberedItems && !isMeaninglessCandidate(numberedItems[1])) return sanitizeForFilename(numberedItems[1]);
+	}
+	if (summary && summary.length > 5 && summary !== "Session completed." && !isMeaninglessCandidate(summary)) {
+		const cleanSummary = summary.replace(/[^\w\s-]/g, " ").trim().split(/\s+/).slice(0, 5).join(" ");
+		if (cleanSummary.length > 3 && !isMeaninglessCandidate(cleanSummary)) return sanitizeForFilename(cleanSummary);
+	}
+	return "";
+}
+/**
+* Rename a session note with a meaningful name.
+* Always uses "NNNN - YYYY-MM-DD - Description.md" format.
+* Returns the new path, or original path if rename fails.
+*/
+function renameSessionNote(notePath, meaningfulName) {
+	if (!meaningfulName || !existsSync$1(notePath)) return notePath;
+	const dir = join$1(notePath, "..");
+	const oldFilename = basename$1(notePath);
+	const correctMatch = oldFilename.match(/^(\d{3,4}) - (\d{4}-\d{2}-\d{2}) - .*\.md$/);
+	const legacyMatch = oldFilename.match(/^(\d{3,4})_(\d{4}-\d{2}-\d{2})_.*\.md$/);
+	const match = correctMatch || legacyMatch;
+	if (!match) return notePath;
+	const [, noteNumber, date] = match;
+	const titleCaseName = meaningfulName.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
+	const newFilename = `${noteNumber.padStart(4, "0")} - ${date} - ${titleCaseName}.md`;
+	const newPath = join$1(dir, newFilename);
+	if (newFilename === oldFilename) return notePath;
+	try {
+		renameSync$1(notePath, newPath);
+		console.error(`Renamed note: ${oldFilename} → ${newFilename}`);
+		return newPath;
+	} catch (error) {
+		console.error(`Could not rename note: ${error}`);
+		return notePath;
+	}
+}
+/**
+* Finalize session note — mark as complete, add summary, rename with meaningful name.
+* IDEMPOTENT: subsequent calls are no-ops if already finalized.
+* Returns the final path (may be renamed).
+*/
+function finalizeSessionNote(notePath, summary) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return notePath;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	if (content.includes("**Status:** Completed")) {
+		console.error(`Note already finalized: ${basename$1(notePath)}`);
+		return notePath;
+	}
+	content = content.replace("**Status:** In Progress", "**Status:** Completed");
+	if (!content.includes("**Completed:**")) {
+		const completionTime = (/* @__PURE__ */ new Date()).toISOString();
+		content = content.replace("---\n\n## Work Done", `**Completed:** ${completionTime}\n\n---\n\n## Work Done`);
+	}
+	const nextStepsMatch = content.match(/## Next Steps\n\n(<!-- .*? -->)/);
+	if (nextStepsMatch) content = content.replace(nextStepsMatch[0], `## Next Steps\n\n${summary || "Session completed."}`);
+	writeFileSync$1(notePath, content);
+	console.error(`Session note finalized: ${basename$1(notePath)}`);
+	const meaningfulName = extractMeaningfulName(content, summary);
+	if (meaningfulName) return renameSessionNote(notePath, meaningfulName);
+	return notePath;
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/todo.ts
+/**
+* TODO.md management — creation, task updates, checkpoints, and Continue section.
+*/
+/**
+* Ensure TODO.md exists. Creates it with default structure if missing.
+* Returns the path to the TODO.md file.
+*/
+function ensureTodoMd(cwd) {
+	const todoPath = findTodoPath(cwd);
+	if (!existsSync$1(todoPath)) {
+		const parentDir = join$1(todoPath, "..");
+		if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+		writeFileSync$1(todoPath, `# TODO
+
+## Current Session
+
+- [ ] (Tasks will be tracked here)
+
+## Backlog
+
+- [ ] (Future tasks)
+
+---
+
+*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`);
+		console.error(`Created TODO.md: ${todoPath}`);
+	}
+	return todoPath;
+}
+/**
+* Update the ## Continue section at the top of TODO.md.
+*
+* This is the unattended writer: the pre-compact hook and the daemon's
+* work-queue worker both come through here. It used to build its own block and
+* strip the existing section with `/## Continue\n[\s\S]*?\n---\n+/` — a
+* non-greedy match to the first `---`, which cuts a rich checkpoint in half at
+* the first horizontal rule inside its body and leaves the remainder orphaned
+* in the document.
+*
+* More importantly it was the writer that actually destroyed model-authored
+* checkpoints: `pai pause` wrote one, then this ran seconds later on session
+* end and replaced it with `Working directory: … Check the latest session note
+* for details.`
+*
+* It now delegates to the shared checkpoint module in "auto" mode, which means
+* it inherits the preservation rules rather than reimplementing them. Guarding
+* here rather than at each of the three call sites is deliberate: any future
+* caller inherits the behaviour without knowing it exists.
+*/
+function updateTodoContinue(cwd, noteFilename, state, tokenDisplay) {
+	ensureTodoMd(cwd);
+	const result = applyContinue({
+		rootPath: cwd,
+		authored: "auto",
+		sessionLine: noteFilename.replace(/\.md$/, ""),
+		cwd,
+		body: state?.trim() || void 0
+	});
+	if (result.action === "preserved") {
+		console.error("TODO.md ## Continue left intact — authored checkpoint for this session");
+		return;
+	}
+	if (result.action === "failed") {
+		console.error(`TODO.md ## Continue update failed: ${result.error}`);
+		return;
+	}
+	try {
+		const todoPath = result.path;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let content = readFileSync$1(todoPath, "utf-8");
+		content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
+		content = content.trimEnd() + `\n\n---\n\n*Last updated: ${now}*\n`;
+		writeFileSync$1(todoPath, content);
+	} catch {}
+	console.error(result.carriedForward ? "TODO.md ## Continue section updated (previous content carried forward)" : "TODO.md ## Continue section updated");
+}
+
+//#endregion
+//#region src/daemon/templates/session-summary-prompt.ts
+/**
+* Build the prompt string to send to the summarizer model.
+*
+* Returns a single string suitable for piping to `claude --model <model> --print`.
+*/
+function buildSessionSummaryPrompt(params) {
+	const { userMessages, gitLog, cwd, date, filesModified, existingNote } = params;
+	const userSection = userMessages.length > 0 ? userMessages.map((m, i) => `[${i + 1}] ${m}`).join("\n\n") : "(No user messages extracted)";
+	const gitSection = gitLog.trim() || "(No git commits during this session)";
+	const filesSection = filesModified && filesModified.length > 0 ? filesModified.map((f) => `- ${f}`).join("\n") : "";
+	return `You are summarizing a coding session. Given the user messages and git commits below, write a session note.
+
+Project directory: ${cwd}
+Date: ${date}
+
+Focus on:
+- What problems were encountered and how they were solved
+- Key architectural decisions and their rationale
+- What was built (reference actual files and code patterns)
+- What was left unfinished or needs follow-up
+
+Do NOT include:
+- Mechanical metadata (token counts, checkpoint timestamps)
+- System messages or tool results verbatim
+- Generic descriptions — be specific about what happened
+- Markdown frontmatter or YAML headers
+${existingNote ? `\nAn existing session note is provided below. Merge the new information into it,
+preserving what was already written. Add new work items and update the summary.
+Do NOT duplicate existing content.
+
+EXISTING NOTE:
+${existingNote}
+` : ""}
+Format your response EXACTLY as follows (no extra text before or after):
+
+TOPIC: [A short topic label, max 60 characters, describing the WORK DONE — not quoting user messages. Format as "Topic1, Topic2, and Topic3" if multiple themes. Example: "Session Summary Worker, Topic Detection"]
+
+# Session: [Descriptive title summarizing what was ACCOMPLISHED, max 60 characters. Describe the work done, not the user's request. Bad: "Dark Mode Button Does Nothing". Good: "Dark Mode Toggle, Keyboard IPC, and Audio Fix"]
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+[Organize by theme, not chronologically. Group related work under descriptive bullet points.
+Use checkbox format: - [x] for completed items, - [ ] for incomplete items.
+Include specific file names, function names, and technical details.]
+
+## Key Decisions
+
+[List important choices made during the session with brief rationale.
+Skip this section entirely if no significant decisions were made.]
+
+## Known Issues
+
+[What was left unfinished, bugs discovered, or follow-up items needed.
+Skip this section entirely if nothing is pending.]
+
+---
+
+USER MESSAGES:
+${userSection}
+
+GIT COMMITS:
+${gitSection}
+${filesSection ? `\nFILES MODIFIED:\n${filesSection}` : ""}`;
+}
+
+//#endregion
+//#region src/daemon/session-summary-worker.ts
+/**
+* session-summary-worker.ts — AI-powered session note generation
+*
+* Processes `session-summary` work items by:
+*   1. Finding the current session's JSONL transcript
+*   2. Extracting user messages and assistant context
+*   3. Gathering git commits from the session period
+*   4. Spawning Claude (sonnet for compaction, opus for session end) to generate a structured summary
+*   5. Comparing the new topic against the existing note's topic
+*   6. Creating a NEW note if the topic shifted, or updating the existing one
+*
+* Topic detection: the summarizer outputs a TOPIC: line as the first line of
+* its response. This is compared against the existing note's title using word
+* overlap. If overlap is below ~30%, a new note is created.
+*
+* Designed to run inside the daemon's work queue worker. All errors are
+* thrown (not swallowed) so the work queue retry logic handles them.
+*/
+/** Minimum interval between summaries for the same project (ms). */
+const SUMMARY_COOLDOWN_MS = 1800 * 1e3;
+/** Maximum JSONL content to feed to the summarizer (characters). */
+/** Max JSONL chars per model. Opus/Sonnet can handle much more than Haiku. */
+const MAX_JSONL_CHARS = {
+	haiku: 5e4,
+	sonnet: 2e5,
+	opus: 5e5
+};
+/** Maximum user messages to include in the prompt. */
+const MAX_USER_MESSAGES = 30;
+/** Timeout for the claude CLI process (ms). */
+const CLAUDE_TIMEOUT_MS = {
+	haiku: 6e4,
+	sonnet: 12e4,
+	opus: 3e5
+};
+/** File tracking last summary timestamps per project. */
+const COOLDOWN_FILE = join(homedir(), ".config", "pai", "summary-cooldowns.json");
+/** Claude Code projects directory. */
+const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+function loadCooldowns() {
+	try {
+		if (existsSync(COOLDOWN_FILE)) return JSON.parse(readFileSync(COOLDOWN_FILE, "utf-8"));
+	} catch {}
+	return {};
+}
+function saveCooldowns(cooldowns) {
+	try {
+		writeFileSync(COOLDOWN_FILE, JSON.stringify(cooldowns, null, 2), "utf-8");
+	} catch {}
+}
+function isOnCooldown(cwd) {
+	const lastRun = loadCooldowns()[cwd];
+	if (!lastRun) return false;
+	return Date.now() - lastRun < SUMMARY_COOLDOWN_MS;
+}
+function markCooldown(cwd) {
+	const cooldowns = loadCooldowns();
+	cooldowns[cwd] = Date.now();
+	const cutoff = Date.now() - 1440 * 60 * 1e3;
+	for (const key of Object.keys(cooldowns)) if (cooldowns[key] < cutoff) delete cooldowns[key];
+	saveCooldowns(cooldowns);
+}
+/**
+* Encode a cwd path the same way Claude Code does for its project directories.
+* Replaces /, space, dot, and hyphen with -.
+*/
+function encodeProjectPath(cwd) {
+	return cwd.replace(/[\/\s.\-]/g, "-");
+}
+/**
+* Find the most recently modified JSONL file for the given project.
+*
+* Claude Code stores transcripts in:
+*   ~/.claude/projects/<encoded-path>/sessions/*.jsonl
+*   ~/.claude/projects/<encoded-path>/<uuid>.jsonl (legacy)
+*/
+function findLatestJsonl(cwd) {
+	const projectDir = join(CLAUDE_PROJECTS_DIR, encodeProjectPath(cwd));
+	if (!existsSync(projectDir)) {
+		process.stderr.write(`[session-summary] No Claude project dir found: ${projectDir}\n`);
+		return null;
+	}
+	const candidates = [];
+	const sessionsDir = join(projectDir, "sessions");
+	if (existsSync(sessionsDir)) try {
+		for (const f of readdirSync(sessionsDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(sessionsDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	try {
+		for (const f of readdirSync(projectDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(projectDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	if (candidates.length === 0) {
+		process.stderr.write(`[session-summary] No JSONL files found in ${projectDir}\n`);
+		return null;
+	}
+	candidates.sort((a, b) => b.mtime - a.mtime);
+	return candidates[0].path;
+}
+/**
+* Parse a JSONL transcript and extract relevant content.
+* Filters noise, truncates to model-appropriate size from the end of the file.
+*/
+function extractFromJsonl(jsonlPath, model = "sonnet") {
+	const result = {
+		userMessages: [],
+		filesModified: [],
+		sessionStartTime: ""
+	};
+	let raw;
+	try {
+		raw = readFileSync(jsonlPath, "utf-8");
+	} catch (e) {
+		throw new Error(`Could not read JSONL at ${jsonlPath}: ${e}`);
+	}
+	const maxChars = MAX_JSONL_CHARS[model] ?? 2e5;
+	if (raw.length > maxChars) {
+		const truncPoint = raw.indexOf("\n", raw.length - maxChars);
+		raw = truncPoint >= 0 ? raw.slice(truncPoint + 1) : raw.slice(-MAX_JSONL_CHARS);
+	}
+	const lines = raw.trim().split("\n");
+	const seenMessages = /* @__PURE__ */ new Set();
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry.timestamp && !result.sessionStartTime) result.sessionStartTime = String(entry.timestamp);
+		if (entry.type === "user") {
+			const msg = entry.message;
+			if (msg?.content) {
+				const text = contentToText$2(msg.content);
+				if (text && !isNoise(text) && !seenMessages.has(text)) {
+					seenMessages.add(text);
+					result.userMessages.push(text.slice(0, 500));
+				}
+			}
+		}
+		if (entry.type === "assistant") {
+			const msg = entry.message;
+			if (msg?.content && Array.isArray(msg.content)) {
+				for (const block of msg.content) if (block.type === "tool_use") {
+					const name = block.name;
+					const input = block.input;
+					if ((name === "Edit" || name === "Write") && input?.file_path) {
+						const fp = String(input.file_path);
+						if (!result.filesModified.includes(fp)) result.filesModified.push(fp);
+					}
+				}
+			}
+		}
+	}
+	if (result.userMessages.length > MAX_USER_MESSAGES) result.userMessages = result.userMessages.slice(-MAX_USER_MESSAGES);
+	return result;
+}
+/** Convert Claude content (string or content block array) to plain text. */
+function contentToText$2(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		if (typeof c === "string") return c;
+		const block = c;
+		if (block?.text) return String(block.text);
+		if (block?.content) return String(block.content);
+		return "";
+	}).join(" ").trim();
+	return "";
+}
+/** Filter out noise entries that shouldn't be included in the summary. */
+function isNoise(text) {
+	if (!text || text.length < 3) return true;
+	if (text.includes("<task-notification>")) return true;
+	if (text.includes("[object Object]")) return true;
+	if (text.startsWith("<system-reminder>")) return true;
+	if (/^(yes|ok|sure|go|continue|weiter|thanks|thank you)\.?$/i.test(text.trim())) return true;
+	if (text.startsWith("Tool Result:") || text.startsWith("tool_result")) return true;
+	return false;
+}
+/**
+* Get git log for the session period.
+* Falls back gracefully if git is not available or the dir is not a repo.
+*/
+async function getGitContext(cwd, sinceTime) {
+	let since = "6 hours ago";
+	if (sinceTime) {
+		const asNum = Number(sinceTime);
+		if (!isNaN(asNum) && asNum > 1e9) since = (/* @__PURE__ */ new Date(asNum * 1e3)).toISOString();
+		else since = sinceTime;
+	}
+	try {
+		const { execFile: execFileCb } = await import("node:child_process");
+		const { promisify } = await import("node:util");
+		const { stdout } = await promisify(execFileCb)("git", [
+			"log",
+			"--format=%h %ai %s",
+			`--since=${since}`,
+			"--stat",
+			"--no-color"
+		], {
+			cwd,
+			timeout: 1e4,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Find the `claude` CLI binary.
+* Checks PATH first, then common installation locations.
+*/
+function findClaudeBinary() {
+	const candidates = [
+		join(homedir(), ".local", "bin", "claude"),
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude"
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return "claude";
+}
+/**
+* Spawn a Claude model via the CLI to generate a session summary.
+* Pipes the prompt via stdin. Model selection:
+*   - opus: session end (best quality for final summary, runs once)
+*   - sonnet: auto-compaction (good quality for incremental checkpoints, runs often)
+*   - haiku: fallback / budget mode
+* Returns the generated text, or null if spawning fails.
+*/
+async function spawnSummarizer(prompt, model = "sonnet") {
+	const claudeBin = findClaudeBinary();
+	if (!claudeBin) {
+		process.stderr.write("[session-summary] Claude CLI not found in PATH or common locations.\n");
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const { ANTHROPIC_API_KEY: _, ...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(`[session-summary] ${model} spawn error: ${err.message}\n`);
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (code !== 0) {
+				process.stderr.write(`[session-summary] ${model} exited with code ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[session-summary] ${model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, CLAUDE_TIMEOUT_MS[model] ?? 12e4);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Extract the TOPIC: line from the summarizer output.
+* Returns the topic string, or null if not found.
+*/
+function extractTopic(summaryText) {
+	const match = summaryText.match(/^TOPIC:\s*(.+)$/m);
+	if (!match) return null;
+	return match[1].trim();
+}
+/**
+* Extract the topic from an existing session note.
+* First checks for a <!-- TOPIC: ... --> comment (stored by previous summaries).
+* Falls back to the H1 "# Session NNNN: Title" line.
+*
+* The HTML comment is the reliable source because the H1 gets renamed by
+* renameSessionNote, which can add/change words and cause false topic shifts.
+*/
+function extractExistingNoteTitle(notePath) {
+	try {
+		const content = readFileSync(notePath, "utf-8");
+		const topicComment = content.match(/<!-- TOPIC:\s*(.+?)\s*-->/);
+		if (topicComment) return topicComment[1].trim();
+		const match = content.match(/^# Session \d+:\s*(.+)$/m);
+		if (match) return match[1].trim();
+	} catch {}
+	return null;
+}
+/**
+* Compute word overlap ratio between two topic strings.
+* Returns a value in [0, 1] — 1.0 means identical word sets.
+*
+* Uses lowercased, normalized words. Stop words and very short words
+* are excluded to avoid false positives on common terms.
+*/
+function computeTopicOverlap(topicA, topicB) {
+	const stopWords = new Set([
+		"a",
+		"an",
+		"the",
+		"and",
+		"or",
+		"but",
+		"in",
+		"on",
+		"at",
+		"to",
+		"for",
+		"of",
+		"with",
+		"by",
+		"from",
+		"is",
+		"was",
+		"are",
+		"were",
+		"be",
+		"been",
+		"being",
+		"have",
+		"has",
+		"had",
+		"do",
+		"does",
+		"did",
+		"will",
+		"would",
+		"could",
+		"should",
+		"may",
+		"might",
+		"can",
+		"shall",
+		"this",
+		"that",
+		"these",
+		"those",
+		"it",
+		"its",
+		"new",
+		"session",
+		"work",
+		"done"
+	]);
+	const normalize = (text) => {
+		const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+		return new Set(words);
+	};
+	const wordsA = normalize(topicA);
+	const wordsB = normalize(topicB);
+	if (wordsA.size === 0 || wordsB.size === 0) return 0;
+	let intersection = 0;
+	for (const w of wordsA) if (wordsB.has(w)) intersection++;
+	const union = new Set([...wordsA, ...wordsB]).size;
+	return union > 0 ? intersection / union : 0;
+}
+/** Threshold: below this overlap ratio, we consider topics different. */
+const TOPIC_OVERLAP_THRESHOLD = .15;
+/**
+* Write (or update) the session note with the AI-generated summary.
+*
+* Strategy:
+*   - Find the current month's latest note
+*   - If it's from today, compare topics:
+*     - Same topic (overlap >= 30%) → update existing note
+*     - Different topic (overlap < 30%) → create a NEW note
+*   - If it's from a different day, create a new note
+*/
+/**
+* Return true if the summarizer output has a meaningful body — i.e. content
+* beyond the TOPIC:/title/metadata/horizontal-rule scaffolding.
+*
+* A summary that is only headers (no Work Done items) must NOT create or update
+* a note: doing so births an empty-bodied scaffold that later rename/finalize
+* can strip to a footer-only stub. This is the born-stub failure mode.
+*/
+function summaryHasContent(summaryText) {
+	return summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*(Date|Status|Completed):\*\*.*$/gm, "").replace(/^#{1,6}\s.*$/gm, "").replace(/^---$/gm, "").replace(/<!--[\s\S]*?-->/g, "").trim().length > 0;
+}
+function writeSessionNote(cwd, summaryText, filesModified) {
+	if (!summaryHasContent(summaryText)) {
+		process.stderr.write(`[session-summary] Summary has no meaningful body — skipping note write.\n`);
+		return null;
+	}
+	const notesInfo = findNotesDir(cwd);
+	let notePath = getCurrentNotePath(notesInfo.path);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const newTopic = extractTopic(summaryText);
+	if (notePath) {
+		const noteFilename = basename(notePath);
+		const dateMatch = noteFilename.match(/(\d{4}-\d{2}-\d{2})/);
+		if ((dateMatch ? dateMatch[1] : "") === today) {
+			const existingTitle = extractExistingNoteTitle(notePath);
+			let topicShifted = false;
+			if (newTopic && existingTitle) {
+				const overlap = computeTopicOverlap(newTopic, existingTitle);
+				process.stderr.write(`[session-summary] Topic overlap: ${(overlap * 100).toFixed(1)}% (new="${newTopic}", existing="${existingTitle}")\n`);
+				if (overlap < TOPIC_OVERLAP_THRESHOLD) {
+					topicShifted = true;
+					process.stderr.write(`[session-summary] Topic shift detected (word overlap) — creating new note.\n`);
+				}
+			}
+			if (!topicShifted) {
+				const boundaryPath = join(notesInfo.path, "topic-boundary.json");
+				if (existsSync(boundaryPath)) try {
+					const boundary = JSON.parse(readFileSync(boundaryPath, "utf-8"));
+					if (boundary.timestamp) {
+						if (Date.now() - new Date(boundary.timestamp).getTime() < 1800 * 1e3) {
+							topicShifted = true;
+							process.stderr.write(`[session-summary] Topic shift detected (boundary marker) — ${boundary.previousProject} → ${boundary.suggestedProject}\n`);
+						}
+					}
+					unlinkSync(boundaryPath);
+				} catch {}
+			}
+			if (topicShifted) notePath = createNoteFromSummary(notesInfo.path, summaryText);
+			else {
+				updateNoteWithSummary(notePath, summaryText);
+				process.stderr.write(`[session-summary] Updated existing note: ${noteFilename}\n`);
+			}
+		} else notePath = createNoteFromSummary(notesInfo.path, summaryText);
+	} else notePath = createNoteFromSummary(notesInfo.path, summaryText);
+	if (notePath) {
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		if (titleMatch) {
+			const title = titleMatch[1].trim();
+			if (title.length > 5 && title.length < 80) {
+				const newPath = renameSessionNote(notePath, title);
+				if (newPath !== notePath) notePath = newPath;
+			}
+		}
+	}
+	return notePath;
+}
+/**
+* Update an existing session note's Work Done section with AI-generated content.
+*/
+function updateNoteWithSummary(notePath, summaryText) {
+	if (!existsSync(notePath)) return;
+	let content = readFileSync(notePath, "utf-8");
+	const newTopic = extractTopic(summaryText);
+	if (newTopic) if (content.includes("<!-- TOPIC:")) content = content.replace(/<!-- TOPIC:.*?-->/, `<!-- TOPIC: ${newTopic} -->`);
+	else content = content.replace(/^(# Session .+)$/m, `$1\n<!-- TOPIC: ${newTopic} -->`);
+	const workDoneMatch = summaryText.match(/## Work Done\n\n([\s\S]*?)(?=\n## Key Decisions|\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (workDoneMatch) {
+		const aiWorkContent = workDoneMatch[1].trim();
+		const sectionHeader = `\n### AI Summary (${(/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0]})\n\n${aiWorkContent}\n`;
+		const nextStepsIdx = content.indexOf("## Next Steps");
+		const knownIssuesIdx = content.indexOf("## Known Issues");
+		const insertBefore = knownIssuesIdx !== -1 ? knownIssuesIdx : nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+		content = content.slice(0, insertBefore) + sectionHeader + "\n" + content.slice(insertBefore);
+	}
+	const decisionsMatch = summaryText.match(/## Key Decisions\n\n([\s\S]*?)(?=\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (decisionsMatch) {
+		const decisions = decisionsMatch[1].trim();
+		if (decisions && !content.includes("## Key Decisions")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Key Decisions\n\n${decisions}\n\n` + content.slice(insertAt);
+		}
+	}
+	const issuesMatch = summaryText.match(/## Known Issues\n\n([\s\S]*?)(?=\n\*\*Tags|\n$)/);
+	if (issuesMatch) {
+		const issues = issuesMatch[1].trim();
+		if (issues && !content.includes("## Known Issues")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Known Issues\n\n${issues}\n\n` + content.slice(insertAt);
+		}
+	}
+	writeFileSync(notePath, content, "utf-8");
+}
+/**
+* Create a brand new session note from the AI summary.
+*/
+function createNoteFromSummary(notesDir, summaryText) {
+	try {
+		const notePath = createSessionNote(notesDir, "New Session");
+		const noteFilename = basename(notePath);
+		const numberMatch = noteFilename.match(/^(\d+)/);
+		const noteNumber = numberMatch ? numberMatch[1] : "0000";
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		const title = titleMatch ? titleMatch[1].trim() : "New Session";
+		const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+		const topic = extractTopic(summaryText);
+		const aiBody = summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*Date:\*\*.*$/m, "").replace(/^\*\*Status:\*\*.*$/m, "").replace(/^---$/m, "").trim();
+		writeFileSync(notePath, `# Session ${noteNumber}: ${title}
+${topic ? `<!-- TOPIC: ${topic} -->` : ""}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+${aiBody}
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`, "utf-8");
+		process.stderr.write(`[session-summary] Created AI-powered note: ${noteFilename}\n`);
+		return notePath;
+	} catch (e) {
+		process.stderr.write(`[session-summary] Failed to create note: ${e}\n`);
+		return null;
+	}
+}
+/**
+* Look up the integer project_id from the registry DB for a given slug.
+* Returns null if not found or registryDb is not yet initialized.
+*/
+function lookupProjectId(slug) {
+	try {
+		if (!registryDb) return null;
+		return registryDb.prepare("SELECT id FROM projects WHERE slug = ? LIMIT 1").get(slug)?.id ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract structured KG triples from a session summary and store them.
+*
+* This is best-effort: any error is logged but never propagated.
+* Requires Postgres backend — silently no-ops on SQLite.
+*/
+async function extractAndStoreTriples(params) {
+	try {
+		if (!storageBackend || storageBackend.backendType !== "postgres") return;
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			process.stderr.write("[session-summary] Triple extraction: no pool available.\n");
+			return;
+		}
+		const cfg = daemonConfig;
+		if (cfg && cfg.kg_extraction_enabled === false) {
+			process.stderr.write("[session-summary] Triple extraction disabled via kg_extraction_enabled=false.\n");
+			return;
+		}
+		const federationDb = openFederation();
+		let result;
+		try {
+			result = await extractAndStoreTriples$1(pool, {
+				summaryText: params.summaryText,
+				projectSlug: params.projectSlug,
+				projectId: params.projectId,
+				sessionId: params.sessionId,
+				gitLog: params.gitLog,
+				model: "sonnet",
+				federationDb
+			});
+		} finally {
+			federationDb.close();
+		}
+		process.stderr.write(`[session-summary] Triple extraction complete: ${result.extracted} extracted, ${result.added} added, ${result.superseded} superseded.\n`);
+	} catch (err) {
+		process.stderr.write(`[session-summary] Triple extraction failed: ${err}\n`);
+	}
+}
+/**
+* Process a `session-summary` work item.
+*
+* This is the main function called by work-queue-worker.ts.
+* Throws on fatal errors (work queue will retry with backoff).
+*/
+async function handleSessionSummary(payload) {
+	const { cwd, sessionId, projectSlug, transcriptPath, force } = payload;
+	if (!cwd) throw new Error("session-summary payload missing cwd");
+	process.stderr.write(`[session-summary] Starting for ${cwd}${sessionId ? ` (session=${sessionId})` : ""}${force ? " (force=true)" : ""}\n`);
+	if (!force && isOnCooldown(cwd)) {
+		process.stderr.write("[session-summary] Skipping — last summary was less than 30 minutes ago.\n");
+		return;
+	}
+	let jsonlPath = transcriptPath || null;
+	if (jsonlPath && !existsSync(jsonlPath)) {
+		process.stderr.write(`[session-summary] Provided transcript path not found: ${jsonlPath}\n`);
+		jsonlPath = null;
+	}
+	if (!jsonlPath) jsonlPath = findLatestJsonl(cwd);
+	if (!jsonlPath) {
+		process.stderr.write("[session-summary] No JSONL transcript found — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Using transcript: ${jsonlPath}\n`);
+	const selectedModel = payload.model ?? (force ? "haiku" : "sonnet");
+	const extracted = extractFromJsonl(jsonlPath, selectedModel);
+	if (extracted.userMessages.length === 0) {
+		process.stderr.write("[session-summary] No user messages found in transcript — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Extracted ${extracted.userMessages.length} user messages, ${extracted.filesModified.length} modified files.\n`);
+	const gitLog = await getGitContext(cwd, extracted.sessionStartTime);
+	if (gitLog) process.stderr.write(`[session-summary] Got git context (${gitLog.split("\n").length} lines).\n`);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const existingNotePath = getCurrentNotePath(findNotesDir(cwd).path);
+	let existingNote;
+	if (existingNotePath) {
+		const dateMatch = basename(existingNotePath).match(/(\d{4}-\d{2}-\d{2})/);
+		if (dateMatch && dateMatch[1] === today) try {
+			existingNote = readFileSync(existingNotePath, "utf-8");
+		} catch {}
+	}
+	const prompt = buildSessionSummaryPrompt({
+		userMessages: extracted.userMessages,
+		gitLog,
+		cwd,
+		date: today,
+		filesModified: extracted.filesModified,
+		existingNote
+	});
+	process.stderr.write(`[session-summary] Sending ${prompt.length} char prompt to ${selectedModel}...\n`);
+	const summaryText = await spawnSummarizer(prompt, selectedModel);
+	if (!summaryText) {
+		process.stderr.write(`[session-summary] ${selectedModel} did not produce output — falling back to mechanical checkpoint.\n`);
+		markCooldown(cwd);
+		return;
+	}
+	process.stderr.write(`[session-summary] ${selectedModel} produced ${summaryText.length} char summary.\n`);
+	const notePath = writeSessionNote(cwd, summaryText, extracted.filesModified);
+	if (notePath) process.stderr.write(`[session-summary] Session note written: ${basename(notePath)}\n`);
+	await extractAndStoreTriples({
+		summaryText,
+		projectSlug: projectSlug ?? basename(cwd),
+		projectId: projectSlug ? lookupProjectId(projectSlug) : null,
+		sessionId: sessionId ?? cwd,
+		gitLog,
+		model: selectedModel
+	});
+	markCooldown(cwd);
+	process.stderr.write("[session-summary] Done.\n");
+}
+
+//#endregion
+//#region src/daemon/topic-detect-worker.ts
+/**
+* topic-detect-worker.ts — Topic shift detection for session note splitting
+*
+* Processes `topic-detect` work items by:
+*   1. Extracting recent user messages from the JSONL transcript
+*   2. Running the BM25-based topic shift detector against the PAI memory DB
+*   3. If a shift is detected, recording a topic boundary marker
+*
+* The actual note splitting is handled by session-summary-worker.ts when it
+* processes the next `session-summary` work item — it uses the TOPIC: line
+* from the summarizer to decide whether to create a new note.
+*
+* This worker provides an additional signal: project-level topic shift
+* (e.g., conversation moved from project A to project B). The session
+* summary worker handles intra-project topic shifts (e.g., from "dark mode"
+* to "keyboard IPC" within the same project).
+*/
+const MAX_CONTEXT_MESSAGES = 5;
+const MAX_CONTEXT_CHARS = 2e3;
+/**
+* Extract recent user messages from a JSONL transcript for topic detection.
+* Takes only the last few messages to represent the current topic.
+*/
+function extractRecentContext(jsonlPath) {
+	try {
+		const raw = readFileSync(jsonlPath, "utf-8");
+		const lines = (raw.length > 5e4 ? raw.slice(-5e4) : raw).trim().split("\n");
+		const messages = [];
+		for (let i = lines.length - 1; i >= 0 && messages.length < MAX_CONTEXT_MESSAGES; i--) {
+			const line = lines[i].trim();
+			if (!line) continue;
+			try {
+				const entry = JSON.parse(line);
+				if (entry.type === "user") {
+					const msg = entry.message;
+					if (msg?.content) {
+						const text = contentToText$1(msg.content);
+						if (text && text.length > 3) messages.unshift(text.slice(0, 500));
+					}
+				}
+			} catch {}
+		}
+		return messages.join("\n\n").slice(0, MAX_CONTEXT_CHARS);
+	} catch {
+		return "";
+	}
+}
+/** Convert Claude content (string or content block array) to plain text. */
+function contentToText$1(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		if (typeof c === "string") return c;
+		const block = c;
+		if (block?.text) return String(block.text);
+		if (block?.content) return String(block.content);
+		return "";
+	}).join(" ").trim();
+	return "";
+}
+const TOPIC_BOUNDARY_FILE = "topic-boundary.json";
+/**
+* Write a topic boundary marker into the Notes directory.
+* The session-summary-worker checks for this file and uses it as an
+* additional signal that a new note should be created.
+*/
+function writeTopicBoundary(cwd, boundary) {
+	try {
+		const boundaryPath = join(findNotesDir(cwd).path, TOPIC_BOUNDARY_FILE);
+		writeFileSync(boundaryPath, JSON.stringify(boundary, null, 2), "utf-8");
+		process.stderr.write(`[topic-detect] Wrote topic boundary marker: ${boundaryPath}\n`);
+	} catch (e) {
+		process.stderr.write(`[topic-detect] Could not write boundary marker: ${e}\n`);
+	}
+}
+/**
+* Process a `topic-detect` work item.
+*
+* Called by work-queue-worker.ts. Throws on fatal errors so the work queue
+* retry logic handles them.
+*/
+async function handleTopicDetect(payload) {
+	const { cwd, currentProject, transcriptPath, sessionId } = payload;
+	if (!cwd) throw new Error("topic-detect payload missing cwd");
+	process.stderr.write(`[topic-detect] Starting for ${cwd}${currentProject ? ` (project=${currentProject})` : ""}${sessionId ? ` (session=${sessionId})` : ""}\n`);
+	if (!registryDb || !storageBackend) {
+		process.stderr.write("[topic-detect] Registry DB or storage backend not available — skipping.\n");
+		return;
+	}
+	let context = payload.context || "";
+	if (!context && transcriptPath && existsSync(transcriptPath)) context = extractRecentContext(transcriptPath);
+	if (!context || context.trim().length < 10) {
+		process.stderr.write("[topic-detect] Insufficient context for topic detection — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[topic-detect] Context: ${context.length} chars, checking against memory...\n`);
+	const result = await detectTopicShift(registryDb, storageBackend, {
+		context,
+		currentProject,
+		threshold: .6,
+		candidates: 20
+	});
+	process.stderr.write(`[topic-detect] Result: shifted=${result.shifted}, suggested=${result.suggestedProject}, confidence=${result.confidence.toFixed(2)}, chunks=${result.chunkCount}\n`);
+	if (result.topProjects.length > 0) process.stderr.write(`[topic-detect] Top projects: ${result.topProjects.map((p) => `${p.slug}(${(p.score * 100).toFixed(0)}%)`).join(", ")}\n`);
+	if (result.shifted) {
+		writeTopicBoundary(cwd, {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			previousProject: result.currentProject,
+			suggestedProject: result.suggestedProject,
+			confidence: result.confidence,
+			context: context.slice(0, 200)
+		});
+		try {
+			const notePath = getCurrentNotePath(findNotesDir(cwd).path);
+			if (notePath) appendCheckpoint(notePath, `Topic shift detected: conversation moved from **${result.currentProject}** to **${result.suggestedProject}** (confidence: ${(result.confidence * 100).toFixed(0)}%). A new session note will be created for the new topic.`);
+		} catch (e) {
+			process.stderr.write(`[topic-detect] Could not append checkpoint: ${e}\n`);
+		}
+	}
+	process.stderr.write("[topic-detect] Done.\n");
+}
+
+//#endregion
+//#region src/daemon/work-queue-worker.ts
+/**
+* work-queue-worker.ts — Daemon worker loop for the persistent work queue
+*
+* Runs every 5 seconds to drain the queue.
+* Handles 'session-end' work items by reading the transcript, extracting
+* work summaries, updating the session note, and updating TODO.md.
+* Handles 'session-summary' items by spawning Haiku for AI-powered note generation.
+* Handles 'registry-scan' items by running performScan() against the registry DB.
+*
+* Handles 'topic-detect' items by running BM25-based topic shift detection.
+* Other item types (note-update, todo-update) are stubs — they log and
+* complete immediately, ready for future expansion.
+*/
+var work_queue_worker_exports = /* @__PURE__ */ __exportAll({
+	enqueueRegistryScan: () => enqueueRegistryScan,
+	notifyNewWork: () => notifyNewWork,
+	startWorker: () => startWorker,
+	stopWorker: () => stopWorker
+});
+const WORKER_INTERVAL_MS = 5e3;
+const HOUSEKEEPING_INTERVAL_MS = 600 * 1e3;
+let workerTimer = null;
+let housekeepingTimer = null;
+/** Start the background worker and housekeeping timers. */
+function startWorker() {
+	process.stderr.write("[work-queue-worker] Starting worker loop.\n");
+	workerTimer = setInterval(async () => {
+		try {
+			await processNextItem();
+		} catch (e) {
+			process.stderr.write(`[work-queue-worker] Uncaught error in worker loop: ${e}\n`);
+		}
+	}, WORKER_INTERVAL_MS);
+	housekeepingTimer = setInterval(() => {
+		try {
+			cleanup();
+		} catch (e) {
+			process.stderr.write(`[work-queue-worker] Housekeeping error: ${e}\n`);
+		}
+	}, HOUSEKEEPING_INTERVAL_MS);
+	process.stderr.write("[work-queue-worker] Worker started (interval=5s, housekeeping=10min).\n");
+}
+/** Stop the worker timers gracefully. */
+function stopWorker() {
+	if (workerTimer !== null) {
+		clearInterval(workerTimer);
+		workerTimer = null;
+	}
+	if (housekeepingTimer !== null) {
+		clearInterval(housekeepingTimer);
+		housekeepingTimer = null;
+	}
+	process.stderr.write("[work-queue-worker] Worker stopped.\n");
+}
+/**
+* Signal that new work has been enqueued.
+* The worker will run on its next tick — we don't need to reset the timer
+* since 5 s is fast enough. The flag allows future optimisations.
+*/
+function notifyNewWork() {}
+async function processNextItem() {
+	const item = dequeue();
+	if (!item) return;
+	process.stderr.write(`[work-queue-worker] Processing ${item.type} (id=${item.id}, attempt=${item.attempts}).\n`);
+	try {
+		switch (item.type) {
+			case "session-end":
+				await handleSessionEnd(item);
+				break;
+			case "session-summary":
+				await handleSessionSummary(item.payload);
+				break;
+			case "topic-detect":
+				await handleTopicDetect(item.payload);
+				break;
+			case "registry-scan":
+				await handleRegistryScan();
+				break;
+			case "note-update":
+			case "todo-update":
+				process.stderr.write(`[work-queue-worker] Item type '${item.type}' is not yet implemented — completing as no-op.\n`);
+				break;
+			default: throw new Error(`Unknown work item type: ${item.type}`);
+		}
+		markCompleted(item.id);
+		process.stderr.write(`[work-queue-worker] Completed ${item.type} (id=${item.id}).\n`);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		markFailed(item.id, msg);
+	}
+}
+/**
+* Process a 'session-end' work item.
+*
+* Expected payload:
+*   transcriptPath: string   — absolute path to the .jsonl transcript
+*   cwd: string              — working directory of the session
+*   message?: string         — COMPLETED: line extracted by the hook (optional)
+*/
+async function handleSessionEnd(item) {
+	const { transcriptPath, cwd, message: hookMessage } = item.payload;
+	if (!transcriptPath) throw new Error("session-end payload missing transcriptPath");
+	if (!cwd) throw new Error("session-end payload missing cwd");
+	let transcript;
+	try {
+		transcript = readFileSync(transcriptPath, "utf-8");
+	} catch (e) {
+		throw new Error(`Could not read transcript at ${transcriptPath}: ${e}`);
+	}
+	const lines = transcript.trim().split("\n");
+	const workItems = extractWorkFromTranscript(lines);
+	let message = hookMessage ?? "";
+	if (!message) {
+		const lastEntry = tryParseJson(lines[lines.length - 1]);
+		if (lastEntry?.type === "assistant" && lastEntry.message?.content) {
+			const m = contentToText(lastEntry.message.content).match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
+			if (m) message = m[1].trim().replace(/\*+/g, "").replace(/\[.*?\]/g, "").trim();
+		}
+	}
+	const currentNotePath = getCurrentNotePath(findNotesDir(cwd).path);
+	if (currentNotePath) {
+		if (workItems.length > 0) {
+			addWorkToSessionNote(currentNotePath, workItems);
+			process.stderr.write(`[work-queue-worker] Added ${workItems.length} work item(s) to note.\n`);
+		} else if (message) {
+			addWorkToSessionNote(currentNotePath, [{
+				title: message,
+				completed: true
+			}]);
+			process.stderr.write("[work-queue-worker] Added completion message to note.\n");
+		}
+		finalizeSessionNote(currentNotePath, message || "Session completed.");
+		process.stderr.write(`[work-queue-worker] Finalized session note: ${basename(currentNotePath)}.\n`);
+		try {
+			const stateLines = [];
+			stateLines.push(`Working directory: ${cwd}`);
+			if (workItems.length > 0) {
+				stateLines.push("", "Work completed:");
+				for (const wi of workItems.slice(0, 5)) stateLines.push(`- ${wi.title}`);
+			}
+			if (message) stateLines.push("", `Last completed: ${message}`);
+			updateTodoContinue(cwd, basename(currentNotePath), stateLines.join("\n"), "session-end");
+		} catch (todoError) {
+			process.stderr.write(`[work-queue-worker] Could not update TODO.md: ${todoError}\n`);
+		}
+	} else process.stderr.write("[work-queue-worker] No current session note found — skipping note update.\n");
+	try {
+		const movedCount = moveSessionFilesToSessionsDir(dirname(transcriptPath));
+		if (movedCount > 0) process.stderr.write(`[work-queue-worker] Moved ${movedCount} session file(s) to sessions/.\n`);
+	} catch (moveError) {
+		process.stderr.write(`[work-queue-worker] Could not move session files: ${moveError}\n`);
+	}
+}
+/**
+* Run performScan() against the registry DB.
+*
+* Debounce: if another registry-scan job is already pending in the queue,
+* we still run this one (dequeue already picked it), but enqueueRegistryScan()
+* checks before enqueuing so duplicates rarely reach here.
+*/
+async function handleRegistryScan() {
+	if (!registryDb) throw new Error("registry-scan: registryDb not initialized yet");
+	const t0 = Date.now();
+	process.stderr.write("[work-queue-worker] Running registry scan...\n");
+	const result = performScan(registryDb);
+	const elapsed = Date.now() - t0;
+	process.stderr.write(`[work-queue-worker] Registry scan complete: ${result.projectsScanned} projects (${result.projectsNew} new, ${result.projectsUpdated} updated), ${result.sessionsScanned} sessions (${result.sessionsNew} new) in ${elapsed}ms.\n`);
+	if (result.skipped.length > 0) process.stderr.write(`[work-queue-worker] Registry scan: ${result.skipped.length} project(s) skipped (path not found).\n`);
+}
+/**
+* Enqueue a registry-scan work item — debounced.
+* If a registry-scan item is already pending or processing, skip enqueue.
+*/
+function enqueueRegistryScan() {
+	if (hasPendingOrProcessingOfType("registry-scan")) {
+		process.stderr.write("[work-queue-worker] Registry scan already pending/processing — skipping duplicate enqueue.\n");
+		return;
+	}
+	enqueue({
+		type: "registry-scan",
+		priority: 5,
+		payload: {}
+	});
+}
+function tryParseJson(line) {
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+}
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		if (typeof c === "string") return c;
+		const block = c;
+		if (block?.text) return String(block.text);
+		if (block?.content) return String(block.content);
+		return "";
+	}).join(" ").trim();
+	return "";
+}
+function extractWorkFromTranscript(lines) {
+	const workItems = [];
+	const seenSummaries = /* @__PURE__ */ new Set();
+	for (const line of lines) {
+		const entry = tryParseJson(line);
+		if (!entry || entry.type !== "assistant") continue;
+		const msg = entry.message;
+		if (!msg?.content) continue;
+		const content = contentToText(msg.content);
+		const summaryMatch = content.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
+		if (summaryMatch) {
+			const summary = summaryMatch[1].trim();
+			if (summary && !seenSummaries.has(summary) && summary.length > 5) {
+				seenSummaries.add(summary);
+				const details = [];
+				const actionsMatch = content.match(/ACTIONS:\s*(.+?)(?=\n[A-Z]+:|$)/is);
+				if (actionsMatch) {
+					const actionLines = actionsMatch[1].split("\n").map((l) => l.replace(/^[-*•]\s*/, "").replace(/^\d+\.\s*/, "").trim()).filter((l) => l.length > 3 && l.length < 100);
+					details.push(...actionLines.slice(0, 3));
+				}
+				workItems.push({
+					title: summary,
+					details: details.length > 0 ? details : void 0,
+					completed: true
+				});
+			}
+		}
+		const completedMatch = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
+		if (completedMatch && workItems.length === 0) {
+			const completed = completedMatch[1].trim().replace(/\*+/g, "").replace(/\[.*?\]/g, "").trim();
+			if (completed && !seenSummaries.has(completed) && completed.length > 5) {
+				seenSummaries.add(completed);
+				workItems.push({
+					title: completed,
+					completed: true
+				});
+			}
+		}
+	}
+	return workItems;
+}
+
+//#endregion
+export { enqueue as a, work_queue_worker_exports as i, startWorker as n, getStats as o, stopWorker as r, loadQueue as s, notifyNewWork as t };
+//# sourceMappingURL=work-queue-worker-CEMpy89q.mjs.map