@tekmidian/pai 0.42.1 → 0.42.3

package/dist/{daemon-DvXih78C.mjs → daemon-Dq8A1uDF.mjs}

@@ -5,14 +5,14 @@ import { n as indexAll } from "./sync-BWbe8JTg.mjs";
 import { t as configureEmbeddingModel } from "./embeddings-DOLZnT1X.mjs";
 import { l as DEFAULT_NOTIFICATION_CONFIG, n as CONFIG_FILE, t as CONFIG_DIR } from "./config-B64vFg14.mjs";
 import { n as getBackendOutage, t as createStorageBackend } from "./factory-DEb9NmHJ.mjs";
-import { h as readWorkersSection } from "./config-Bi_F6lXf.mjs";
-import { _ as workersLogDir } from "./server-DvN-IFIV.mjs";
-import { _ as loadStatuses, d as alive, h as isChatPane, n as itermForClaudeSession, y as nowStamp } from "./scope-CfYnjy5R.mjs";
-import { C as setStorageBackend, D as storageBackend, E as startTime, O as vaultIndexInProgress, 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, 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-BTa10SOM.mjs";
+import { _ as readWorkersSection } from "./config-_lQI_W08.mjs";
+import { _ as workersLogDir, m as ledgerPath, p as eventsPath } from "./server-D4vAieF4.mjs";
+import { A as nowStamp, C as alive, D as loadStatus, E as isChatPane, O as loadStatuses, _ as itermForClaudeSession, j as appendLedger, n as runWorker } from "./run-CGXbhf2k.mjs";
+import { A as vaultIndexInProgress, C as setShutdownRequested, D as shutdownRequested, E as setVaultIndexInProgress, O as startTime, S as setRegistryDb, T as setStorageBackend, _ as setIndexSchedulerTimer, a as indexInProgress, b as setLastVaultIndexTime, c as lastIndexTime, d as registryDb, f as setCacheKeepaliveTimer, g as setIndexInProgress, h as setEmbedSchedulerTimer, i as embedSchedulerTimer, k as storageBackend, l as lastVaultIndexTime, m as setEmbedInProgress, n as daemonConfig, o as indexSchedulerTimer, p as setDaemonConfig, r as embedInProgress, s as lastEmbedTime, t as cacheKeepaliveTimer, u as notificationConfig, v as setLastEmbedTime, w as setStartTime, x as setNotificationConfig, y as setLastIndexTime } from "./state-BRdB-Bf1.mjs";
 import { t as routeNotification } from "./router-DD6D4j31.mjs";
 import { C as toolProjectInfo, D as toolMemoryGet, O as toolMemorySearch, S as toolProjectHealth, T as toolProjectTodo, a as toolMemoryWakeup, b as toolSessionRoute, i as toolMemoryTaxonomy, n as toolMemoryFeedback, t as toolMemoryKgSearch, v as toolRegistrySearch, w as toolProjectList, x as toolProjectDetect, y as toolSessionList } from "./tools-LlzcV_eK.mjs";
 import { t as detectTopicShift } from "./detector-C73Nxm94.mjs";
-import { a as enqueue, i as stopWorker, n as notifyNewWork, o as getStats, r as startWorker, s as loadQueue } from "./work-queue-worker-DXh_FnT5.mjs";
+import { a as enqueue, i as stopWorker, n as notifyNewWork, o as getStats, r as startWorker, s as loadQueue } from "./work-queue-worker-DIT-VLSh.mjs";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { setPriority } from "node:os";
 import { dirname, join } from "node:path";
@@ -87,6 +87,141 @@ function patchNotificationConfig(patch) {
 	return current;
 }
 
+//#endregion
+//#region src/workers/keepalive.ts
+/**
+* keepalive.ts — one cache-keepalive beat, shared by the daemon scheduler and
+* the probe script.
+*
+* The provider (GLM anthropic-compat endpoint) caches the worker prefix
+* implicitly — no cache_control blocks — so a trivial single-turn worker spawn
+* through the very same runWorker path re-arms that cache for the next real
+* worker: identical env, identical tool grants, identical WORKER_CONTRACT_PROMPT
+* by construction, because it IS a worker spawn.
+*
+* Measured 2026-09-18 (docs/cache-keepalive.md): the implicit cache only
+* serves spawns within seconds of the previous identical request and never
+* survived a 60 s beat cadence in the armed proof — hence the knob defaults
+* to off and arming it is the operator's explicit call.
+*
+* Deliberately NOT a hand-built claude invocation: duplicated prefix
+* construction is how this repo has shipped real breakage before (probeResume
+* x3, archiver x2). Everything flows through runWorker.
+*/
+/**
+* The trivial prompt every cache beat (and probe) carries. Kept in one place
+* so the heartbeat arms exactly the prefix a verifying probe measures.
+*/
+const HEARTBEAT_PROMPT = "Reply with exactly one word: pong.";
+/** The worker class a beat runs as — the cheapest spawn the config defines. */
+const KEEPALIVE_CLASS = "simple";
+/** Worker label of every beat, so `pai worker ps` can tell them apart. */
+const KEEPALIVE_LABEL = "cache-keepalive";
+/** Cadence a keepalive runs at for this config; 0 keeps it off. */
+function keepaliveSecs(workers) {
+	return workers.enabled ? workers.cacheKeepaliveSecs : 0;
+}
+/**
+* The LAST `type:"result"` event of a worker transcript, or null when the
+* file is missing, unreadable, or carries no result line (a failed run can
+* end without one).
+*/
+function parseLastResultEvent(path) {
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+	let found = null;
+	for (const line of text.split("\n")) {
+		if (!line.startsWith("{")) continue;
+		let e;
+		try {
+			e = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (e.type === "result") found = e;
+	}
+	return found;
+}
+/**
+* Metrics of one run from its final result event. Single-turn runs make the
+* cumulative result usage identical to first-turn usage, so a warm cache
+* shows up directly as cache_read_input_tokens > 0.
+*/
+function extractBeatMetrics(m, ev) {
+	const u = ev?.usage;
+	return {
+		...m,
+		input_tokens: u?.input_tokens ?? null,
+		output_tokens: u?.output_tokens ?? null,
+		cache_read_input_tokens: u?.cache_read_input_tokens ?? null,
+		cache_creation_input_tokens: u?.cache_creation_input_tokens ?? null,
+		duration_api_ms: ev?.duration_api_ms ?? null,
+		duration_ms: ev?.duration_ms ?? null,
+		num_turns: ev?.num_turns ?? null
+	};
+}
+/** True while a beat's worker is still running — the overlap guard reads it. */
+let beatInFlight = false;
+/** `keepalive-<YYYYMMDD-HHMMSS>` — beats are minutes apart, seconds suffice. */
+function beatId(d = /* @__PURE__ */ new Date()) {
+	const p = (n) => String(n).padStart(2, "0");
+	return `keepalive-${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+/**
+* One heartbeat: a single-turn trivial worker through the exact worker spawn
+* path, its result metrics parsed from the transcript, one WORKER-KEEPALIVE
+* ledger line. Returns null when another beat is still running (overlap
+* guard) — a skipped beat is free, a queue of them is not.
+*
+* The beat runs in the workers logDir: no session renders its status line
+* there, so the spawn adopts no spawnerSession and no iTerm identity, and
+* worker supervision has no owner to notify — heartbeats are infrastructure,
+* not somebody's workers.
+*/
+async function runKeepaliveBeat(opts = {}) {
+	if (beatInFlight) return null;
+	beatInFlight = true;
+	try {
+		const { workers: config } = readWorkersSection(opts.configPath);
+		const logDir = workersLogDir(config);
+		const id = opts.id ?? beatId();
+		const rc = await runWorker({
+			claudeArgs: ["-p", HEARTBEAT_PROMPT],
+			className: KEEPALIVE_CLASS,
+			label: KEEPALIVE_LABEL,
+			noPane: true,
+			quiet: true,
+			worktreeFlag: false,
+			id,
+			cwd: logDir
+		});
+		const status = loadStatus(logDir, id);
+		const metrics = extractBeatMetrics({
+			id,
+			ok: rc === 0,
+			rc,
+			provider: status?.provider ?? null,
+			model: status?.model ?? null
+		}, parseLastResultEvent(eventsPath(logDir, id)));
+		appendLedger(ledgerPath(logDir), "WORKER-KEEPALIVE", {
+			id,
+			provider: metrics.provider,
+			model: metrics.model,
+			input_tokens: metrics.input_tokens,
+			cache_read_input_tokens: metrics.cache_read_input_tokens,
+			cache_creation_input_tokens: metrics.cache_creation_input_tokens,
+			duration_api_ms: metrics.duration_api_ms
+		});
+		return metrics;
+	} finally {
+		beatInFlight = false;
+	}
+}
+
 //#endregion
 //#region src/workers/supervision.ts
 /**
@@ -379,368 +514,132 @@ async function runSupervisionTick(logDir, opts = {}) {
 }
 
 //#endregion
-//#region src/daemon/daemon/scheduler.ts
+//#region src/observations/store.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.
+* 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.
 */
-/** Minimum interval between vault index runs (30 minutes). */
-const VAULT_INDEX_MIN_INTERVAL_MS = 1800 * 1e3;
+let _tablesEnsured = false;
 /**
-* Run a full index pass. Guards against overlapping runs with indexInProgress.
-* Called both by the scheduler and by the index_now IPC method.
+* 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/).
 */
-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-Cq3gJcq9.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-BPTzKFZU.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);
-	}
-}
+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 vault index pass. Guards against overlapping runs with vaultIndexInProgress.
-* Skips if no vaultPath is configured, or if project index/embed is in progress.
+* 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 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-RXepvbnO.mjs");
-	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-mata9S7b.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);
-	}
+async function ensureObservationTables(pool) {
+	if (_tablesEnsured) return;
+	await pool.query(SCHEMA_SQL);
+	_tablesEnsured = true;
 }
 /**
-* Start the periodic index scheduler. Runs an initial pass 2 seconds after startup.
+* Compute a 16-character hex content hash for deduplication.
+* Hash = SHA256(session_id + tool_name + title).slice(0, 16)
 */
-function startIndexScheduler() {
-	const intervalMs = daemonConfig.indexIntervalSecs * 1e3;
-	process.stderr.write(`[pai-daemon] Index scheduler: every ${daemonConfig.indexIntervalSecs}s\n`);
-	const cycle = (label, withEmbed) => runIndex().then(() => runVaultIndex()).then(() => withEmbed ? runEmbed() : void 0).catch((e) => {
-		process.stderr.write(`[pai-daemon] ${label} index error: ${e}\n`);
-	});
-	if (daemonConfig.maintenanceHour === void 0) setTimeout(() => void cycle("Startup", daemonConfig.embedOnStartup), 2e3);
-	else process.stderr.write("[pai-daemon] Startup index pass skipped (maintenanceHour is set).\n");
-	const firstDelayMs = msUntilNextAnchor(daemonConfig.maintenanceHour, intervalMs);
-	if (daemonConfig.maintenanceHour !== void 0) process.stderr.write(`[pai-daemon] Index scheduler anchored to ${String(daemonConfig.maintenanceHour).padStart(2, "0")}:00 local (next pass in ${Math.round(firstDelayMs / 6e4)} min)\n`);
-	let timer;
-	const startTimer = () => {
-		timer = setInterval(() => void cycle("Scheduled", true), intervalMs);
-		if (timer.unref) timer.unref();
-		setIndexSchedulerTimer(timer);
-	};
-	const first = setTimeout(() => {
-		cycle("Scheduled", true);
-		startTimer();
-	}, firstDelayMs);
-	if (first.unref) first.unref();
+function computeContentHash(sessionId, toolName, title) {
+	return sha256(sessionId + "\0" + toolName + "\0" + title).slice(0, 16);
 }
 /**
-* Milliseconds until the next occurrence of `hour`:00 local time.
-* Falls back to the plain interval when no anchor hour is configured.
+* Insert an observation, skipping duplicates within a 30-second window.
+* Returns the inserted row's id, or null if the insert was suppressed.
 */
-function msUntilNextAnchor(hour, intervalMs) {
-	if (hour === void 0 || !Number.isInteger(hour) || hour < 0 || hour > 23) return intervalMs;
-	const now = /* @__PURE__ */ new Date();
-	const next = new Date(now);
-	next.setHours(hour, 0, 0, 0);
-	if (next <= now) next.setDate(next.getDate() + 1);
-	return next.getTime() - now.getTime();
+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).
+* Attribute an observation to the active project covering `cwd`, then store
+* it. One shared sequence for every daemon-side writer (IPC handler, cache
+* keepalive) so the lookup query exists exactly once.
 */
-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;
+async function storeObservationWithProject(db, pool, obs) {
+	let project_id = null;
+	let project_slug = null;
+	if (obs.cwd) {
+		const row = db.prepare("SELECT id, slug FROM projects WHERE status = 'active' AND ? LIKE root_path || '%' ORDER BY length(root_path) DESC LIMIT 1").get(obs.cwd);
+		if (row) {
+			project_id = row.id;
+			project_slug = row.slug;
+		}
 	}
-	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-BPTzKFZU.mjs");
-		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested, projectNames, { maxMillis: 24e4 });
-		let vaultEmbedCount = 0;
-		if (daemonConfig.vaultPath) try {
-			const { SQLiteBackend } = await import("./sqlite-Cq3gJcq9.mjs");
-			const { openFederation } = await import("./db-O-cyAPfS.mjs");
-			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`);
-	if (daemonConfig.embedOnStartup) setTimeout(() => {
-		runEmbed().catch((e) => {
-			process.stderr.write(`[pai-daemon] Startup embed error: ${e}\n`);
-		});
-	}, 6e4);
-	else process.stderr.write("[pai-daemon] Startup embed pass skipped (embedOnStartup=false).\n");
-	if (daemonConfig.maintenanceHour !== void 0) {
-		process.stderr.write("[pai-daemon] Standalone embed timer not armed (maintenanceHour is set; embed runs at the end of each anchored index cycle).\n");
-		return;
-	}
-	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-19r0cpH4.mjs").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-19r0cpH4.mjs").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();
-}
-/** How often the daemon looks at the worker ledger for supervision events. */
-const SUPERVISION_TICK_MS = 3e4;
-/** First supervision pass waits for the first statuses to exist at all. */
-const SUPERVISION_STARTUP_DELAY_MS = 15e3;
-/**
-* Start the worker supervisor: one tick every 30 s over the workers ledger
-* (src/workers/supervision.ts) that pushes finished/failed/stalled events to
-* the owning session — the daemon-side replacement for orchestrator polling.
-* Daemon code only: no model call has any business being here, and none is
-* made. Disabled workers disable the supervisor with it.
-*/
-function startWorkerSupervisor() {
-	let enabled = false;
-	try {
-		enabled = readWorkersSection().workers.enabled;
-	} catch (e) {
-		process.stderr.write(`[pai-daemon] Worker supervisor: not started (${e instanceof Error ? e.message : String(e)})\n`);
-		return;
-	}
-	if (!enabled) {
-		process.stderr.write("[pai-daemon] Worker supervisor: disabled (workers are off)\n");
-		return;
-	}
-	const tick = () => {
-		runSupervisionTick(workersLogDir(readWorkersSection().workers), { stallMs: stallMinutesFromEnv() * 6e4 }).then((r) => {
-			for (const ev of r.events) process.stderr.write(`[pai-daemon] Supervision: ${ev.text}\n`);
-		}).catch((e) => {
-			process.stderr.write(`[pai-daemon] Supervision tick error: ${e instanceof Error ? e.message : String(e)}\n`);
-		});
-	};
-	const first = setTimeout(tick, SUPERVISION_STARTUP_DELAY_MS);
-	if (first.unref) first.unref();
-	const timer = setInterval(tick, SUPERVISION_TICK_MS);
-	if (timer.unref) timer.unref();
-	process.stderr.write(`[pai-daemon] Worker supervisor: every ${Math.round(SUPERVISION_TICK_MS / 1e3)}s\n`);
-}
-
-//#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;
+	return storeObservation(pool, {
+		...obs,
+		project_id,
+		project_slug
+	});
 }
 /**
 * Filtered query for observations with optional projectId, sessionId, type,
@@ -905,6 +804,335 @@ async function querySkillTelemetry(pool, opts = {}) {
      LIMIT $${idx}`, params)).rows;
 }
 
+//#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-Cq3gJcq9.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-BPTzKFZU.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-CY6I-Hnc.mjs");
+	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-mata9S7b.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, withEmbed) => runIndex().then(() => runVaultIndex()).then(() => withEmbed ? runEmbed() : void 0).catch((e) => {
+		process.stderr.write(`[pai-daemon] ${label} index error: ${e}\n`);
+	});
+	if (daemonConfig.maintenanceHour === void 0) setTimeout(() => void cycle("Startup", daemonConfig.embedOnStartup), 2e3);
+	else process.stderr.write("[pai-daemon] Startup index pass skipped (maintenanceHour is set).\n");
+	const firstDelayMs = msUntilNextAnchor(daemonConfig.maintenanceHour, intervalMs);
+	if (daemonConfig.maintenanceHour !== void 0) process.stderr.write(`[pai-daemon] Index scheduler anchored to ${String(daemonConfig.maintenanceHour).padStart(2, "0")}:00 local (next pass in ${Math.round(firstDelayMs / 6e4)} min)\n`);
+	let timer;
+	const startTimer = () => {
+		timer = setInterval(() => void cycle("Scheduled", true), intervalMs);
+		if (timer.unref) timer.unref();
+		setIndexSchedulerTimer(timer);
+	};
+	const first = setTimeout(() => {
+		cycle("Scheduled", true);
+		startTimer();
+	}, firstDelayMs);
+	if (first.unref) first.unref();
+}
+/**
+* Milliseconds until the next occurrence of `hour`:00 local time.
+* Falls back to the plain interval when no anchor hour is configured.
+*/
+function msUntilNextAnchor(hour, intervalMs) {
+	if (hour === void 0 || !Number.isInteger(hour) || hour < 0 || hour > 23) return intervalMs;
+	const now = /* @__PURE__ */ new Date();
+	const next = new Date(now);
+	next.setHours(hour, 0, 0, 0);
+	if (next <= now) next.setDate(next.getDate() + 1);
+	return next.getTime() - now.getTime();
+}
+/**
+* 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-BPTzKFZU.mjs");
+		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested, projectNames, { maxMillis: 24e4 });
+		let vaultEmbedCount = 0;
+		if (daemonConfig.vaultPath) try {
+			const { SQLiteBackend } = await import("./sqlite-Cq3gJcq9.mjs");
+			const { openFederation } = await import("./db-O-cyAPfS.mjs");
+			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`);
+	if (daemonConfig.embedOnStartup) setTimeout(() => {
+		runEmbed().catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup embed error: ${e}\n`);
+		});
+	}, 6e4);
+	else process.stderr.write("[pai-daemon] Startup embed pass skipped (embedOnStartup=false).\n");
+	if (daemonConfig.maintenanceHour !== void 0) {
+		process.stderr.write("[pai-daemon] Standalone embed timer not armed (maintenanceHour is set; embed runs at the end of each anchored index cycle).\n");
+		return;
+	}
+	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-AEmfVE0F.mjs").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-AEmfVE0F.mjs").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();
+}
+/** How often the daemon looks at the worker ledger for supervision events. */
+const SUPERVISION_TICK_MS = 3e4;
+/** First supervision pass waits for the first statuses to exist at all. */
+const SUPERVISION_STARTUP_DELAY_MS = 15e3;
+/**
+* Start the worker supervisor: one tick every 30 s over the workers ledger
+* (src/workers/supervision.ts) that pushes finished/failed/stalled events to
+* the owning session — the daemon-side replacement for orchestrator polling.
+* Daemon code only: no model call has any business being here, and none is
+* made. Disabled workers disable the supervisor with it.
+*/
+function startWorkerSupervisor() {
+	let enabled = false;
+	try {
+		enabled = readWorkersSection().workers.enabled;
+	} catch (e) {
+		process.stderr.write(`[pai-daemon] Worker supervisor: not started (${e instanceof Error ? e.message : String(e)})\n`);
+		return;
+	}
+	if (!enabled) {
+		process.stderr.write("[pai-daemon] Worker supervisor: disabled (workers are off)\n");
+		return;
+	}
+	const tick = () => {
+		runSupervisionTick(workersLogDir(readWorkersSection().workers), { stallMs: stallMinutesFromEnv() * 6e4 }).then((r) => {
+			for (const ev of r.events) process.stderr.write(`[pai-daemon] Supervision: ${ev.text}\n`);
+		}).catch((e) => {
+			process.stderr.write(`[pai-daemon] Supervision tick error: ${e instanceof Error ? e.message : String(e)}\n`);
+		});
+	};
+	const first = setTimeout(tick, SUPERVISION_STARTUP_DELAY_MS);
+	if (first.unref) first.unref();
+	const timer = setInterval(tick, SUPERVISION_TICK_MS);
+	if (timer.unref) timer.unref();
+	process.stderr.write(`[pai-daemon] Worker supervisor: every ${Math.round(SUPERVISION_TICK_MS / 1e3)}s\n`);
+}
+/** First beat waits a while after boot; the daemon start is itself a warm request. */
+const KEEPALIVE_STARTUP_DELAY_MS = 6e4;
+/**
+* Start the cache keepalive: every workers.cacheKeepaliveSecs one trivial
+* single-turn worker (src/workers/keepalive.ts) re-arms the provider's
+* implicit prompt cache so real worker spawns start warm. Needs no storage
+* backend — it starts with the IPC server, not after the federation connect.
+* 0 (or workers off) keeps it off. A failed beat is logged and swallowed.
+*/
+function startCacheKeepalive(opts = {}) {
+	let workers;
+	try {
+		workers = readWorkersSection(opts.configPath).workers;
+	} catch (e) {
+		process.stderr.write(`[pai-daemon] Cache keepalive: not started (${e instanceof Error ? e.message : String(e)})\n`);
+		return;
+	}
+	if (!workers.enabled) {
+		process.stderr.write("[pai-daemon] Cache keepalive: disabled (workers are off)\n");
+		return;
+	}
+	const secs = keepaliveSecs(workers);
+	if (!secs) {
+		process.stderr.write("[pai-daemon] Cache keepalive: disabled (cacheKeepaliveSecs is 0)\n");
+		return;
+	}
+	let notedNoPostgres = false;
+	const sqliteNote = () => {
+		const pool = storageBackend?.getPool?.();
+		if (pool) return pool;
+		if (!notedNoPostgres) {
+			notedNoPostgres = true;
+			process.stderr.write("[pai-daemon] Cache keepalive: observation rows need Postgres — ledger line only\n");
+		}
+		return null;
+	};
+	const beat = async () => {
+		const m = await (opts.beat ?? runKeepaliveBeat)();
+		if (!m) return;
+		const pool = sqliteNote();
+		if (!pool) return;
+		try {
+			await storeObservationWithProject(registryDb, pool, {
+				session_id: m.id,
+				type: "change",
+				title: `cache keepalive ${m.ok ? "ok" : "failed"} (cache_read=${m.cache_read_input_tokens}, api_ms=${m.duration_api_ms})`,
+				tool_name: "cache-keepalive",
+				narrative: `beat ${m.id}: input=${m.input_tokens} cache_read=${m.cache_read_input_tokens} cache_creation=${m.cache_creation_input_tokens} duration_api_ms=${m.duration_api_ms}`,
+				tool_input_summary: void 0,
+				files_read: [],
+				files_modified: [],
+				concepts: []
+			});
+		} catch (e) {
+			process.stderr.write(`[pai-daemon] Cache keepalive observation error: ${e instanceof Error ? e.message : String(e)}\n`);
+		}
+	};
+	const first = setTimeout(() => {
+		beat().catch((e) => {
+			process.stderr.write(`[pai-daemon] Cache keepalive beat error: ${e instanceof Error ? e.message : String(e)}\n`);
+		});
+	}, KEEPALIVE_STARTUP_DELAY_MS);
+	if (first.unref) first.unref();
+	const timer = setInterval(() => {
+		beat().catch((e) => {
+			process.stderr.write(`[pai-daemon] Cache keepalive beat error: ${e instanceof Error ? e.message : String(e)}\n`);
+		});
+	}, secs * 1e3);
+	if (timer.unref) timer.unref();
+	setCacheKeepaliveTimer(timer);
+	process.stderr.write(`[pai-daemon] Cache keepalive: every ${secs}s\n`);
+}
+
 //#endregion
 //#region src/daemon/daemon/dispatcher.ts
 /**
@@ -1176,33 +1404,22 @@ async function handleRequest(request, socket) {
 		}
 		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, {
+					id: await storeObservationWithProject(registryDb, 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,
+						tool_input_summary: p.tool_input_summary ?? void 0,
 						files_read: p.files_read ?? [],
 						files_modified: p.files_modified ?? [],
-						concepts: p.concepts ?? []
+						concepts: p.concepts ?? [],
+						cwd: p.cwd
 					})
 				}
 			});
@@ -1643,7 +1860,7 @@ async function serve(config) {
 	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-RXepvbnO.mjs");
+	const { notificationConfig } = await import("./state-CY6I-Hnc.mjs");
 	process.stderr.write(`[pai-daemon] Notification mode: ${notificationConfig.mode}\n`);
 	try {
 		setPriority(process.pid, 10);
@@ -1660,6 +1877,7 @@ async function serve(config) {
 	const server = await startIpcServer(config.socketPath);
 	startRegistryScanScheduler();
 	startWorkerSupervisor();
+	startCacheKeepalive();
 	createStorageBackend(config, { waitForPostgres: true }).then((backend) => {
 		setStorageBackend(backend);
 		process.stderr.write(`[pai-daemon] Federation backend: ${backend.backendType}\n`);
@@ -1678,6 +1896,7 @@ async function serve(config) {
 		setShutdownRequested(true);
 		if (indexSchedulerTimer) clearInterval(indexSchedulerTimer);
 		if (embedSchedulerTimer) clearInterval(embedSchedulerTimer);
+		if (cacheKeepaliveTimer) clearInterval(cacheKeepaliveTimer);
 		stopWorker();
 		server.close();
 		const SHUTDOWN_TIMEOUT_MS = 1e4;
@@ -1708,4 +1927,4 @@ async function serve(config) {
 
 //#endregion
 export { serve as t };
-//# sourceMappingURL=daemon-DvXih78C.mjs.map
+//# sourceMappingURL=daemon-Dq8A1uDF.mjs.map