@tekmidian/pai 0.7.2 → 0.7.3

package/dist/cli/index.mjs

@@ -3793,7 +3793,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("../daemon-DuGlDnV7.mjs").then((n) => n.t);
+		const { serve } = await import("../daemon-D8ZxcFhU.mjs").then((n) => n.t);
 		const { loadConfig: lc, ensureConfigDir } = await import("../config-BuhHWyOK.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());

package/dist/daemon/index.mjs

@@ -8,7 +8,7 @@ import "../indexer-D53l5d1U.mjs";
 import { t as PaiClient } from "../ipc-client-CoyUHPod.mjs";
 import { i as ensureConfigDir, o as loadConfig } from "../config-BuhHWyOK.mjs";
 import "../factory-Ygqe_bVZ.mjs";
-import { n as serve } from "../daemon-DuGlDnV7.mjs";
+import { n as serve } from "../daemon-D8ZxcFhU.mjs";
 import "../state-C6_vqz7w.mjs";
 import "../tools-DcaJlYDN.mjs";
 import "../detector-jGBuYQJM.mjs";

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

@@ -8,7 +8,7 @@ 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, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, 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";
@@ -1117,6 +1117,30 @@ function findTodoPath(cwd) {
 /**
 * 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).
@@ -1139,6 +1163,41 @@ function getCurrentNotePath(notesDir) {
 	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;
+}
 /** Add work items to the "Work Done" section of a session note. */
 function addWorkToSessionNote(notePath, workItems, sectionTitle) {
 	if (!existsSync$1(notePath)) {
@@ -1342,6 +1401,540 @@ ${stateLines}
 	console.error("TODO.md ## Continue section updated");
 }
 
+//#endregion
+//#region src/daemon/templates/session-summary-prompt.ts
+/**
+* Build the prompt string to send to Haiku for session summarization.
+*
+* Returns a single string suitable for piping to `claude --model haiku --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):
+
+# Session: [Descriptive Title - 5-8 words summarizing the main accomplishment]
+
+**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 Haiku via `claude` CLI to generate a structured summary
+*   5. Writing the summary to the project's session note
+*
+* 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 Haiku (characters). */
+const MAX_JSONL_CHARS = 5e4;
+/** Maximum user messages to include in the prompt. */
+const MAX_USER_MESSAGES = 30;
+/** Timeout for the claude CLI process (ms). */
+const CLAUDE_TIMEOUT_MS = 6e4;
+/** 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 MAX_JSONL_CHARS from the end of the file.
+*/
+function extractFromJsonl(jsonlPath) {
+	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}`);
+	}
+	if (raw.length > MAX_JSONL_CHARS) {
+		const truncPoint = raw.indexOf("\n", raw.length - MAX_JSONL_CHARS);
+		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$1(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$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 "";
+}
+/** 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 = [
+		"claude",
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		join(homedir(), ".local", "bin", "claude")
+	];
+	for (const candidate of candidates) try {
+		if (candidate === "claude") return candidate;
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return null;
+}
+/**
+* Spawn Haiku via the claude CLI to generate a session summary.
+* Pipes the prompt via stdin to `claude --model haiku --print --no-input`.
+* Returns the generated text, or null if spawning fails.
+*/
+async function spawnHaikuSummarizer(prompt) {
+	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 child = spawn(claudeBin, [
+			"--model",
+			"haiku",
+			"-p",
+			"--no-session-persistence"
+		], {
+			env: { ...process.env },
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			process.stderr.write(`[session-summary] Haiku 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] Haiku exited with code ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write("[session-summary] Haiku timed out — killing process.\n");
+			child.kill("SIGTERM");
+			resolve(null);
+		}, CLAUDE_TIMEOUT_MS);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Write (or update) the session note with the AI-generated summary.
+*
+* Strategy:
+*   - Find the current month's latest note
+*   - If it's from today, update it with the new summary
+*   - If it's from a different day, create a new note
+*/
+function writeSessionNote(cwd, summaryText, filesModified) {
+	const notesInfo = findNotesDir(cwd);
+	let notePath = getCurrentNotePath(notesInfo.path);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	if (notePath) {
+		const noteFilename = basename(notePath);
+		const dateMatch = noteFilename.match(/(\d{4}-\d{2}-\d{2})/);
+		if ((dateMatch ? dateMatch[1] : "") === today) {
+			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 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);
+		writeFileSync(notePath, `# Session ${noteNumber}: ${titleMatch ? titleMatch[1].trim() : "New Session"}
+
+**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+**Status:** In Progress
+
+---
+
+${summaryText.replace(/^# Session:.*$/m, "").replace(/^\*\*Date:\*\*.*$/m, "").replace(/^\*\*Status:\*\*.*$/m, "").replace(/^---$/m, "").trim()}
+
+---
+
+## 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;
+	}
+}
+/**
+* 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 extracted = extractFromJsonl(jsonlPath);
+	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 Haiku...\n`);
+	const summaryText = await spawnHaikuSummarizer(prompt);
+	if (!summaryText) {
+		process.stderr.write("[session-summary] Haiku did not produce output — falling back to mechanical checkpoint.\n");
+		markCooldown(cwd);
+		return;
+	}
+	process.stderr.write(`[session-summary] Haiku 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`);
+	markCooldown(cwd);
+	process.stderr.write("[session-summary] Done.\n");
+}
+
 //#endregion
 //#region src/daemon/work-queue-worker.ts
 /**
@@ -1350,8 +1943,9 @@ ${stateLines}
 * 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.
 *
-* Other item types (session-summary, note-update, todo-update, topic-detect)
+* Other item types (note-update, todo-update, topic-detect)
 * are stubs — they log and complete immediately, ready for future expansion.
 */
 const WORKER_INTERVAL_MS = 5e3;
@@ -1405,6 +1999,8 @@ async function processNextItem() {
 				await handleSessionEnd(item);
 				break;
 			case "session-summary":
+				await handleSessionSummary(item.payload);
+				break;
 			case "note-update":
 			case "todo-update":
 			case "topic-detect":
@@ -2159,4 +2755,4 @@ var daemon_exports = /* @__PURE__ */ __exportAll({ serve: () => serve });
 
 //#endregion
 export { serve as n, daemon_exports as t };
-//# sourceMappingURL=daemon-DuGlDnV7.mjs.map
+//# sourceMappingURL=daemon-D8ZxcFhU.mjs.map