@tekmidian/pai 0.5.6 → 0.6.0

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

@@ -1,11 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
-import { n as openRegistry } from "./db-4lSqLFb8.mjs";
-import { r as indexAll } from "./indexer-CMPOiY1r.mjs";
+import { n as openRegistry } from "./db-BtuN768f.mjs";
+import { d as sha256 } from "./helpers-BEST-4Gx.mjs";
+import { n as indexAll } from "./sync-BOsnEj2-.mjs";
 import { t as configureEmbeddingModel } from "./embeddings-DGRAPAYb.mjs";
-import { n as CONFIG_FILE, s as DEFAULT_NOTIFICATION_CONFIG, t as CONFIG_DIR } from "./config-Cf92lGX_.mjs";
-import { a as toolProjectHealth, c as toolProjectTodo, d as toolSessionRoute, i as toolProjectDetect, l as toolRegistrySearch, n as toolMemorySearch, o as toolProjectInfo, s as toolProjectList, t as toolMemoryGet, u as toolSessionList } from "./tools-DV_lsiCc.mjs";
-import { t as createStorageBackend } from "./factory-Bzcy70G9.mjs";
-import { t as detectTopicShift } from "./detector-Bp-2SM3x.mjs";
+import { n as CONFIG_FILE, s as DEFAULT_NOTIFICATION_CONFIG, t as CONFIG_DIR } from "./config-BuhHWyOK.mjs";
+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 { randomUUID } from "node:crypto";
@@ -81,6 +83,182 @@ function patchNotificationConfig(patch) {
 	return current;
 }
 
+//#endregion
+//#region src/daemon/daemon/scheduler.ts
+/**
+* Index, embed, and vault index schedulers for the PAI daemon.
+* Exports run* functions (also called on-demand by the IPC handler)
+* and the start* functions invoked once at daemon startup.
+*/
+/** Minimum interval between vault index runs (30 minutes). */
+const VAULT_INDEX_MIN_INTERVAL_MS = 1800 * 1e3;
+/**
+* Run a full index pass. Guards against overlapping runs with indexInProgress.
+* Called both by the scheduler and by the index_now IPC method.
+*/
+async function runIndex() {
+	if (indexInProgress) {
+		process.stderr.write("[pai-daemon] Index already in progress, skipping.\n");
+		return;
+	}
+	if (embedInProgress) {
+		process.stderr.write("[pai-daemon] Embed in progress, deferring index run.\n");
+		return;
+	}
+	setIndexInProgress(true);
+	const t0 = Date.now();
+	try {
+		process.stderr.write("[pai-daemon] Starting scheduled index run...\n");
+		if (storageBackend.backendType === "sqlite") {
+			const { SQLiteBackend } = await import("./sqlite-l-s9xPjY.mjs");
+			if (storageBackend instanceof SQLiteBackend) {
+				const { projects, result } = await indexAll(storageBackend.getRawDb(), registryDb);
+				const elapsed = Date.now() - t0;
+				setLastIndexTime(Date.now());
+				process.stderr.write(`[pai-daemon] Index complete: ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
+			}
+		} else {
+			const { indexAllWithBackend } = await import("./indexer-backend-jcJFsmB4.mjs");
+			const { projects, result } = await indexAllWithBackend(storageBackend, registryDb);
+			const elapsed = Date.now() - t0;
+			setLastIndexTime(Date.now());
+			process.stderr.write(`[pai-daemon] Index complete (postgres): ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
+		}
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Index error: ${msg}\n`);
+	} finally {
+		setIndexInProgress(false);
+	}
+}
+/**
+* Run a vault index pass. Guards against overlapping runs with vaultIndexInProgress.
+* Skips if no vaultPath is configured, or if project index/embed is in progress.
+*/
+async function runVaultIndex() {
+	if (!daemonConfig.vaultPath) return;
+	if (vaultIndexInProgress) {
+		process.stderr.write("[pai-daemon] Vault index already in progress, skipping.\n");
+		return;
+	}
+	if (indexInProgress || embedInProgress) {
+		process.stderr.write("[pai-daemon] Index/embed in progress, deferring vault index.\n");
+		return;
+	}
+	const { lastVaultIndexTime } = await import("./state-C6_vqz7w.mjs").then((n) => n.D);
+	if (lastVaultIndexTime > 0 && Date.now() - lastVaultIndexTime < VAULT_INDEX_MIN_INTERVAL_MS) return;
+	let vaultProjectId = daemonConfig.vaultProjectId;
+	if (!vaultProjectId) {
+		const row = registryDb.prepare("SELECT id FROM projects WHERE root_path = ?").get(daemonConfig.vaultPath);
+		vaultProjectId = row?.id ?? 999;
+		if (!row) process.stderr.write("[pai-daemon] Vault not in project registry — using synthetic project ID 999.\n");
+	}
+	setVaultIndexInProgress(true);
+	const t0 = Date.now();
+	process.stderr.write("[pai-daemon] Starting vault index run...\n");
+	try {
+		const { indexVault } = await import("./vault-indexer-Bi2cRmn7.mjs");
+		const r = await indexVault(storageBackend, vaultProjectId, daemonConfig.vaultPath);
+		const elapsed = Date.now() - t0;
+		setLastVaultIndexTime(Date.now());
+		process.stderr.write(`[pai-daemon] Vault index complete: ${r.filesIndexed} files, ${r.linksExtracted} links, ${r.deadLinksFound} dead, ${r.orphansFound} orphans (${elapsed}ms)\n`);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Vault index error: ${msg}\n`);
+	} finally {
+		setVaultIndexInProgress(false);
+	}
+}
+/**
+* Start the periodic index scheduler. Runs an initial pass 2 seconds after startup.
+*/
+function startIndexScheduler() {
+	const intervalMs = daemonConfig.indexIntervalSecs * 1e3;
+	process.stderr.write(`[pai-daemon] Index scheduler: every ${daemonConfig.indexIntervalSecs}s\n`);
+	setTimeout(() => {
+		runIndex().then(() => runVaultIndex()).catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup index error: ${e}\n`);
+		});
+	}, 2e3);
+	const timer = setInterval(() => {
+		runIndex().then(() => runVaultIndex()).catch((e) => {
+			process.stderr.write(`[pai-daemon] Scheduled index error: ${e}\n`);
+		});
+	}, intervalMs);
+	if (timer.unref) timer.unref();
+	setIndexSchedulerTimer(timer);
+}
+/**
+* Run an embedding pass for all unembedded chunks (Postgres backend only).
+*/
+async function runEmbed() {
+	if (embedInProgress) {
+		process.stderr.write("[pai-daemon] Embed already in progress, skipping.\n");
+		return;
+	}
+	if (indexInProgress) {
+		process.stderr.write("[pai-daemon] Index in progress, deferring embed pass.\n");
+		return;
+	}
+	if (storageBackend.backendType !== "postgres") return;
+	setEmbedInProgress(true);
+	const t0 = Date.now();
+	try {
+		process.stderr.write("[pai-daemon] Starting scheduled embed pass...\n");
+		const projectNames = /* @__PURE__ */ new Map();
+		try {
+			const rows = registryDb.prepare("SELECT id, slug FROM projects WHERE status = 'active'").all();
+			for (const r of rows) projectNames.set(r.id, r.slug);
+		} catch {}
+		const { embedChunksWithBackend } = await import("./indexer-backend-jcJFsmB4.mjs");
+		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested, projectNames);
+		let vaultEmbedCount = 0;
+		if (daemonConfig.vaultPath) try {
+			const { SQLiteBackend } = await import("./sqlite-l-s9xPjY.mjs");
+			const { openFederation } = await import("./db-DdUperSl.mjs").then((n) => n.t);
+			const federationDb = openFederation();
+			const vaultSqliteBackend = new SQLiteBackend(federationDb);
+			const vaultProjectNames = new Map(projectNames);
+			if (!vaultProjectNames.has(999)) vaultProjectNames.set(999, "obsidian-vault");
+			vaultEmbedCount = await embedChunksWithBackend(vaultSqliteBackend, () => shutdownRequested, vaultProjectNames);
+			try {
+				federationDb.close();
+			} catch {}
+			if (vaultEmbedCount > 0) process.stderr.write(`[pai-daemon] Vault embed pass complete: ${vaultEmbedCount} vault chunks embedded\n`);
+		} catch (ve) {
+			const vmsg = ve instanceof Error ? ve.message : String(ve);
+			process.stderr.write(`[pai-daemon] Vault embed error: ${vmsg}\n`);
+		}
+		const elapsed = Date.now() - t0;
+		setLastEmbedTime(Date.now());
+		process.stderr.write(`[pai-daemon] Embed pass complete: ${count} postgres chunks + ${vaultEmbedCount} vault chunks embedded (${elapsed}ms)\n`);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Embed error: ${msg}\n`);
+	} finally {
+		setEmbedInProgress(false);
+	}
+}
+/**
+* Start the periodic embed scheduler. Initial run is 60 seconds after startup.
+*/
+function startEmbedScheduler() {
+	const intervalMs = daemonConfig.embedIntervalSecs * 1e3;
+	process.stderr.write(`[pai-daemon] Embed scheduler: every ${daemonConfig.embedIntervalSecs}s\n`);
+	setTimeout(() => {
+		runEmbed().catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup embed error: ${e}\n`);
+		});
+	}, 6e4);
+	const timer = setInterval(() => {
+		runEmbed().catch((e) => {
+			process.stderr.write(`[pai-daemon] Scheduled embed error: ${e}\n`);
+		});
+	}, intervalMs);
+	if (timer.unref) timer.unref();
+	setEmbedSchedulerTimer(timer);
+}
+
 //#endregion
 //#region src/notifications/providers/ntfy.ts
 var NtfyProvider = class {
@@ -302,223 +480,199 @@ async function routeNotification(payload, config) {
 }
 
 //#endregion
-//#region src/daemon/daemon.ts
+//#region src/observations/store.ts
 /**
-* daemon.ts — The persistent PAI Daemon
-*
-* Provides shared database access, tool dispatch, and periodic index scheduling
-* for multiple concurrent Claude Code sessions via a Unix Domain Socket.
-*
-* Architecture:
-*   MCP shims (Claude sessions) → Unix socket → PAI Daemon
-*                                                   ├── registry.db (shared, WAL, always SQLite)
-*                                                   ├── federation (SQLite or Postgres/pgvector)
-*                                                   ├── Embedding model (singleton)
-*                                                   └── Index scheduler (periodic)
-*
-* IPC protocol: NDJSON over Unix Domain Socket
-*
-* Request  (shim → daemon):
-*   { "id": "uuid", "method": "tool_name_or_special", "params": {} }
-*
-* Response (daemon → shim):
-*   { "id": "uuid", "ok": true, "result": <any> }
-*   { "id": "uuid", "ok": false, "error": "message" }
+* store.ts — PostgreSQL persistence for PAI observations.
 *
-* Special methods:
-*   status     — Return daemon status (uptime, index state, db stats)
-*   index_now  — Trigger immediate index run (non-blocking)
+* All functions accept a pg.Pool and are safe to call concurrently.
+* Schema is initialized lazily via ensureObservationTables().
 *
-* All other methods are dispatched to the corresponding PAI tool function.
-*
-* Design notes:
-* - Registry stays in SQLite (small, simple metadata).
-* - Federation backend is configurable: SQLite (default) or Postgres/pgvector.
-* - Auto-fallback: if Postgres is configured but unavailable, falls back to SQLite.
-* - Index writes guarded by indexInProgress flag (not a mutex — index is idempotent).
-* - Embedding model loaded lazily on first semantic/hybrid request, then kept alive.
-* - Scheduler runs indexAll() every indexIntervalSecs (default 5 minutes).
+* Content-hash deduplication: observations with the same hash
+* created within a 30-second window are silently dropped to prevent
+* duplicate entries from rapid repeated tool calls.
 */
-var daemon_exports = /* @__PURE__ */ __exportAll({ serve: () => serve });
-let registryDb;
-let storageBackend;
-let daemonConfig;
-let startTime = Date.now();
-let indexInProgress = false;
-let lastIndexTime = 0;
-let indexSchedulerTimer = null;
-let embedInProgress = false;
-let lastEmbedTime = 0;
-let embedSchedulerTimer = null;
-let vaultIndexInProgress = false;
-let lastVaultIndexTime = 0;
-/** Mutable notification config — loaded from disk at startup, patchable at runtime */
-let notificationConfig;
+let _tablesEnsured = false;
 /**
-* Set to true when a SIGTERM/SIGINT is received so that long-running loops
-* (embed, index) can detect the signal and exit their inner loops before the
-* pool/backend is closed.  Checked by embedChunksWithBackend() via the
-* `shouldStop` callback passed from runEmbed().
+* Inlined schema DDL — avoids runtime file reads that break in bundled code
+* (the bundler puts this in a shared chunk whose __dirname differs from src/).
 */
-let shutdownRequested = false;
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS pai_observations (
+  id SERIAL PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  project_id INTEGER,
+  project_slug TEXT,
+  type TEXT NOT NULL CHECK (type IN ('decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change')),
+  title TEXT NOT NULL,
+  narrative TEXT,
+  tool_name TEXT,
+  tool_input_summary TEXT,
+  files_read JSONB DEFAULT '[]'::jsonb,
+  files_modified JSONB DEFAULT '[]'::jsonb,
+  concepts JSONB DEFAULT '[]'::jsonb,
+  content_hash TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_obs_project ON pai_observations(project_id);
+CREATE INDEX IF NOT EXISTS idx_obs_session ON pai_observations(session_id);
+CREATE INDEX IF NOT EXISTS idx_obs_type ON pai_observations(type);
+CREATE INDEX IF NOT EXISTS idx_obs_created ON pai_observations(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_obs_hash ON pai_observations(content_hash);
+
+CREATE TABLE IF NOT EXISTS pai_session_summaries (
+  id SERIAL PRIMARY KEY,
+  session_id TEXT NOT NULL UNIQUE,
+  project_id INTEGER,
+  project_slug TEXT,
+  request TEXT,
+  investigated TEXT,
+  learned TEXT,
+  completed TEXT,
+  next_steps TEXT,
+  observation_count INTEGER DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_ss_project ON pai_session_summaries(project_id);
+CREATE INDEX IF NOT EXISTS idx_ss_session ON pai_session_summaries(session_id);
+`;
 /**
-* Run a full index pass. Guards against overlapping runs with indexInProgress.
-* Called both by the scheduler and by the index_now IPC method.
-*
-* NOTE: We pass the raw SQLite federation DB to indexAll() for SQLite backend,
-* or skip and use the backend interface for Postgres.  The indexer currently
-* uses better-sqlite3 directly; it will be refactored in a future phase.
-* For now, we keep the SQLite indexer path and add a Postgres-aware path.
+* Run schema DDL idempotently against the given pool.
+* Uses a module-level flag so subsequent calls are no-ops within the same
+* process lifetime (the SQL itself uses IF NOT EXISTS so it is safe to re-run).
 */
-async function runIndex() {
-	if (indexInProgress) {
-		process.stderr.write("[pai-daemon] Index already in progress, skipping.\n");
-		return;
-	}
-	if (embedInProgress) {
-		process.stderr.write("[pai-daemon] Embed in progress, deferring index run.\n");
-		return;
-	}
-	indexInProgress = true;
-	const t0 = Date.now();
-	try {
-		process.stderr.write("[pai-daemon] Starting scheduled index run...\n");
-		if (storageBackend.backendType === "sqlite") {
-			const { SQLiteBackend } = await import("./sqlite-WWBq7_2C.mjs");
-			if (storageBackend instanceof SQLiteBackend) {
-				const { projects, result } = await indexAll(storageBackend.getRawDb(), registryDb);
-				const elapsed = Date.now() - t0;
-				lastIndexTime = Date.now();
-				process.stderr.write(`[pai-daemon] Index complete: ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
-			}
-		} else {
-			const { indexAllWithBackend } = await import("./indexer-backend-CIMXedqk.mjs");
-			const { projects, result } = await indexAllWithBackend(storageBackend, registryDb);
-			const elapsed = Date.now() - t0;
-			lastIndexTime = Date.now();
-			process.stderr.write(`[pai-daemon] Index complete (postgres): ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
-		}
-	} catch (e) {
-		const msg = e instanceof Error ? e.message : String(e);
-		process.stderr.write(`[pai-daemon] Index error: ${msg}\n`);
-	} finally {
-		indexInProgress = false;
-	}
+async function ensureObservationTables(pool) {
+	if (_tablesEnsured) return;
+	await pool.query(SCHEMA_SQL);
+	_tablesEnsured = true;
 }
 /**
-* Run a vault index pass. Guards against overlapping runs with vaultIndexInProgress.
-* Skips if no vaultPath is configured, or if project index/embed is in progress.
-* Called both by the scheduler (chained after runIndex) and by the vault_index_now IPC method.
+* Compute a 16-character hex content hash for deduplication.
+* Hash = SHA256(session_id + tool_name + title).slice(0, 16)
 */
-async function runVaultIndex() {
-	if (!daemonConfig.vaultPath) return;
-	if (vaultIndexInProgress) {
-		process.stderr.write("[pai-daemon] Vault index already in progress, skipping.\n");
-		return;
-	}
-	if (indexInProgress || embedInProgress) {
-		process.stderr.write("[pai-daemon] Index/embed in progress, deferring vault index.\n");
-		return;
-	}
-	vaultIndexInProgress = true;
-	const t0 = Date.now();
-	try {
-		process.stderr.write("[pai-daemon] Starting vault index run...\n");
-		if (storageBackend.backendType === "sqlite") {
-			const { SQLiteBackend } = await import("./sqlite-WWBq7_2C.mjs");
-			if (storageBackend instanceof SQLiteBackend) {
-				const db = storageBackend.getRawDb();
-				let vaultProjectId = daemonConfig.vaultProjectId;
-				if (!vaultProjectId) vaultProjectId = registryDb.prepare("SELECT id FROM projects WHERE root_path = ?").get(daemonConfig.vaultPath)?.id ?? 0;
-				if (!vaultProjectId) {
-					process.stderr.write("[pai-daemon] Vault project ID not found. Register the vault as a project first.\n");
-					return;
-				}
-				const { indexVault } = await import("./vault-indexer-DXWs9pDn.mjs");
-				const result = await indexVault(db, vaultProjectId, daemonConfig.vaultPath);
-				const elapsed = Date.now() - t0;
-				lastVaultIndexTime = Date.now();
-				process.stderr.write(`[pai-daemon] Vault index complete: ${result.filesIndexed} files, ${result.linksExtracted} links, ${result.deadLinksFound} dead, ${result.orphansFound} orphans (${elapsed}ms)\n`);
-			}
-		} else process.stderr.write("[pai-daemon] Vault indexing only supported on SQLite backend.\n");
-	} catch (e) {
-		const msg = e instanceof Error ? e.message : String(e);
-		process.stderr.write(`[pai-daemon] Vault index error: ${msg}\n`);
-	} finally {
-		vaultIndexInProgress = false;
-	}
+function computeContentHash(sessionId, toolName, title) {
+	return sha256(sessionId + "\0" + toolName + "\0" + title).slice(0, 16);
 }
 /**
-* Start the periodic index scheduler.
+* Insert an observation, skipping duplicates within a 30-second window.
+* Returns the inserted row's id, or null if the insert was suppressed.
 */
-function startIndexScheduler() {
-	const intervalMs = daemonConfig.indexIntervalSecs * 1e3;
-	process.stderr.write(`[pai-daemon] Index scheduler: every ${daemonConfig.indexIntervalSecs}s\n`);
-	setTimeout(() => {
-		runIndex().then(() => runVaultIndex()).catch((e) => {
-			process.stderr.write(`[pai-daemon] Startup index error: ${e}\n`);
-		});
-	}, 2e3);
-	indexSchedulerTimer = setInterval(() => {
-		runIndex().then(() => runVaultIndex()).catch((e) => {
-			process.stderr.write(`[pai-daemon] Scheduled index error: ${e}\n`);
-		});
-	}, intervalMs);
-	if (indexSchedulerTimer.unref) indexSchedulerTimer.unref();
+async function storeObservation(pool, obs) {
+	await ensureObservationTables(pool);
+	const hash = computeContentHash(obs.session_id, obs.tool_name, obs.title);
+	const dupCheck = await pool.query(`SELECT id FROM pai_observations
+     WHERE content_hash = $1
+       AND session_id   = $2
+       AND created_at  >= NOW() - INTERVAL '30 seconds'
+     LIMIT 1`, [hash, obs.session_id]);
+	if (dupCheck.rowCount && dupCheck.rowCount > 0) return null;
+	return (await pool.query(`INSERT INTO pai_observations
+       (session_id, project_id, project_slug, type, title, narrative,
+        tool_name, tool_input_summary, files_read, files_modified, concepts, content_hash)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10::jsonb, $11::jsonb, $12)
+     RETURNING id`, [
+		obs.session_id,
+		obs.project_id ?? null,
+		obs.project_slug ?? null,
+		obs.type,
+		obs.title,
+		obs.narrative ?? null,
+		obs.tool_name,
+		obs.tool_input_summary ?? null,
+		JSON.stringify(obs.files_read),
+		JSON.stringify(obs.files_modified),
+		JSON.stringify(obs.concepts),
+		hash
+	])).rows[0]?.id ?? null;
 }
 /**
-* Run an embedding pass for all unembedded chunks (Postgres backend only).
-* Guards against overlapping runs with embedInProgress.
-* Skips if an index run is currently in progress to avoid contention.
+* Filtered query for observations with optional projectId, sessionId, type,
+* limit, and offset. Returns results ordered by created_at DESC.
 */
-async function runEmbed() {
-	if (embedInProgress) {
-		process.stderr.write("[pai-daemon] Embed already in progress, skipping.\n");
-		return;
+async function queryObservations(pool, opts = {}) {
+	await ensureObservationTables(pool);
+	const conditions = [];
+	const params = [];
+	let idx = 1;
+	if (opts.projectId !== void 0) {
+		conditions.push(`project_id = $${idx++}`);
+		params.push(opts.projectId);
 	}
-	if (indexInProgress) {
-		process.stderr.write("[pai-daemon] Index in progress, deferring embed pass.\n");
-		return;
+	if (opts.sessionId !== void 0) {
+		conditions.push(`session_id = $${idx++}`);
+		params.push(opts.sessionId);
 	}
-	if (storageBackend.backendType !== "postgres") return;
-	embedInProgress = true;
-	const t0 = Date.now();
-	try {
-		process.stderr.write("[pai-daemon] Starting scheduled embed pass...\n");
-		const { embedChunksWithBackend } = await import("./indexer-backend-CIMXedqk.mjs");
-		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested);
-		const elapsed = Date.now() - t0;
-		lastEmbedTime = Date.now();
-		process.stderr.write(`[pai-daemon] Embed pass complete: ${count} chunks embedded (${elapsed}ms)\n`);
-	} catch (e) {
-		const msg = e instanceof Error ? e.message : String(e);
-		process.stderr.write(`[pai-daemon] Embed error: ${msg}\n`);
-	} finally {
-		embedInProgress = false;
+	if (opts.type !== void 0) {
+		conditions.push(`type = $${idx++}`);
+		params.push(opts.type);
 	}
+	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	const limit = opts.limit ?? 50;
+	const offset = opts.offset ?? 0;
+	params.push(limit, offset);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug, type, title, narrative,
+            tool_name, tool_input_summary,
+            files_read, files_modified, concepts,
+            content_hash, created_at
+     FROM pai_observations
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT $${idx++} OFFSET $${idx}`, params)).rows;
 }
 /**
-* Start the periodic embed scheduler.
-* Initial run is 30 seconds after startup (after the 2-second index startup run).
+* Most recent observations for a project, ordered by created_at DESC.
 */
-function startEmbedScheduler() {
-	const intervalMs = daemonConfig.embedIntervalSecs * 1e3;
-	process.stderr.write(`[pai-daemon] Embed scheduler: every ${daemonConfig.embedIntervalSecs}s\n`);
-	setTimeout(() => {
-		runEmbed().catch((e) => {
-			process.stderr.write(`[pai-daemon] Startup embed error: ${e}\n`);
-		});
-	}, 3e4);
-	embedSchedulerTimer = setInterval(() => {
-		runEmbed().catch((e) => {
-			process.stderr.write(`[pai-daemon] Scheduled embed error: ${e}\n`);
-		});
-	}, intervalMs);
-	if (embedSchedulerTimer.unref) embedSchedulerTimer.unref();
+async function queryRecentObservations(pool, projectId, limit) {
+	await ensureObservationTables(pool);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug, type, title, narrative,
+            tool_name, tool_input_summary,
+            files_read, files_modified, concepts,
+            content_hash, created_at
+     FROM pai_observations
+     WHERE project_id = $1
+     ORDER BY created_at DESC
+     LIMIT $2`, [projectId, limit])).rows;
 }
 /**
+* Upsert a session summary.  Uses ON CONFLICT on session_id so calling this
+* multiple times with updated content is safe.
+*/
+async function storeSessionSummary(pool, summary) {
+	await ensureObservationTables(pool);
+	await pool.query(`INSERT INTO pai_session_summaries
+       (session_id, project_id, project_slug, request, investigated,
+        learned, completed, next_steps, observation_count)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+     ON CONFLICT (session_id) DO UPDATE SET
+       project_id        = EXCLUDED.project_id,
+       project_slug      = EXCLUDED.project_slug,
+       request           = EXCLUDED.request,
+       investigated      = EXCLUDED.investigated,
+       learned           = EXCLUDED.learned,
+       completed         = EXCLUDED.completed,
+       next_steps        = EXCLUDED.next_steps,
+       observation_count = EXCLUDED.observation_count`, [
+		summary.session_id,
+		summary.project_id ?? null,
+		summary.project_slug ?? null,
+		summary.request ?? null,
+		summary.investigated ?? null,
+		summary.learned ?? null,
+		summary.completed ?? null,
+		summary.next_steps ?? null,
+		summary.observation_count ?? 0
+	]);
+}
+
+//#endregion
+//#region src/daemon/daemon/dispatcher.ts
+/**
+* Tool dispatcher — maps IPC method names to PAI tool functions.
+*/
+/**
 * Dispatch an IPC tool call to the appropriate tool function.
-* Returns the tool result or throws.
+* Returns the tool result or throws on unknown/failed methods.
 */
 async function dispatchTool(method, params) {
 	const p = params;
@@ -540,24 +694,48 @@ async function dispatchTool(method, params) {
 		case "zettel_suggest":
 		case "zettel_converse":
 		case "zettel_themes": {
-			const { toolZettelExplore, toolZettelHealth, toolZettelSurprise, toolZettelSuggest, toolZettelConverse, toolZettelThemes } = await import("./tools-DV_lsiCc.mjs").then((n) => n.y);
-			if (storageBackend.backendType !== "sqlite") throw new Error("Zettel tools require SQLite backend");
-			const { SQLiteBackend } = await import("./sqlite-WWBq7_2C.mjs");
-			if (!(storageBackend instanceof SQLiteBackend)) throw new Error("Zettel tools require SQLite backend");
-			const fedDb = storageBackend.getRawDb();
+			const { toolZettelExplore, toolZettelHealth, toolZettelSurprise, toolZettelSuggest, toolZettelConverse, toolZettelThemes } = await import("./tools-DcaJlYDN.mjs").then((n) => n.t);
 			switch (method) {
-				case "zettel_explore": return toolZettelExplore(fedDb, p);
-				case "zettel_health": return toolZettelHealth(fedDb, p);
-				case "zettel_surprise": return toolZettelSurprise(fedDb, p);
-				case "zettel_suggest": return toolZettelSuggest(fedDb, p);
-				case "zettel_converse": return toolZettelConverse(fedDb, p);
-				case "zettel_themes": return toolZettelThemes(fedDb, p);
+				case "zettel_explore": return toolZettelExplore(storageBackend, p);
+				case "zettel_health": return toolZettelHealth(storageBackend, p);
+				case "zettel_surprise": return toolZettelSurprise(storageBackend, p);
+				case "zettel_suggest": return toolZettelSuggest(storageBackend, p);
+				case "zettel_converse": return toolZettelConverse(storageBackend, p);
+				case "zettel_themes": return toolZettelThemes(storageBackend, p);
 			}
 			break;
 		}
+		case "graph_clusters": {
+			const { handleGraphClusters } = await import("./clusters-JIDQW65f.mjs");
+			return handleGraphClusters(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_neighborhood": {
+			const { handleGraphNeighborhood } = await import("./neighborhood-BYYbEkUJ.mjs");
+			return handleGraphNeighborhood(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_note_context": {
+			const { handleGraphNoteContext } = await import("./note-context-BK24bX8Y.mjs");
+			return handleGraphNoteContext(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_trace": {
+			const { handleGraphTrace } = await import("./trace-CRx9lPuc.mjs");
+			return handleGraphTrace(storageBackend, p);
+		}
+		case "graph_latent_ideas": {
+			const { handleGraphLatentIdeas } = await import("./latent-ideas-bTJo6Omd.mjs");
+			return handleGraphLatentIdeas(storageBackend, p);
+		}
+		case "idea_materialize": {
+			const { handleIdeaMaterialize } = await import("./latent-ideas-bTJo6Omd.mjs");
+			if (!daemonConfig.vaultPath) throw new Error("idea_materialize requires vaultPath to be configured in the daemon config");
+			return handleIdeaMaterialize(p, daemonConfig.vaultPath);
+		}
 		default: throw new Error(`Unknown method: ${method}`);
 	}
 }
+
+//#endregion
+//#region src/daemon/daemon/handler.ts
 function sendResponse(socket, response) {
 	try {
 		socket.write(JSON.stringify(response) + "\n");
@@ -643,15 +821,16 @@ async function handleRequest(request, socket) {
 	if (method === "notification_set_config") {
 		try {
 			const p = params;
-			notificationConfig = patchNotificationConfig({
+			const updated = patchNotificationConfig({
 				mode: p.mode,
 				channels: p.channels,
 				routing: p.routing
 			});
+			setNotificationConfig(updated);
 			sendResponse(socket, {
 				id,
 				ok: true,
-				result: { config: notificationConfig }
+				result: { config: updated }
 			});
 		} catch (e) {
 			sendResponse(socket, {
@@ -695,6 +874,266 @@ async function handleRequest(request, socket) {
 		});
 		return;
 	}
+	if (method === "observation_store") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Observations require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			let project_id = null;
+			let project_slug = null;
+			if (p.cwd) {
+				const row = registryDb.prepare("SELECT id, slug FROM projects WHERE status = 'active' AND ? LIKE root_path || '%' ORDER BY length(root_path) DESC LIMIT 1").get(p.cwd);
+				if (row) {
+					project_id = row.id;
+					project_slug = row.slug;
+				}
+			}
+			await ensureObservationTables(pool);
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: {
+					ok: true,
+					id: await storeObservation(pool, {
+						session_id: p.session_id,
+						project_id,
+						project_slug,
+						type: p.type,
+						title: p.title,
+						narrative: p.narrative ?? null,
+						tool_name: p.tool_name,
+						tool_input_summary: p.tool_input_summary ?? null,
+						files_read: p.files_read ?? [],
+						files_modified: p.files_modified ?? [],
+						concepts: p.concepts ?? []
+					})
+				}
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "observation_query") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Observations require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: await queryObservations(pool, {
+					projectId: p.project_id,
+					sessionId: p.session_id,
+					type: p.type,
+					limit: p.limit,
+					offset: p.offset
+				})
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "observation_recent") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Observations require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			const limit = p.limit ?? 20;
+			let resolvedProjectId = p.project_id;
+			let resolvedProjectSlug;
+			if (resolvedProjectId === void 0 && p.cwd) {
+				const row = registryDb.prepare("SELECT id, slug FROM projects WHERE status = 'active' AND ? LIKE root_path || '%' ORDER BY length(root_path) DESC LIMIT 1").get(p.cwd);
+				if (row) {
+					resolvedProjectId = row.id;
+					resolvedProjectSlug = row.slug;
+				}
+			}
+			let rows;
+			if (resolvedProjectId !== void 0) rows = await queryRecentObservations(pool, resolvedProjectId, limit);
+			else rows = await queryObservations(pool, { limit });
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: {
+					rows,
+					project_slug: resolvedProjectSlug
+				}
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "observation_list") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Observations require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			let projectId;
+			if (p.project_slug) projectId = registryDb.prepare("SELECT id FROM projects WHERE slug = ?").get(p.project_slug)?.id;
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: await queryObservations(pool, {
+					projectId,
+					sessionId: p.session_id,
+					type: p.type,
+					limit: p.limit ?? 20,
+					offset: p.offset ?? 0
+				})
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "observation_stats") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Observations require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			await ensureObservationTables(pool);
+			const [totalRes, byTypeRes, byProjectRes, recentRes] = await Promise.all([
+				pool.query("SELECT COUNT(*) as count FROM pai_observations"),
+				pool.query("SELECT type, COUNT(*) as count FROM pai_observations GROUP BY type ORDER BY count DESC"),
+				pool.query("SELECT project_slug, COUNT(*) as count FROM pai_observations GROUP BY project_slug ORDER BY count DESC LIMIT 15"),
+				pool.query("SELECT created_at FROM pai_observations ORDER BY created_at DESC LIMIT 1")
+			]);
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: {
+					total: parseInt(totalRes.rows[0]?.count ?? "0", 10),
+					by_type: byTypeRes.rows.map((r) => ({
+						type: r.type,
+						count: parseInt(r.count, 10)
+					})),
+					by_project: byProjectRes.rows.map((r) => ({
+						project_slug: r.project_slug,
+						count: parseInt(r.count, 10)
+					})),
+					most_recent: recentRes.rows[0]?.created_at ?? null
+				}
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "session_summary_store") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Session summaries require Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			let resolvedProjectId = p.project_id ?? null;
+			let resolvedProjectSlug = p.project_slug ?? null;
+			if (resolvedProjectId === null && p.cwd) {
+				const row = registryDb.prepare("SELECT id, slug FROM projects WHERE status = 'active' AND ? LIKE root_path || '%' ORDER BY length(root_path) DESC LIMIT 1").get(p.cwd);
+				if (row) {
+					resolvedProjectId = row.id;
+					resolvedProjectSlug = row.slug;
+				}
+			}
+			await storeSessionSummary(pool, {
+				session_id: p.session_id,
+				project_id: resolvedProjectId,
+				project_slug: resolvedProjectSlug,
+				request: p.request ?? null,
+				investigated: p.investigated ?? null,
+				learned: p.learned ?? null,
+				completed: p.completed ?? null,
+				next_steps: p.next_steps ?? null,
+				observation_count: p.observation_count ?? 0
+			});
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: { ok: true }
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
 	try {
 		sendResponse(socket, {
 			id,
@@ -710,9 +1149,15 @@ async function handleRequest(request, socket) {
 	}
 	socket.end();
 }
+
+//#endregion
+//#region src/daemon/daemon/server.ts
+/**
+* IPC server and daemon entry point.
+* Owns: isSocketLive, startIpcServer, serve (exported).
+*/
 /**
 * Check whether an existing socket file is actually being served by a live process.
-* Returns true if a daemon is already accepting connections, false otherwise.
 */
 function isSocketLive(path) {
 	return new Promise((resolve) => {
@@ -786,19 +1231,20 @@ async function startIpcServer(socketPath) {
 	return server;
 }
 async function serve(config) {
-	daemonConfig = config;
-	startTime = Date.now();
-	notificationConfig = loadNotificationConfig();
+	setDaemonConfig(config);
+	setStartTime(Date.now());
+	setNotificationConfig(loadNotificationConfig());
 	process.stderr.write("[pai-daemon] Starting daemon...\n");
 	process.stderr.write(`[pai-daemon] Socket: ${config.socketPath}\n`);
 	process.stderr.write(`[pai-daemon] Storage backend: ${config.storageBackend}\n`);
+	const { notificationConfig } = await import("./state-C6_vqz7w.mjs").then((n) => n.D);
 	process.stderr.write(`[pai-daemon] Notification mode: ${notificationConfig.mode}\n`);
 	try {
 		setPriority(process.pid, 10);
 	} catch {}
 	configureEmbeddingModel(config.embeddingModel);
 	try {
-		registryDb = openRegistry();
+		setRegistryDb(openRegistry());
 		process.stderr.write("[pai-daemon] Registry database opened.\n");
 	} catch (e) {
 		const msg = e instanceof Error ? e.message : String(e);
@@ -806,8 +1252,9 @@ async function serve(config) {
 		process.exit(1);
 	}
 	try {
-		storageBackend = await createStorageBackend(config);
-		process.stderr.write(`[pai-daemon] Federation backend: ${storageBackend.backendType}\n`);
+		const backend = await createStorageBackend(config);
+		setStorageBackend(backend);
+		process.stderr.write(`[pai-daemon] Federation backend: ${backend.backendType}\n`);
 	} catch (e) {
 		const msg = e instanceof Error ? e.message : String(e);
 		process.stderr.write(`[pai-daemon] Fatal: Could not open federation storage: ${msg}\n`);
@@ -819,7 +1266,7 @@ async function serve(config) {
 	const server = await startIpcServer(config.socketPath);
 	const shutdown = async (signal) => {
 		process.stderr.write(`\n[pai-daemon] ${signal} received. Stopping.\n`);
-		shutdownRequested = true;
+		setShutdownRequested(true);
 		if (indexSchedulerTimer) clearInterval(indexSchedulerTimer);
 		if (embedSchedulerTimer) clearInterval(embedSchedulerTimer);
 		server.close();
@@ -849,6 +1296,10 @@ async function serve(config) {
 	await new Promise(() => {});
 }
 
+//#endregion
+//#region src/daemon/daemon.ts
+var daemon_exports = /* @__PURE__ */ __exportAll({ serve: () => serve });
+
 //#endregion
 export { serve as n, daemon_exports as t };
-//# sourceMappingURL=daemon-D9evGlgR.mjs.map
+//# sourceMappingURL=daemon-D3hYb5_C.mjs.map