@tekmidian/pai 0.25.2 → 0.27.0

package/dist/daemon-BaBTOB1P.mjs

@@ -0,0 +1,1356 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as openRegistry } from "./db-BtuN768f.mjs";
+import { n as openFederation } from "./db-CYmBWcjh.mjs";
+import { d as sha256 } from "./helpers-crDEr6S2.mjs";
+import { n as indexAll } from "./sync--BoxBBok.mjs";
+import { t as configureEmbeddingModel } from "./embeddings-Bn86ssxR.mjs";
+import { l as DEFAULT_NOTIFICATION_CONFIG, n as CONFIG_FILE, t as CONFIG_DIR } from "./config-CcdkNSWa.mjs";
+import { r as getBackendOutage, t as createStorageBackend } from "./factory-CAy0N1xR.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-DTvy-jRB.mjs";
+import { t as routeNotification } from "./router-B2xR3gVP.mjs";
+import { a as toolMemoryWakeup, c as toolSessionRoute, d as toolProjectInfo, f as toolProjectList, h as toolMemorySearch, i as toolMemoryTaxonomy, l as toolProjectDetect, m as toolMemoryGet, n as toolMemoryKgSearch, o as toolRegistrySearch, p as toolProjectTodo, r as toolMemoryFeedback, s as toolSessionList, u as toolProjectHealth } from "./tools-DMAQxlOk.mjs";
+import { t as detectTopicShift } from "./detector-DExEQ5cW.mjs";
+import { a as enqueue, n as startWorker, o as getStats, r as stopWorker, s as loadQueue, t as notifyNewWork } from "./work-queue-worker-Bt_UcbMy.mjs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { setPriority } from "node:os";
+import { connect, createServer } from "node:net";
+
+//#region src/notifications/config.ts
+/**
+* config.ts — Notification config persistence helpers
+*
+* Reads and writes the `notifications` section of ~/.config/pai/config.json.
+* Deep-merges with defaults so partial configs work fine.
+*
+* This module is intentionally separate from the daemon's config loader
+* so it can be used standalone (e.g. from CLI commands).
+*/
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const srcVal = source[key];
+		if (srcVal === void 0 || srcVal === null) continue;
+		const tgtVal = target[key];
+		if (typeof srcVal === "object" && !Array.isArray(srcVal) && typeof tgtVal === "object" && tgtVal !== null && !Array.isArray(tgtVal)) result[key] = deepMerge(tgtVal, srcVal);
+		else result[key] = srcVal;
+	}
+	return result;
+}
+/**
+* Load the notification config from the PAI config file.
+* Returns defaults merged with any stored values.
+*/
+function loadNotificationConfig() {
+	if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_NOTIFICATION_CONFIG };
+	let raw;
+	try {
+		raw = readFileSync(CONFIG_FILE, "utf-8");
+	} catch {
+		return { ...DEFAULT_NOTIFICATION_CONFIG };
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return { ...DEFAULT_NOTIFICATION_CONFIG };
+	}
+	const stored = parsed["notifications"];
+	if (!stored || typeof stored !== "object") return { ...DEFAULT_NOTIFICATION_CONFIG };
+	return deepMerge(DEFAULT_NOTIFICATION_CONFIG, stored);
+}
+/**
+* Persist the notification config by merging it into the existing
+* ~/.config/pai/config.json. Creates the file if it does not exist.
+*/
+function saveNotificationConfig(config) {
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+	let full = {};
+	if (existsSync(CONFIG_FILE)) try {
+		full = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+	} catch {}
+	full["notifications"] = config;
+	writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2) + "\n", "utf-8");
+}
+/**
+* Apply a partial update to the current notification config and persist it.
+* Returns the new merged config.
+*/
+function patchNotificationConfig(patch) {
+	const current = loadNotificationConfig();
+	if (patch.mode !== void 0) current.mode = patch.mode;
+	if (patch.channels) current.channels = deepMerge(current.channels, patch.channels);
+	if (patch.routing) current.routing = deepMerge(current.routing, patch.routing);
+	saveNotificationConfig(current);
+	return current;
+}
+
+//#endregion
+//#region src/daemon/daemon/scheduler.ts
+/**
+* Index, embed, vault index, and registry scan 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--BBAyXLH.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-vOJqSE0U.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-DTvy-jRB.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-Dt8qXP-w.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`);
+	const cycle = (label) => runIndex().then(() => runVaultIndex()).then(() => runEmbed()).catch((e) => {
+		process.stderr.write(`[pai-daemon] ${label} index error: ${e}\n`);
+	});
+	setTimeout(() => void cycle("Startup"), 2e3);
+	const timer = setInterval(() => void cycle("Scheduled"), 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-vOJqSE0U.mjs");
+		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested, projectNames, { maxMillis: 24e4 });
+		let vaultEmbedCount = 0;
+		if (daemonConfig.vaultPath) try {
+			const { SQLiteBackend } = await import("./sqlite--BBAyXLH.mjs");
+			const { openFederation } = await import("./db-CYmBWcjh.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, { maxMillis: 45e3 });
+			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);
+}
+const REGISTRY_SCAN_INTERVAL_MS = 1800 * 1e3;
+const REGISTRY_SCAN_STARTUP_DELAY_MS = 1e4;
+/**
+* Start the periodic registry scan scheduler.
+* First scan runs 10 seconds after startup (enough time for IPC to stabilise).
+* Subsequent scans run every 30 minutes.
+* Uses the work-queue so the scan runs on the worker thread without blocking IPC.
+*/
+function startRegistryScanScheduler() {
+	process.stderr.write("[pai-daemon] Registry scan scheduler: every 30min (first in 10s)\n");
+	setTimeout(() => {
+		import("./work-queue-worker-Bt_UcbMy.mjs").then((n) => n.i).then(({ enqueueRegistryScan }) => enqueueRegistryScan()).catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup registry scan error: ${e}\n`);
+		});
+	}, REGISTRY_SCAN_STARTUP_DELAY_MS);
+	const timer = setInterval(() => {
+		import("./work-queue-worker-Bt_UcbMy.mjs").then((n) => n.i).then(({ enqueueRegistryScan }) => enqueueRegistryScan()).catch((e) => {
+			process.stderr.write(`[pai-daemon] Scheduled registry scan error: ${e}\n`);
+		});
+	}, REGISTRY_SCAN_INTERVAL_MS);
+	if (timer.unref) timer.unref();
+}
+
+//#endregion
+//#region src/observations/store.ts
+/**
+* store.ts — PostgreSQL persistence for PAI observations.
+*
+* All functions accept a pg.Pool and are safe to call concurrently.
+* Schema is initialized lazily via ensureObservationTables().
+*
+* 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.
+*/
+let _tablesEnsured = false;
+/**
+* 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/).
+*/
+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 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 ensureObservationTables(pool) {
+	if (_tablesEnsured) return;
+	await pool.query(SCHEMA_SQL);
+	_tablesEnsured = true;
+}
+/**
+* Compute a 16-character hex content hash for deduplication.
+* Hash = SHA256(session_id + tool_name + title).slice(0, 16)
+*/
+function computeContentHash(sessionId, toolName, title) {
+	return sha256(sessionId + "\0" + toolName + "\0" + title).slice(0, 16);
+}
+/**
+* Insert an observation, skipping duplicates within a 30-second window.
+* Returns the inserted row's id, or null if the insert was suppressed.
+*/
+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;
+}
+/**
+* Filtered query for observations with optional projectId, sessionId, type,
+* limit, and offset. Returns results ordered by created_at DESC.
+*/
+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 (opts.sessionId !== void 0) {
+		conditions.push(`session_id = $${idx++}`);
+		params.push(opts.sessionId);
+	}
+	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;
+}
+/**
+* Most recent observations for a project, ordered by created_at DESC.
+*/
+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
+	]);
+}
+const SKILL_TELEMETRY_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS pai_skill_telemetry (
+  id               SERIAL PRIMARY KEY,
+  scope            TEXT NOT NULL DEFAULT 'default',
+  skill_name       TEXT NOT NULL,
+  source           TEXT NOT NULL DEFAULT 'local',
+  status           TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('trial','active','archived')),
+  trigger_count    INTEGER NOT NULL DEFAULT 0,
+  accept_count     INTEGER NOT NULL DEFAULT 0,
+  first_triggered  TIMESTAMPTZ DEFAULT NOW(),
+  last_triggered   TIMESTAMPTZ DEFAULT NOW(),
+  context_projects JSONB DEFAULT '[]'::jsonb,
+  hash             TEXT,
+  audit_status     TEXT,
+  last_audited     TIMESTAMPTZ,
+  UNIQUE(scope, skill_name, source)
+);
+
+CREATE INDEX IF NOT EXISTS idx_skilltel_scope   ON pai_skill_telemetry(scope);
+CREATE INDEX IF NOT EXISTS idx_skilltel_status  ON pai_skill_telemetry(scope, status);
+CREATE INDEX IF NOT EXISTS idx_skilltel_last    ON pai_skill_telemetry(last_triggered DESC);
+`;
+let _skillTelemetryEnsured = false;
+async function ensureSkillTelemetryTable(pool) {
+	if (_skillTelemetryEnsured) return;
+	await pool.query(SKILL_TELEMETRY_SCHEMA_SQL);
+	_skillTelemetryEnsured = true;
+}
+/**
+* Record a single skill invocation. Upserts on (scope, skill_name, source):
+* increments trigger_count, refreshes last_triggered, and dedup-merges the
+* project slug into context_projects.
+*/
+async function recordSkillInvocation(pool, input) {
+	await ensureSkillTelemetryTable(pool);
+	const scope = input.scope ?? "default";
+	const source = input.source ?? "local";
+	const proj = input.project_slug ?? null;
+	const initialProjects = JSON.stringify(proj ? [proj] : []);
+	await pool.query(`INSERT INTO pai_skill_telemetry
+       (scope, skill_name, source, trigger_count, context_projects)
+     VALUES ($1, $2, $3, 1, $4::jsonb)
+     ON CONFLICT (scope, skill_name, source) DO UPDATE SET
+       trigger_count    = pai_skill_telemetry.trigger_count + 1,
+       last_triggered   = NOW(),
+       context_projects = CASE
+         WHEN $5::text IS NULL THEN pai_skill_telemetry.context_projects
+         WHEN pai_skill_telemetry.context_projects @> to_jsonb($5::text)
+           THEN pai_skill_telemetry.context_projects
+         ELSE pai_skill_telemetry.context_projects || to_jsonb($5::text)
+       END`, [
+		scope,
+		input.skill_name,
+		source,
+		initialProjects,
+		proj
+	]);
+}
+/**
+* List skill telemetry rows, most-triggered first.
+*/
+async function querySkillTelemetry(pool, opts = {}) {
+	await ensureSkillTelemetryTable(pool);
+	const conditions = [];
+	const params = [];
+	let idx = 1;
+	conditions.push(`scope = $${idx++}`);
+	params.push(opts.scope ?? "default");
+	if (opts.status !== void 0) {
+		conditions.push(`status = $${idx++}`);
+		params.push(opts.status);
+	}
+	const where = `WHERE ${conditions.join(" AND ")}`;
+	const limit = opts.limit ?? 100;
+	params.push(limit);
+	return (await pool.query(`SELECT id, scope, skill_name, source, status,
+            trigger_count, accept_count,
+            first_triggered, last_triggered,
+            context_projects, hash, audit_status, last_audited
+     FROM pai_skill_telemetry
+     ${where}
+     ORDER BY trigger_count DESC, last_triggered DESC
+     LIMIT $${idx}`, params)).rows;
+}
+
+//#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 on unknown/failed methods.
+*/
+async function dispatchTool(method, params) {
+	const p = params;
+	switch (method) {
+		case "memory_search": return toolMemorySearch(registryDb, storageBackend, p);
+		case "memory_get": return toolMemoryGet(registryDb, p);
+		case "project_info": return toolProjectInfo(registryDb, p);
+		case "project_list": return toolProjectList(registryDb, p);
+		case "session_list": return toolSessionList(registryDb, p);
+		case "registry_search": return toolRegistrySearch(registryDb, p);
+		case "project_detect": return toolProjectDetect(registryDb, p);
+		case "project_health": return toolProjectHealth(registryDb, p);
+		case "project_todo": return toolProjectTodo(registryDb, p);
+		case "memory_wakeup": return toolMemoryWakeup(registryDb, p);
+		case "memory_taxonomy": return toolMemoryTaxonomy(registryDb, storageBackend, p);
+		case "topic_check": return detectTopicShift(registryDb, storageBackend, p);
+		case "session_auto_route": return toolSessionRoute(registryDb, storageBackend, p);
+		case "zettel_explore":
+		case "zettel_health":
+		case "zettel_surprise":
+		case "zettel_suggest":
+		case "zettel_converse":
+		case "zettel_themes":
+		case "zettel_god_notes":
+		case "zettel_communities": {
+			const { toolZettelExplore, toolZettelHealth, toolZettelSurprise, toolZettelSuggest, toolZettelConverse, toolZettelThemes, toolZettelGodNotes, toolZettelCommunities } = await import("./tools-DMAQxlOk.mjs").then((n) => n.t);
+			switch (method) {
+				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);
+				case "zettel_god_notes": return toolZettelGodNotes(storageBackend, p);
+				case "zettel_communities": return toolZettelCommunities(storageBackend, p);
+			}
+			break;
+		}
+		case "graph_clusters": {
+			const { handleGraphClusters } = await import("./clusters-BdvGIoD-.mjs");
+			return handleGraphClusters(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_neighborhood": {
+			const { handleGraphNeighborhood } = await import("./neighborhood-DSkvFMAv.mjs");
+			return handleGraphNeighborhood(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_note_context": {
+			const { handleGraphNoteContext } = await import("./note-context-DrcY4cWm.mjs");
+			return handleGraphNoteContext(storageBackend.getPool?.() ?? null, storageBackend, p);
+		}
+		case "graph_trace": {
+			const { handleGraphTrace } = await import("./trace-DfyGmMG_.mjs");
+			return handleGraphTrace(storageBackend, p);
+		}
+		case "graph_latent_ideas": {
+			const { handleGraphLatentIdeas } = await import("./latent-ideas-DuM_kgkW.mjs");
+			return handleGraphLatentIdeas(storageBackend, p);
+		}
+		case "idea_materialize": {
+			const { handleIdeaMaterialize } = await import("./latent-ideas-DuM_kgkW.mjs");
+			if (!daemonConfig.vaultPath) throw new Error("idea_materialize requires vaultPath to be configured in the daemon config");
+			return handleIdeaMaterialize(p, daemonConfig.vaultPath);
+		}
+		case "kg_add":
+		case "kg_query":
+		case "kg_invalidate":
+		case "kg_contradictions": {
+			const { toolKgAdd, toolKgQuery, toolKgInvalidate, toolKgContradictions } = await import("./tools-DMAQxlOk.mjs").then((n) => n.t);
+			const pgPool = storageBackend.getPool?.() ?? null;
+			if (!pgPool) throw new Error(`${method} requires a Postgres storage backend`);
+			switch (method) {
+				case "kg_add": return toolKgAdd(pgPool, p);
+				case "kg_query": return toolKgQuery(pgPool, p);
+				case "kg_invalidate": return toolKgInvalidate(pgPool, p);
+				case "kg_contradictions": return toolKgContradictions(pgPool, p);
+			}
+			break;
+		}
+		case "memory_tunnels": {
+			const { toolMemoryTunnels } = await import("./tools-DMAQxlOk.mjs").then((n) => n.t);
+			return toolMemoryTunnels(registryDb, storageBackend, p);
+		}
+		case "memory_feedback": {
+			const federationDb = openFederation();
+			try {
+				return await toolMemoryFeedback(federationDb, p);
+			} finally {
+				federationDb.close();
+			}
+		}
+		case "memory_kg_search": {
+			const federationDb = openFederation();
+			const pgPool = storageBackend.getPool?.() ?? null;
+			if (!pgPool) {
+				federationDb.close();
+				throw new Error("memory_kg_search requires a Postgres storage backend for KG triple expansion");
+			}
+			try {
+				return await toolMemoryKgSearch(federationDb, pgPool, p);
+			} finally {
+				federationDb.close();
+			}
+		}
+		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");
+	} catch {}
+}
+/**
+* Handle a single IPC request.
+*/
+async function handleRequest(request, socket) {
+	const { id, method, params } = request;
+	if (method === "status") {
+		const dbStats = await (async () => {
+			try {
+				if (!storageBackend) return null;
+				const fedStats = await storageBackend.getStats();
+				const projects = registryDb.prepare("SELECT COUNT(*) AS n FROM projects").get().n;
+				return {
+					files: fedStats.files,
+					chunks: fedStats.chunks,
+					projects
+				};
+			} catch {
+				return null;
+			}
+		})();
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: {
+				uptime: Math.floor((Date.now() - startTime) / 1e3),
+				indexInProgress,
+				lastIndexTime: lastIndexTime ? new Date(lastIndexTime).toISOString() : null,
+				indexIntervalSecs: daemonConfig.indexIntervalSecs,
+				embedInProgress,
+				lastEmbedTime: lastEmbedTime ? new Date(lastEmbedTime).toISOString() : null,
+				embedIntervalSecs: daemonConfig.embedIntervalSecs,
+				socketPath: daemonConfig.socketPath,
+				storageBackend: storageBackend?.backendType ?? "initializing",
+				db: dbStats,
+				vaultIndexInProgress,
+				lastVaultIndexTime: lastVaultIndexTime ? new Date(lastVaultIndexTime).toISOString() : null,
+				vaultPath: daemonConfig.vaultPath ?? null,
+				workQueue: getStats(),
+				backendOutage: getBackendOutage()
+			}
+		});
+		socket.end();
+		return;
+	}
+	if (method === "index_now") {
+		runIndex().catch((e) => {
+			process.stderr.write(`[pai-daemon] index_now error: ${e}\n`);
+		});
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: { triggered: true }
+		});
+		socket.end();
+		return;
+	}
+	if (method === "vault_index_now") {
+		runVaultIndex().catch((e) => {
+			process.stderr.write(`[pai-daemon] vault_index_now error: ${e}\n`);
+		});
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: { triggered: true }
+		});
+		socket.end();
+		return;
+	}
+	if (method === "notification_get_config") {
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: {
+				config: notificationConfig,
+				activeChannels: Object.entries(notificationConfig.channels).filter(([ch, cfg]) => ch !== "voice" && cfg.enabled).map(([ch]) => ch)
+			}
+		});
+		socket.end();
+		return;
+	}
+	if (method === "notification_set_config") {
+		try {
+			const p = params;
+			const updated = patchNotificationConfig({
+				mode: p.mode,
+				channels: p.channels,
+				routing: p.routing
+			});
+			setNotificationConfig(updated);
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: { config: updated }
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "notification_send") {
+		const p = params;
+		if (!p.message) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "notification_send: message is required"
+			});
+			socket.end();
+			return;
+		}
+		routeNotification({
+			event: p.event ?? "info",
+			message: p.message,
+			title: p.title
+		}, notificationConfig).then((result) => {
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result
+			});
+			socket.end();
+		}).catch((e) => {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+			socket.end();
+		});
+		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 === "skill_telemetry_record") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Skill telemetry requires Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			let project_slug = null;
+			if (p.cwd) {
+				const row = registryDb.prepare("SELECT slug FROM projects WHERE status = 'active' AND ? LIKE root_path || '%' ORDER BY length(root_path) DESC LIMIT 1").get(p.cwd);
+				if (row) project_slug = row.slug;
+			}
+			await recordSkillInvocation(pool, {
+				skill_name: p.skill_name,
+				source: p.source,
+				scope: p.scope,
+				project_slug
+			});
+			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;
+	}
+	if (method === "skill_telemetry_query") {
+		const pool = storageBackend.getPool?.();
+		if (!pool) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "Skill telemetry requires Postgres backend"
+			});
+			socket.end();
+			return;
+		}
+		try {
+			const p = params;
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: await querySkillTelemetry(pool, {
+					scope: p.scope,
+					status: p.status,
+					limit: p.limit
+				})
+			});
+		} 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;
+	}
+	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,
+			ok: true,
+			result: await dispatchTool(method, params)
+		});
+	} catch (e) {
+		sendResponse(socket, {
+			id,
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		});
+	}
+	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.
+*/
+function isSocketLive(path) {
+	return new Promise((resolve) => {
+		const client = connect(path);
+		const timer = setTimeout(() => {
+			client.destroy();
+			resolve(false);
+		}, 500);
+		client.on("connect", () => {
+			clearTimeout(timer);
+			client.end();
+			resolve(true);
+		});
+		client.on("error", () => {
+			clearTimeout(timer);
+			resolve(false);
+		});
+	});
+}
+/**
+* Start the Unix Domain Socket IPC server.
+*/
+async function startIpcServer(socketPath) {
+	if (existsSync(socketPath)) {
+		if (await isSocketLive(socketPath)) throw new Error("Another daemon is already running — socket is live. Aborting startup.");
+		try {
+			unlinkSync(socketPath);
+			process.stderr.write("[pai-daemon] Removed stale socket file.\n");
+		} catch {}
+	}
+	const server = createServer((socket) => {
+		let buffer = "";
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString();
+			let nl;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.slice(0, nl);
+				buffer = buffer.slice(nl + 1);
+				if (line.trim() === "") continue;
+				let request;
+				try {
+					request = JSON.parse(line);
+				} catch {
+					sendResponse(socket, {
+						id: "?",
+						ok: false,
+						error: "Invalid JSON"
+					});
+					socket.destroy();
+					return;
+				}
+				handleRequest(request, socket).catch((e) => {
+					const msg = e instanceof Error ? e.message : String(e);
+					sendResponse(socket, {
+						id: request.id,
+						ok: false,
+						error: msg
+					});
+					socket.destroy();
+				});
+			}
+		});
+		socket.on("error", () => {});
+	});
+	server.on("error", (e) => {
+		process.stderr.write(`[pai-daemon] IPC server error: ${e}\n`);
+	});
+	server.listen(socketPath, () => {
+		process.stderr.write(`[pai-daemon] IPC server listening on ${socketPath}\n`);
+	});
+	return server;
+}
+async function serve(config) {
+	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-DTvy-jRB.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 {
+		setRegistryDb(openRegistry());
+		process.stderr.write("[pai-daemon] Registry database opened.\n");
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Fatal: Could not open registry: ${msg}\n`);
+		process.exit(1);
+	}
+	const server = await startIpcServer(config.socketPath);
+	startRegistryScanScheduler();
+	createStorageBackend(config, { waitForPostgres: true }).then((backend) => {
+		setStorageBackend(backend);
+		process.stderr.write(`[pai-daemon] Federation backend: ${backend.backendType}\n`);
+		startIndexScheduler();
+		if (backend.backendType === "postgres") startEmbedScheduler();
+		else process.stderr.write("[pai-daemon] Embed scheduler: disabled (SQLite backend)\n");
+		loadQueue();
+		startWorker();
+	}).catch((e) => {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Fatal: Could not open federation storage: ${msg}\n`);
+		process.exit(1);
+	});
+	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;
+		const deadline = Date.now() + SHUTDOWN_TIMEOUT_MS;
+		if (indexInProgress || embedInProgress) {
+			process.stderr.write(`[pai-daemon] Waiting for in-progress operations to finish (index=${indexInProgress}, embed=${embedInProgress})...\n`);
+			while ((indexInProgress || embedInProgress) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			if (indexInProgress || embedInProgress) process.stderr.write("[pai-daemon] Shutdown timeout reached — forcing exit.\n");
+			else process.stderr.write("[pai-daemon] In-progress operations finished.\n");
+		}
+		try {
+			await storageBackend.close();
+		} catch {}
+		try {
+			unlinkSync(config.socketPath);
+		} catch {}
+		process.exit(0);
+	};
+	process.on("SIGINT", () => {
+		shutdown("SIGINT").catch(() => process.exit(0));
+	});
+	process.on("SIGTERM", () => {
+		shutdown("SIGTERM").catch(() => process.exit(0));
+	});
+	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-BaBTOB1P.mjs.map