@tekmidian/pai 0.41.0 → 0.42.1

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

@@ -3,15 +3,19 @@ import { t as openFederation } from "./db-a1ixZQjr.mjs";
 import { d as sha256 } from "./helpers-IjZkXBhj.mjs";
 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-D1G9IFpn.mjs";
-import { n as getBackendOutage, t as createStorageBackend } from "./factory-Bc5EyN54.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-ahFAbD8b.mjs";
-import { t as routeNotification } from "./router-DHracTUC.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-CMlHa9lZ.mjs";
-import { t as detectTopicShift } from "./detector-smpCm7ku.mjs";
-import { a as enqueue, i as stopWorker, n as notifyNewWork, o as getStats, r as startWorker, s as loadQueue } from "./work-queue-worker-B3nl8yyn.mjs";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+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 { 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 { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { setPriority } from "node:os";
+import { dirname, join } from "node:path";
 import { connect, createServer } from "node:net";
 
 //#region src/notifications/config.ts
@@ -83,6 +87,297 @@ function patchNotificationConfig(patch) {
 	return current;
 }
 
+//#endregion
+//#region src/workers/supervision.ts
+/**
+* supervision.ts — daemon-side worker supervision, event push not polling.
+*
+* An orchestrating session must keep an eye on its workers without sleeping
+* (the Worker skill forbids busy-waiting), the same way the AIBroker daemon
+* keeps an eye on sessions. The PAI daemon already runs all day; this module
+* gives it a tick that watches every worker's status file and pushes one-line
+* events to the owning session when something happens:
+*
+*   finished — the run ended clean (state done, rc 0)
+*   failed   — the run ended badly (state failed/killed/lost, or rc != 0,
+*              or the runner pid vanished while state was still running)
+*   stalled  — state running, runner alive, but no new turn for longer than
+*              the stall threshold (PAI_WORKER_STALL_MINUTES, default 10);
+*              never emitted for the interactive chat pane (origin "chat"),
+*              which idles between sessions by design
+*
+* Delivery, in order of preference, never both counted as required:
+*   1. AIBroker `send_to_session` into the orchestrator's terminal — the
+*      one-line Agentish-style notification, arriving as a user turn without
+*      the orchestrator asking for it. Needs the iTerm identity of the owner,
+*      which the status line bridges into the session map (see scope.ts).
+*   2. An append-only event file, <logDir>/supervision/<owner>.events, one
+*      JSON line per event. The UserPromptSubmit hook
+*      (src/hooks/ts/user-prompt/worker-supervision.ts) surfaces undelivered
+*      lines into the session that owns them, so the events reach the model
+*      on its next turn even with AIBroker absent.
+*
+* Exactly-once: every event carries a deterministic id and the set of
+* delivered ids per worker is persisted (<logDir>/supervision/state.json), so
+* a daemon restart replays nothing. A first run with no state adopts every
+* already-terminal worker as delivered — supervision reports transitions it
+* observes, not history. Chain stages are separate workers with their own
+* status files and are supervised individually.
+*
+* No model is ever called from here — this is daemon code, and it must stay
+* that way: supervision that bills tokens to watch tokens is a bug.
+*/
+/**
+* The owning session of a worker, or null when nobody claims it (and so
+* nothing to notify): the spawner's claude session id first — that is what
+* the hook knows a session by — else the AIBroker iTerm uuid.
+*/
+function ownershipKey(s) {
+	if (s.spawnerSession) return s.spawnerSession;
+	if (s.session?.id) return s.session.id;
+	return null;
+}
+const TERMINAL = [
+	"done",
+	"failed",
+	"killed",
+	"lost"
+];
+function isTerminal(s) {
+	return TERMINAL.includes(s.state);
+}
+/** Age of a "YYYY-MM-DD HH:MM:SS" stamp in ms, NaN-safe (unparsable → 0). */
+function ageMs(ts, now) {
+	const t = Date.parse(ts.replace(" ", "T"));
+	if (Number.isNaN(t)) return 0;
+	return Math.max(0, now.getTime() - t);
+}
+/**
+* The stall threshold in minutes from PAI_WORKER_STALL_MINUTES (default 10).
+* Anything unparsible or non-positive falls back to the default — a broken
+* value must not turn supervision off or make it fire every tick.
+*/
+const DEFAULT_STALL_MINUTES = 10;
+function stallMinutesFromEnv(env = process.env) {
+	const raw = env.PAI_WORKER_STALL_MINUTES;
+	if (raw === void 0 || raw === "") return DEFAULT_STALL_MINUTES;
+	const n = Number(raw);
+	return Number.isFinite(n) && n > 0 ? n : DEFAULT_STALL_MINUTES;
+}
+/**
+* Event id: `<worker>#<kind>` for the once-per-run terminal kinds, and
+* `<worker>#stalled@<turns>` for stalls — the turn count re-arms the id, so a
+* worker that resumes and stalls again gets a second event while a restart
+* cannot replay the first.
+*/
+function eventId(worker, kind, turns = 0) {
+	return kind === "stalled" ? `${worker}#stalled@${turns}` : `${worker}#${kind}`;
+}
+/** One event's one-liner — the exact line the orchestrator reads. */
+function eventText(kind, s, rc, stalledMin) {
+	const tail = `- see pai worker replay ${s.id}`;
+	if (kind === "finished") return `worker ${s.id} ${s.label} finished rc=0 ${tail}`;
+	if (kind === "stalled") return `worker ${s.id} ${s.label} stalled ${stalledMin}m no turns ${tail}`;
+	const why = rc === null ? "runner gone" : `rc=${rc}`;
+	return `worker ${s.id} ${s.label} failed ${why} ${tail}`;
+}
+/**
+* Detect conditions across a ledger snapshot. Pure: statuses in, events out;
+* dedup against delivered ids is the caller's job (see filterUndelivered).
+* Workers without an owning session are skipped — nobody to notify.
+*/
+function detectSupervisionEvents(statuses, opts) {
+	const isAlive = opts.isAlive ?? alive;
+	const deadGraceMs = opts.deadGraceMs ?? 15e3;
+	const out = [];
+	for (const s of statuses) {
+		const session = ownershipKey(s);
+		if (!session) continue;
+		let kind = null;
+		let rc = null;
+		let stalledMin = null;
+		if (isTerminal(s)) if (s.state === "done" && (s.rc ?? 0) === 0) {
+			kind = "finished";
+			rc = 0;
+		} else {
+			kind = "failed";
+			rc = s.state === "lost" ? null : s.rc;
+		}
+		else if (!isAlive(s.pid) && ageMs(s.updated, opts.now) > deadGraceMs) {
+			kind = "failed";
+			rc = null;
+		} else if (!isChatPane(s) && ageMs(s.updated, opts.now) > opts.stallMs) {
+			kind = "stalled";
+			stalledMin = Math.floor(ageMs(s.updated, opts.now) / 6e4);
+		}
+		if (!kind) continue;
+		out.push({
+			id: eventId(s.id, kind, s.turns),
+			ts: nowStamp(opts.now),
+			kind,
+			worker: s.id,
+			label: s.label,
+			session,
+			rc,
+			stalledMin,
+			text: eventText(kind, s, rc, stalledMin)
+		});
+	}
+	return out;
+}
+/** Cap on remembered workers: terminal and delivered is history, not state. */
+const MAX_REMEMBERED_WORKERS = 500;
+function supervisionDirPath(logDir) {
+	return join(logDir, "supervision");
+}
+function supervisionStatePath(logDir) {
+	return join(supervisionDirPath(logDir), "state.json");
+}
+function supervisionEventsPath(logDir, session) {
+	return join(supervisionDirPath(logDir), `${session}.events`);
+}
+/** Receipts of events already pushed into a terminal, one event id per line. */
+function supervisionPushedPath(logDir, session) {
+	return join(supervisionDirPath(logDir), `${session}.pushed`);
+}
+function loadSupervisionState(path) {
+	if (!existsSync(path)) return {
+		state: { delivered: {} },
+		fresh: true
+	};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (parsed && typeof parsed === "object" && typeof parsed.delivered === "object") return {
+			state: parsed,
+			fresh: false
+		};
+	} catch {}
+	return {
+		state: { delivered: {} },
+		fresh: true
+	};
+}
+function saveSupervisionState(path, state) {
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmp = `${path}.tmp`;
+	writeFileSync(tmp, JSON.stringify(state), "utf8");
+	renameSync(tmp, path);
+}
+/**
+* Drop workers the ledger no longer lists and cap the rest (newest ids last —
+* worker ids sort chronologically), so the persisted state stays bounded.
+*/
+function pruneState(state, statuses) {
+	const present = new Set(statuses.map((s) => s.id));
+	const kept = Object.entries(state.delivered).filter(([id]) => present.has(id)).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).slice(-MAX_REMEMBERED_WORKERS);
+	return { delivered: Object.fromEntries(kept) };
+}
+/**
+* First run: adopt every already-terminal worker as delivered. Supervision
+* reports the transitions it observes from now on, never a replay of every
+* worker that ever finished before it started.
+*/
+function baselineState(statuses) {
+	const delivered = {};
+	for (const s of statuses) {
+		if (!isTerminal(s) || !ownershipKey(s)) continue;
+		delivered[s.id] = [eventId(s.id, "finished"), eventId(s.id, "failed")];
+	}
+	return { delivered };
+}
+/** The events whose ids the state has not seen yet. */
+function filterUndelivered(events, state) {
+	return events.filter((e) => !(state.delivered[e.worker] ?? []).includes(e.id));
+}
+function markDelivered(state, events) {
+	for (const e of events) {
+		const ids = state.delivered[e.worker] ?? [];
+		if (!ids.includes(e.id)) ids.push(e.id);
+		state.delivered[e.worker] = ids;
+	}
+}
+/**
+* Default push: AIBroker `send_to_session` into the orchestrator's terminal,
+* using the iTerm uuid the worker recorded (`session.id`) or the one the
+* session map bridges for the spawner's claude session. A timeout still
+* delivered (see aibroker-client) counts as delivered; every failure is
+* reported as not-delivered so only the event file carries the event.
+*/
+const aibrokerPush = async (logDir, target, ev) => {
+	const iterm = target.iterm ?? (target.claudeSession ? itermForClaudeSession(logDir, target.claudeSession) : null);
+	if (!iterm) return false;
+	try {
+		const { sendToSession } = await import("./aibroker-client-C6m71p6O.mjs");
+		const r = await sendToSession(iterm, ev.text);
+		return r.ok || r.timedOut === true;
+	} catch {
+		return false;
+	}
+};
+function appendEventFile(logDir, ev) {
+	const path = supervisionEventsPath(logDir, ev.session);
+	const dir = supervisionDirPath(logDir);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	appendFileSync(path, JSON.stringify(ev) + "\n", "utf8");
+}
+/** Record that an event reached its owner's terminal — the hook then skips it. */
+function appendPushReceipt(logDir, ev) {
+	try {
+		appendFileSync(supervisionPushedPath(logDir, ev.session), `${ev.id}\n`, "utf8");
+	} catch {}
+}
+/**
+* One supervision pass over the ledger: detect, append each new event to its
+* owner's event file, push it best effort, persist the delivered ids. The
+* event file is the durable record — an event is marked delivered only after
+* its line landed there, so a failed tick retries, a repeated one replays
+* nothing.
+*/
+async function runSupervisionTick(logDir, opts = {}) {
+	const now = opts.now ?? /* @__PURE__ */ new Date();
+	const statuses = opts.statuses ?? loadStatuses(logDir);
+	const statePath = supervisionStatePath(logDir);
+	const loaded = loadSupervisionState(statePath);
+	let state = loaded.state;
+	if (loaded.fresh) state = baselineState(statuses);
+	const pending = filterUndelivered(detectSupervisionEvents(statuses, {
+		stallMs: opts.stallMs ?? DEFAULT_STALL_MINUTES * 6e4,
+		now,
+		...opts.isAlive ? { isAlive: opts.isAlive } : {}
+	}), state);
+	const written = [];
+	for (const ev of pending) {
+		appendEventFile(logDir, ev);
+		written.push(ev);
+	}
+	const push = opts.push ?? aibrokerPush;
+	const pushed = [];
+	for (const ev of written) {
+		const owner = statuses.find((s) => s.id === ev.worker);
+		const target = {
+			claudeSession: owner?.spawnerSession ?? null,
+			iterm: owner?.session?.id ?? null
+		};
+		let ok = false;
+		try {
+			ok = await push(logDir, target, ev);
+		} catch {
+			ok = false;
+		}
+		if (ok) {
+			pushed.push(ev);
+			appendPushReceipt(logDir, ev);
+		}
+	}
+	markDelivered(state, written);
+	saveSupervisionState(statePath, pruneState(state, statuses));
+	return {
+		events: written,
+		pushed
+	};
+}
+
 //#endregion
 //#region src/daemon/daemon/scheduler.ts
 /**
@@ -110,7 +405,7 @@ async function runIndex() {
 	try {
 		process.stderr.write("[pai-daemon] Starting scheduled index run...\n");
 		if (storageBackend.backendType === "sqlite") {
-			const { SQLiteBackend } = await import("./sqlite-kFZeWCJ2.mjs");
+			const { SQLiteBackend } = await import("./sqlite-Cq3gJcq9.mjs");
 			if (storageBackend instanceof SQLiteBackend) {
 				const { projects, result } = await indexAll(storageBackend.getRawDb(), registryDb);
 				const elapsed = Date.now() - t0;
@@ -118,7 +413,7 @@ async function runIndex() {
 				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-rohVVKrA.mjs");
+			const { indexAllWithBackend } = await import("./indexer-backend-BPTzKFZU.mjs");
 			const { projects, result } = await indexAllWithBackend(storageBackend, registryDb);
 			const elapsed = Date.now() - t0;
 			setLastIndexTime(Date.now());
@@ -145,7 +440,7 @@ async function runVaultIndex() {
 		process.stderr.write("[pai-daemon] Index/embed in progress, deferring vault index.\n");
 		return;
 	}
-	const { lastVaultIndexTime } = await import("./state-DH_mp5Xe.mjs");
+	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) {
@@ -157,7 +452,7 @@ async function runVaultIndex() {
 	const t0 = Date.now();
 	process.stderr.write("[pai-daemon] Starting vault index run...\n");
 	try {
-		const { indexVault } = await import("./vault-indexer-YMH22mLU.mjs");
+		const { indexVault } = await import("./vault-indexer-mata9S7b.mjs");
 		const r = await indexVault(storageBackend, vaultProjectId, daemonConfig.vaultPath);
 		const elapsed = Date.now() - t0;
 		setLastVaultIndexTime(Date.now());
@@ -228,11 +523,11 @@ async function runEmbed() {
 			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-rohVVKrA.mjs");
+		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-kFZeWCJ2.mjs");
+			const { SQLiteBackend } = await import("./sqlite-Cq3gJcq9.mjs");
 			const { openFederation } = await import("./db-O-cyAPfS.mjs");
 			const federationDb = openFederation();
 			const vaultSqliteBackend = new SQLiteBackend(federationDb);
@@ -292,17 +587,53 @@ const REGISTRY_SCAN_STARTUP_DELAY_MS = 1e4;
 function startRegistryScanScheduler() {
 	process.stderr.write("[pai-daemon] Registry scan scheduler: every 30min (first in 10s)\n");
 	setTimeout(() => {
-		import("./work-queue-worker-BM1GcAAq.mjs").then(({ enqueueRegistryScan }) => enqueueRegistryScan()).catch((e) => {
+		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-BM1GcAAq.mjs").then(({ enqueueRegistryScan }) => enqueueRegistryScan()).catch((e) => {
+		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
@@ -607,7 +938,7 @@ async function dispatchTool(method, params) {
 		case "zettel_themes":
 		case "zettel_god_notes":
 		case "zettel_communities": {
-			const { toolZettelExplore, toolZettelHealth, toolZettelSurprise, toolZettelSuggest, toolZettelConverse, toolZettelThemes, toolZettelGodNotes, toolZettelCommunities } = await import("./tools-COna9vZR.mjs");
+			const { toolZettelExplore, toolZettelHealth, toolZettelSurprise, toolZettelSuggest, toolZettelConverse, toolZettelThemes, toolZettelGodNotes, toolZettelCommunities } = await import("./tools-BW3NLMPk.mjs");
 			switch (method) {
 				case "zettel_explore": return toolZettelExplore(storageBackend, p);
 				case "zettel_health": return toolZettelHealth(storageBackend, p);
@@ -621,27 +952,27 @@ async function dispatchTool(method, params) {
 			break;
 		}
 		case "graph_clusters": {
-			const { handleGraphClusters } = await import("./clusters-DRHhfli9.mjs");
+			const { handleGraphClusters } = await import("./clusters-j0ZuNYp9.mjs");
 			return handleGraphClusters(storageBackend.getPool?.() ?? null, storageBackend, p);
 		}
 		case "graph_neighborhood": {
-			const { handleGraphNeighborhood } = await import("./neighborhood-AGL7oXQ2.mjs");
+			const { handleGraphNeighborhood } = await import("./neighborhood-CM7Jgb51.mjs");
 			return handleGraphNeighborhood(storageBackend.getPool?.() ?? null, storageBackend, p);
 		}
 		case "graph_note_context": {
-			const { handleGraphNoteContext } = await import("./note-context-BHwYpSFf.mjs");
+			const { handleGraphNoteContext } = await import("./note-context-DCwE2A-M.mjs");
 			return handleGraphNoteContext(storageBackend.getPool?.() ?? null, storageBackend, p);
 		}
 		case "graph_trace": {
-			const { handleGraphTrace } = await import("./trace-DTP6k4B_.mjs");
+			const { handleGraphTrace } = await import("./trace-u4hT-pLD.mjs");
 			return handleGraphTrace(storageBackend, p);
 		}
 		case "graph_latent_ideas": {
-			const { handleGraphLatentIdeas } = await import("./latent-ideas-iNp5s55R.mjs");
+			const { handleGraphLatentIdeas } = await import("./latent-ideas-CtSca4qG.mjs");
 			return handleGraphLatentIdeas(storageBackend, p);
 		}
 		case "idea_materialize": {
-			const { handleIdeaMaterialize } = await import("./latent-ideas-iNp5s55R.mjs");
+			const { handleIdeaMaterialize } = await import("./latent-ideas-CtSca4qG.mjs");
 			if (!daemonConfig.vaultPath) throw new Error("idea_materialize requires vaultPath to be configured in the daemon config");
 			return handleIdeaMaterialize(p, daemonConfig.vaultPath);
 		}
@@ -649,7 +980,7 @@ async function dispatchTool(method, params) {
 		case "kg_query":
 		case "kg_invalidate":
 		case "kg_contradictions": {
-			const { toolKgAdd, toolKgQuery, toolKgInvalidate, toolKgContradictions } = await import("./tools-COna9vZR.mjs");
+			const { toolKgAdd, toolKgQuery, toolKgInvalidate, toolKgContradictions } = await import("./tools-BW3NLMPk.mjs");
 			const pgPool = storageBackend.getPool?.() ?? null;
 			if (!pgPool) throw new Error(`${method} requires a Postgres storage backend`);
 			switch (method) {
@@ -661,7 +992,7 @@ async function dispatchTool(method, params) {
 			break;
 		}
 		case "memory_tunnels": {
-			const { toolMemoryTunnels } = await import("./tools-COna9vZR.mjs");
+			const { toolMemoryTunnels } = await import("./tools-BW3NLMPk.mjs");
 			return toolMemoryTunnels(registryDb, storageBackend, p);
 		}
 		case "memory_feedback": {
@@ -1312,7 +1643,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-DH_mp5Xe.mjs");
+	const { notificationConfig } = await import("./state-RXepvbnO.mjs");
 	process.stderr.write(`[pai-daemon] Notification mode: ${notificationConfig.mode}\n`);
 	try {
 		setPriority(process.pid, 10);
@@ -1328,6 +1659,7 @@ async function serve(config) {
 	}
 	const server = await startIpcServer(config.socketPath);
 	startRegistryScanScheduler();
+	startWorkerSupervisor();
 	createStorageBackend(config, { waitForPostgres: true }).then((backend) => {
 		setStorageBackend(backend);
 		process.stderr.write(`[pai-daemon] Federation backend: ${backend.backendType}\n`);
@@ -1376,4 +1708,4 @@ async function serve(config) {
 
 //#endregion
 export { serve as t };
-//# sourceMappingURL=daemon-CpdVUnl_.mjs.map
+//# sourceMappingURL=daemon-DvXih78C.mjs.map