@tekmidian/pai 0.7.0 → 0.7.2

package/dist/{daemon-D3hYb5_C.mjs → daemon-DuGlDnV7.mjs}

@@ -8,11 +8,15 @@ import { t as createStorageBackend } from "./factory-Ygqe_bVZ.mjs";
 import { C as setStorageBackend, E as startTime, O as storageBackend, S as setStartTime, T as shutdownRequested, _ as setLastIndexTime, a as indexSchedulerTimer, b as setRegistryDb, c as lastVaultIndexTime, d as setDaemonConfig, f as setEmbedInProgress, g as setLastEmbedTime, h as setIndexSchedulerTimer, i as indexInProgress, k as vaultIndexInProgress, l as notificationConfig, m as setIndexInProgress, n as embedInProgress, o as lastEmbedTime, p as setEmbedSchedulerTimer, r as embedSchedulerTimer, s as lastIndexTime, t as daemonConfig, u as registryDb, v as setLastVaultIndexTime, w as setVaultIndexInProgress, x as setShutdownRequested, y as setNotificationConfig } from "./state-C6_vqz7w.mjs";
 import { a as toolProjectDetect, c as toolProjectList, d as toolMemorySearch, i as toolSessionRoute, l as toolProjectTodo, n as toolRegistrySearch, o as toolProjectHealth, r as toolSessionList, s as toolProjectInfo, u as toolMemoryGet } from "./tools-DcaJlYDN.mjs";
 import { t as detectTopicShift } from "./detector-jGBuYQJM.mjs";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { setPriority } from "node:os";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, setPriority } from "node:os";
+import { basename, dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { connect, createServer } from "node:net";
 import { spawn } from "node:child_process";
+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/notifications/config.ts
 /**
@@ -734,6 +738,809 @@ async function dispatchTool(method, params) {
 	}
 }
 
+//#endregion
+//#region src/daemon/work-queue.ts
+/**
+* work-queue.ts — Persistent work queue for the PAI Daemon
+*
+* Provides a durable, file-backed queue that survives daemon restarts.
+* Items are processed sequentially to avoid concurrent writes to the same
+* session note. Failed items are retried with exponential backoff.
+*
+* Queue file: ~/.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;
+}
+/**
+* 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 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);
+}
+/** 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.
+* Mirrors "pause session" behavior — gives the next session a starting point.
+* Replaces any existing ## Continue section.
+*/
+function updateTodoContinue(cwd, noteFilename, state, tokenDisplay) {
+	const todoPath = ensureTodoMd(cwd);
+	let content = readFileSync$1(todoPath, "utf-8");
+	content = content.replace(/## Continue\n[\s\S]*?\n---\n+/, "");
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const stateLines = state ? state.split("\n").filter((l) => l.trim()).slice(0, 10).map((l) => `> ${l}`).join("\n") : `> Working directory: ${cwd}. Check the latest session note for details.`;
+	const continueSection = `## Continue
+
+> **Last session:** ${noteFilename.replace(".md", "")}
+> **Paused at:** ${now}
+>
+${stateLines}
+
+---
+
+`;
+	content = content.replace(/^\s+/, "");
+	const titleMatch = content.match(/^(# [^\n]+\n+)/);
+	if (titleMatch) content = titleMatch[1] + continueSection + content.substring(titleMatch[0].length);
+	else content = continueSection + content;
+	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);
+	console.error("TODO.md ## Continue section updated");
+}
+
+//#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.
+*
+* Other item types (session-summary, note-update, todo-update, topic-detect)
+* are stubs — they log and complete immediately, ready for future expansion.
+*/
+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":
+			case "note-update":
+			case "todo-update":
+			case "topic-detect":
+				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`);
+	}
+}
+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
 //#region src/daemon/daemon/handler.ts
 function sendResponse(socket, response) {
@@ -776,7 +1583,8 @@ async function handleRequest(request, socket) {
 				db: dbStats,
 				vaultIndexInProgress,
 				lastVaultIndexTime: lastVaultIndexTime ? new Date(lastVaultIndexTime).toISOString() : null,
-				vaultPath: daemonConfig.vaultPath ?? null
+				vaultPath: daemonConfig.vaultPath ?? null,
+				workQueue: getStats()
 			}
 		});
 		socket.end();
@@ -1134,6 +1942,52 @@ async function handleRequest(request, socket) {
 		socket.end();
 		return;
 	}
+	if (method === "work_queue_enqueue") {
+		try {
+			const p = params;
+			if (!p.type) {
+				sendResponse(socket, {
+					id,
+					ok: false,
+					error: "work_queue_enqueue: type is required"
+				});
+				socket.end();
+				return;
+			}
+			const item = enqueue({
+				type: p.type,
+				priority: p.priority,
+				payload: p.payload ?? {},
+				maxAttempts: p.maxAttempts
+			});
+			/* @__PURE__ */ notifyNewWork();
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: {
+					id: item.id,
+					status: item.status
+				}
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "work_queue_stats") {
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: getStats()
+		});
+		socket.end();
+		return;
+	}
 	try {
 		sendResponse(socket, {
 			id,
@@ -1263,12 +2117,15 @@ async function serve(config) {
 	startIndexScheduler();
 	if (storageBackend.backendType === "postgres") startEmbedScheduler();
 	else process.stderr.write("[pai-daemon] Embed scheduler: disabled (SQLite backend)\n");
+	loadQueue();
+	startWorker();
 	const server = await startIpcServer(config.socketPath);
 	const shutdown = async (signal) => {
 		process.stderr.write(`\n[pai-daemon] ${signal} received. Stopping.\n`);
 		setShutdownRequested(true);
 		if (indexSchedulerTimer) clearInterval(indexSchedulerTimer);
 		if (embedSchedulerTimer) clearInterval(embedSchedulerTimer);
+		stopWorker();
 		server.close();
 		const SHUTDOWN_TIMEOUT_MS = 1e4;
 		const POLL_INTERVAL_MS = 100;
@@ -1302,4 +2159,4 @@ var daemon_exports = /* @__PURE__ */ __exportAll({ serve: () => serve });
 
 //#endregion
 export { serve as n, daemon_exports as t };
-//# sourceMappingURL=daemon-D3hYb5_C.mjs.map
+//# sourceMappingURL=daemon-DuGlDnV7.mjs.map