@tekmidian/pai 0.66.1 → 0.66.2

package/dist/daemon-DXlaVCkw.mjs

@@ -1,1741 +0,0 @@
-import { n as createRegistryBackend, o as getBackendOutage, r as createStorageBackend } from "./factory-CNpPQQ-5.mjs";
-import { a as enqueue, c as loadQueue, o as getStats } from "./context-handover-cache-pkHzmL3c.mjs";
-import { S as DEFAULT_NOTIFICATION_CONFIG, d as readMainConfigRaw, f as writeMainConfigRaw } from "./config-BbLFD7Uf.mjs";
-import { D as readWorkersSection } from "./run-env-DRcp7A8K.mjs";
-import { G as loadStatuses, H as isChatPane, P as appendLedger, R as alive, W as loadStatus, n as runWorker, q as nowStamp, x as itermForClaudeSession } from "./run-BCpbxqA5.mjs";
-import { h as ledgerPath, m as eventsPath, v as workersLogDir } from "./server-DgmAHyFK.mjs";
-import { A as vaultIndexInProgress, C as setShutdownRequested, D as shutdownRequested, E as setVaultIndexInProgress, O as startTime, S as setRegistryBackend, T as setStorageBackend, _ as setIndexSchedulerTimer, a as indexInProgress, b as setLastVaultIndexTime, c as lastIndexTime, d as registryBackend, 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-HyjqTihC.mjs";
-import { n as runSessionKeepaliveTick } from "./session-keepalive-DxjTHGcK.mjs";
-import { t as configureEmbeddingModel } from "./embeddings-Bx3q0QOY.mjs";
-import { t as routeNotification } from "./router-a5G7q8_3.mjs";
-import { C as toolProjectInfo, D as toolMemoryGet, O as toolMemoryOutline, S as toolProjectHealth, T as toolProjectTodo, a as toolMemoryWakeup, b as toolSessionRoute, i as toolMemoryTaxonomy, k as toolMemorySearch, n as toolMemoryFeedback, t as toolMemoryKgSearch, v as toolRegistrySearch, w as toolProjectList, x as toolProjectDetect, y as toolSessionList } from "./tools-BcOKPBtg.mjs";
-import { t as detectTopicShift } from "./detector-BRTtAWrM.mjs";
-import { i as stopWorker, n as notifyNewWork, r as startWorker } from "./work-queue-worker-4tLa5gpQ.mjs";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { setPriority } from "node:os";
-import { dirname, join } from "node:path";
-import { execFileSync } from "node:child_process";
-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_FILE (see
-* src/daemon/config.ts's paiConfigFilePath).
-* 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() {
-	let parsed;
-	try {
-		parsed = readMainConfigRaw();
-	} 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_FILE. Creates the file if it does not exist.
-*/
-function saveNotificationConfig(config) {
-	let full = {};
-	try {
-		full = readMainConfigRaw();
-	} catch {}
-	full["notifications"] = config;
-	writeMainConfigRaw(full);
-}
-/**
-* 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/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
-/**
-* 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)
-*   thrashing — state running, runner alive, turning, but the last N tool
-*              executions all failed (PAI_WORKER_THRASH_FAILS, default 5) —
-*              a worker that keeps failing every command never goes quiet,
-*              so the stall detector alone cannot see it
-*   sleeping — state running, one Bash command sleeping N >= 60s with nothing
-*              to wait on — under the stall threshold for runs like
-*              `sleep 500` (8.3m), which would otherwise be invisible until
-*              they cross it. The bounded-wait pattern (background a build or
-*              test, then `sleep 60; ps` cycles) has live children and stays
-*              quiet; stalled and thrashing remain the backstop for a child
-*              that never finishes or dies silently
-*
-* The interactive chat pane (origin "chat") is never supervised: it is the
-* operator's own session, not a task worker. Its status file flips to done
-* when the session ends, and reporting that as "worker finished" to whoever
-* next opens the same tab is noise, not an outcome.
-*
-* 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 kinds that fire mid-run and re-arm on turn progress (see eventId). */
-const MID_RUN_KINDS = [
-	"stalled",
-	"thrashing",
-	"sleeping"
-];
-/**
-* 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;
-}
-/**
-* The consecutive-failure threshold from PAI_WORKER_THRASH_FAILS (default 5),
-* with the same broken-value tolerance as stallMinutesFromEnv.
-*/
-const DEFAULT_THRASH_FAILS = 5;
-function thrashFailsFromEnv(env = process.env) {
-	const raw = env.PAI_WORKER_THRASH_FAILS;
-	if (raw === void 0 || raw === "") return DEFAULT_THRASH_FAILS;
-	const n = Number(raw);
-	return Number.isFinite(n) && n > 0 ? n : DEFAULT_THRASH_FAILS;
-}
-/**
-* Event id: `<worker>#<kind>` for the once-per-run terminal kinds, and
-* `<worker>#<kind>@<turns>` for the mid-run kinds (stalled, thrashing,
-* sleeping) — the turn count re-arms the id, so a worker that resumes and
-* hits the same condition again gets a second event while a restart cannot
-* replay the first.
-*/
-function eventId(worker, kind, turns = 0) {
-	return MID_RUN_KINDS.includes(kind) ? `${worker}#${kind}@${turns}` : `${worker}#${kind}`;
-}
-/**
-* Live child pids of a runner via `pgrep -P` (its exit 1 means "no
-* children"). Any failure — here or in an injected stub — is caught at the
-* one call site in detectSupervisionEvents and reads as an empty list, so a
-* broken check degrades to firing the sleeping event, never to silencing it.
-*/
-function pgrepChildren(pid) {
-	return execFileSync("pgrep", ["-P", String(pid)], { encoding: "utf8" }).split("\n").flatMap((l) => {
-		const n = Number(l.trim());
-		return Number.isInteger(n) && n > 0 ? [n] : [];
-	});
-}
-/** 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}`;
-	if (kind === "thrashing") return `worker ${s.id} ${s.label} thrashing: ${s.consecFails} consecutive failed commands ${tail}`;
-	if (kind === "sleeping") return `worker ${s.id} ${s.label} sleeping ${s.sleepSec}s in one command ${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;
-		if (isChatPane(s)) 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 (ageMs(s.updated, opts.now) > opts.stallMs) {
-			kind = "stalled";
-			stalledMin = Math.floor(ageMs(s.updated, opts.now) / 6e4);
-		} else if ((s.consecFails ?? 0) >= (opts.thrashFails ?? DEFAULT_THRASH_FAILS)) kind = "thrashing";
-		else if (s.sleepSec != null) {
-			let hasChildren = false;
-			if (isAlive(s.pid)) try {
-				hasChildren = (opts.childPids ?? pgrepChildren)(s.pid).length > 0;
-			} catch {
-				hasChildren = false;
-			}
-			if (!hasChildren) kind = "sleeping";
-		}
-		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,
-			...kind === "thrashing" ? { consecFails: s.consecFails ?? 0 } : {},
-			...kind === "sleeping" ? { sleepSec: s.sleepSec ?? 0 } : {},
-			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 the delivered ids of workers the ledger no longer lists (absent means
-* history: their status files are gone) and cap only that history — newest
-* ids last, worker ids sort chronologically — so the persisted state stays
-* bounded. A worker the ledger still lists must never lose its receipts:
-* pruning one un-marks its terminal events as delivered, and every save
-* re-arms them into an unbounded re-delivery loop (the 2026-09-25 incident:
-* one old chain stage re-pushed 7,393 times, because the cap of 500 bit into
-* a ledger of ~1,700 live statuses).
-*/
-function pruneState(state, statuses, maxAbsent = MAX_REMEMBERED_WORKERS) {
-	const present = new Set(statuses.map((s) => s.id));
-	const entries = Object.entries(state.delivered);
-	const byId = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
-	const keptPresent = entries.filter(([id]) => present.has(id)).sort(byId);
-	const absent = entries.filter(([id]) => !present.has(id)).sort(byId);
-	const keptAbsent = absent.slice(Math.max(0, absent.length - maxAbsent));
-	return { delivered: Object.fromEntries([...keptAbsent, ...keptPresent]) };
-}
-/**
-* 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-B8c42Lh8.mjs");
-		const r = await sendToSession(iterm, ev.text);
-		return r.ok || r.timedOut === true;
-	} catch {
-		return false;
-	}
-};
-/**
-* Whether an event should be relayed into the owner's terminal. The mid-run
-* kinds (stalled, thrashing, sleeping) ALWAYS relay: a json/stream-json
-* caller knows the run's result at exit but has no other way to hear
-* mid-run trouble. Only the terminal kinds (finished/failed) skip the relay
-* for those callers — they read the run's result itself, and the harness
-* already notifies them on process exit, so the one-liner would cost a full
-* extra turn for information they already have. Interactive/pane launches
-* and the default text format are never skipped.
-*/
-function shouldRelay(kind, outputFormat) {
-	if (MID_RUN_KINDS.includes(kind)) return true;
-	return outputFormat !== "json" && outputFormat !== "stream-json";
-}
-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,
-		thrashFails: opts.thrashFails ?? thrashFailsFromEnv(),
-		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);
-		if (!shouldRelay(ev.kind, owner?.outputFormat)) continue;
-		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
-/**
-* 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");
-		const { projects, result } = await storageBackend.indexAll(registryBackend);
-		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`);
-	} 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-DW8zdweW.mjs");
-	if (lastVaultIndexTime > 0 && Date.now() - lastVaultIndexTime < VAULT_INDEX_MIN_INTERVAL_MS) return;
-	let vaultProjectId = daemonConfig.vaultProjectId;
-	if (!vaultProjectId) {
-		const row = await registryBackend.getProjectByRootPath(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-BG1sEVyM.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.supportsPostgresFeatures) 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 = await registryBackend.listProjects({ status: "active" });
-			for (const r of rows) projectNames.set(r.id, r.slug);
-		} catch {}
-		const { embedChunksWithBackend } = await import("./indexer-backend-DFF2FrYx.mjs");
-		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested, projectNames, { maxMillis: 24e4 });
-		const elapsed = Date.now() - t0;
-		setLastEmbedTime(Date.now());
-		process.stderr.write(`[pai-daemon] Embed pass complete: ${count} chunks embedded (${elapsed}ms)\n`);
-	} catch (e) {
-		const msg = e instanceof Error ? e.message : String(e);
-		process.stderr.write(`[pai-daemon] Embed error: ${msg}\n`);
-	} finally {
-		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-rFZvTO3p.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-rFZvTO3p.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,
-			thrashFails: thrashFailsFromEnv()
-		}).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 supportsObservations = () => {
-		if (storageBackend?.supportsPostgresFeatures) return true;
-		if (!notedNoPostgres) {
-			notedNoPostgres = true;
-			process.stderr.write("[pai-daemon] Cache keepalive: observation rows need Postgres — ledger line only\n");
-		}
-		return false;
-	};
-	const beat = async () => {
-		const m = await (opts.beat ?? runKeepaliveBeat)();
-		if (!m) return;
-		if (!supportsObservations()) return;
-		try {
-			await storageBackend.storeObservationWithProject(registryBackend, {
-				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`);
-}
-/** Tick cadence: coarse enough to be cheap, fine enough that a session
-*  crossing idleMinutes gets beaten within a minute of becoming eligible. */
-const SESSION_KEEPALIVE_TICK_MS = 6e4;
-/**
-* Start the interactive-session cache keepalive: every 60s, beat every live
-* session that has gone idle past `sessions.cacheKeepalive.idleMinutes`
-* (src/daemon/session-keepalive.ts). Off unless
-* `sessions.cacheKeepalive.enabled` is true — no hot-reload, matching
-* startCacheKeepalive above: config changes need a daemon restart.
-*/
-function startSessionKeepalive() {
-	const config = daemonConfig.sessions.cacheKeepalive;
-	if (!config.enabled) {
-		process.stderr.write("[pai-daemon] Session keepalive: disabled (sessions.cacheKeepalive.enabled is false)\n");
-		return;
-	}
-	const tick = () => {
-		runSessionKeepaliveTick(config).catch((e) => {
-			process.stderr.write(`[pai-daemon] Session keepalive tick error: ${e instanceof Error ? e.message : String(e)}\n`);
-		});
-	};
-	const timer = setInterval(tick, SESSION_KEEPALIVE_TICK_MS);
-	if (timer.unref) timer.unref();
-	process.stderr.write(`[pai-daemon] Session keepalive: every ${SESSION_KEEPALIVE_TICK_MS / 1e3}s (idle >= ${config.idleMinutes}min, hours ${config.activeHours}, max ${config.maxBeats} beats/stretch)\n`);
-}
-
-//#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(registryBackend, storageBackend, p);
-		case "memory_get": return toolMemoryGet(registryBackend, p);
-		case "memory_outline": return toolMemoryOutline(registryBackend, p);
-		case "project_info": return toolProjectInfo(registryBackend, p);
-		case "project_list": return toolProjectList(registryBackend, p);
-		case "session_list": return toolSessionList(registryBackend, p);
-		case "registry_search": return toolRegistrySearch(registryBackend, p);
-		case "project_detect": return toolProjectDetect(p);
-		case "project_health": return toolProjectHealth(registryBackend, p);
-		case "project_todo": return toolProjectTodo(registryBackend, p);
-		case "memory_wakeup": return toolMemoryWakeup(registryBackend, p);
-		case "memory_taxonomy": return toolMemoryTaxonomy(registryBackend, storageBackend, p);
-		case "topic_check": return detectTopicShift(registryBackend, storageBackend, p);
-		case "session_auto_route": return toolSessionRoute(registryBackend, 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-C-_l0o8Z.mjs");
-			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-BCtD3fbe.mjs");
-			return handleGraphClusters(storageBackend, p);
-		}
-		case "graph_neighborhood": {
-			const { handleGraphNeighborhood } = await import("./neighborhood-2FsmzoxG.mjs");
-			return handleGraphNeighborhood(storageBackend, p);
-		}
-		case "graph_note_context": {
-			const { handleGraphNoteContext } = await import("./note-context-De63k8na.mjs");
-			return handleGraphNoteContext(storageBackend, p);
-		}
-		case "graph_trace": {
-			const { handleGraphTrace } = await import("./trace-CtV0RO6n.mjs");
-			return handleGraphTrace(storageBackend, p);
-		}
-		case "graph_latent_ideas": {
-			const { handleGraphLatentIdeas } = await import("./latent-ideas-wwAXquGe.mjs");
-			return handleGraphLatentIdeas(storageBackend, p);
-		}
-		case "idea_materialize": {
-			const { handleIdeaMaterialize } = await import("./latent-ideas-wwAXquGe.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-C-_l0o8Z.mjs");
-			if (!storageBackend.supportsPostgresFeatures) throw new Error(`${method} requires a Postgres storage backend`);
-			switch (method) {
-				case "kg_add": return toolKgAdd(storageBackend, p);
-				case "kg_query": return toolKgQuery(storageBackend, p);
-				case "kg_invalidate": return toolKgInvalidate(storageBackend, p);
-				case "kg_contradictions": return toolKgContradictions(storageBackend, p);
-			}
-			break;
-		}
-		case "memory_tunnels": {
-			const { toolMemoryTunnels } = await import("./tools-C-_l0o8Z.mjs");
-			return toolMemoryTunnels(registryBackend, storageBackend, p);
-		}
-		case "memory_feedback": return await toolMemoryFeedback(storageBackend, p);
-		case "memory_kg_search":
-			if (!storageBackend.supportsPostgresFeatures) throw new Error("memory_kg_search requires a Postgres storage backend for KG triple expansion");
-			return await toolMemoryKgSearch(storageBackend, p);
-		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 = await registryBackend.countProjects();
-				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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: "Observations require Postgres backend"
-			});
-			socket.end();
-			return;
-		}
-		try {
-			const p = params;
-			sendResponse(socket, {
-				id,
-				ok: true,
-				result: {
-					ok: true,
-					id: await storageBackend.storeObservationWithProject(registryBackend, {
-						session_id: p.session_id,
-						type: p.type,
-						title: p.title,
-						narrative: p.narrative ?? null,
-						tool_name: p.tool_name,
-						tool_input_summary: p.tool_input_summary ?? void 0,
-						files_read: p.files_read ?? [],
-						files_modified: p.files_modified ?? [],
-						concepts: p.concepts ?? [],
-						cwd: p.cwd
-					})
-				}
-			});
-		} catch (e) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: e instanceof Error ? e.message : String(e)
-			});
-		}
-		socket.end();
-		return;
-	}
-	if (method === "skill_telemetry_record") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			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 = await registryBackend.findProjectByCwdPrefix(p.cwd);
-				if (row) project_slug = row.slug;
-			}
-			await storageBackend.recordSkillInvocation({
-				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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			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 storageBackend.querySkillTelemetry({
-					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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: "Observations require Postgres backend"
-			});
-			socket.end();
-			return;
-		}
-		try {
-			const p = params;
-			sendResponse(socket, {
-				id,
-				ok: true,
-				result: await storageBackend.queryObservations({
-					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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			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 = await registryBackend.findProjectByCwdPrefix(p.cwd);
-				if (row) {
-					resolvedProjectId = row.id;
-					resolvedProjectSlug = row.slug;
-				}
-			}
-			let rows;
-			if (resolvedProjectId !== void 0) rows = await storageBackend.queryRecentObservations(resolvedProjectId, limit);
-			else rows = await storageBackend.queryObservations({ 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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: "Observations require Postgres backend"
-			});
-			socket.end();
-			return;
-		}
-		try {
-			const p = params;
-			let projectId;
-			if (p.project_slug) projectId = (await registryBackend.getProjectBySlug(p.project_slug))?.id;
-			sendResponse(socket, {
-				id,
-				ok: true,
-				result: await storageBackend.queryObservations({
-					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") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: "Observations require Postgres backend"
-			});
-			socket.end();
-			return;
-		}
-		try {
-			sendResponse(socket, {
-				id,
-				ok: true,
-				result: await storageBackend.getObservationStats()
-			});
-		} catch (e) {
-			sendResponse(socket, {
-				id,
-				ok: false,
-				error: e instanceof Error ? e.message : String(e)
-			});
-		}
-		socket.end();
-		return;
-	}
-	if (method === "session_summary_store") {
-		if (!storageBackend?.supportsPostgresFeatures) {
-			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 = await registryBackend.findProjectByCwdPrefix(p.cwd);
-				if (row) {
-					resolvedProjectId = row.id;
-					resolvedProjectSlug = row.slug;
-				}
-			}
-			await storageBackend.storeSessionSummary({
-				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/storage/postgres/fts-migration.ts
-const DONE_MARKER = "fts:simple";
-const PROGRESS_PREFIX = "fts:simple:inprogress:";
-const BATCH_SIZE = 1e3;
-const MAX_ATTEMPTS = 5;
-const RETRYABLE_CODES = new Set(["40P01", "40001"]);
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function migrateFtsConfig(backend) {
-	const pool = backend.getPool();
-	if ((await pool.query(`SELECT 1 FROM information_schema.tables WHERE table_name = 'pai_chunks'`)).rowCount === 0) return;
-	const comment = (await pool.query(`SELECT col_description('pai_chunks'::regclass, ordinal_position) AS comment
-     FROM information_schema.columns
-     WHERE table_name = 'pai_chunks' AND column_name = 'fts_vector'`)).rows[0]?.comment ?? null;
-	if (comment === DONE_MARKER) return;
-	const resumeId = comment?.startsWith(PROGRESS_PREFIX) ? comment.slice(22) : "";
-	process.stderr.write("[pai-postgres] FTS config migration: starting (english -> simple)\n");
-	if ((await pool.query(`SELECT 1 FROM pg_proc WHERE proname = 'pai_chunks_fts_update'`)).rowCount !== 0) {
-		await pool.query(`
-      CREATE OR REPLACE FUNCTION pai_chunks_fts_update()
-      RETURNS TRIGGER AS $$
-      BEGIN
-        NEW.fts_vector := to_tsvector('simple', COALESCE(NEW.text, ''));
-        RETURN NEW;
-      END;
-      $$ LANGUAGE plpgsql;
-    `);
-		process.stderr.write("[pai-postgres] FTS config migration: trigger function now uses 'simple'\n");
-	}
-	let lastId = resumeId || null;
-	if (lastId !== null) process.stderr.write(`[pai-postgres] FTS config migration: resuming from ${lastId}\n`);
-	let totalUpdated = 0;
-	let batchN = 0;
-	while (true) {
-		const sql = lastId === null ? `SELECT id FROM pai_chunks ORDER BY id LIMIT $1` : `SELECT id FROM pai_chunks WHERE id > $2 ORDER BY id LIMIT $1`;
-		const params = lastId === null ? [BATCH_SIZE] : [BATCH_SIZE, lastId];
-		const idRows = await pool.query(sql, params);
-		if (idRows.rows.length === 0) break;
-		const ids = idRows.rows.map((r) => r.id);
-		for (let attempt = 1;; attempt++) try {
-			const result = await pool.query(`UPDATE pai_chunks c SET fts_vector = to_tsvector('simple', COALESCE(c.text, ''))
-           FROM (SELECT id FROM pai_chunks WHERE id = ANY($1::text[]) ORDER BY id FOR UPDATE) s
-           WHERE c.id = s.id
-             AND c.fts_vector IS DISTINCT FROM to_tsvector('simple', COALESCE(c.text, ''))`, [ids]);
-			totalUpdated += result.rowCount ?? 0;
-			break;
-		} catch (err) {
-			const code = err.code;
-			if (attempt >= MAX_ATTEMPTS || !code || !RETRYABLE_CODES.has(code)) throw err;
-			await sleep(200 * attempt);
-		}
-		lastId = ids[ids.length - 1];
-		batchN++;
-		if (batchN % 20 === 0) {
-			await pool.query(`COMMENT ON COLUMN pai_chunks.fts_vector IS '${PROGRESS_PREFIX}${lastId.replace(/'/g, "''")}'`);
-			process.stderr.write(`[pai-postgres] FTS config migration: ${totalUpdated} chunks rebuilt so far...\n`);
-		}
-		if (idRows.rows.length < BATCH_SIZE) break;
-	}
-	await pool.query(`COMMENT ON COLUMN pai_chunks.fts_vector IS '${DONE_MARKER}'`);
-	process.stderr.write(`[pai-postgres] FTS config migration: done, ${totalUpdated} chunks rebuilt\n`);
-}
-
-//#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-DW8zdweW.mjs");
-	process.stderr.write(`[pai-daemon] Notification mode: ${notificationConfig.mode}\n`);
-	try {
-		setPriority(process.pid, 10);
-	} catch {}
-	configureEmbeddingModel(config.embeddingModel);
-	createRegistryBackend(config, { waitForPostgres: true }).then((backend) => {
-		setRegistryBackend(backend);
-		process.stderr.write(`[pai-daemon] Registry backend: ${backend.backendType}\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();
-	startWorkerSupervisor();
-	startCacheKeepalive();
-	startSessionKeepalive();
-	createStorageBackend(config, { waitForPostgres: true }).then((backend) => {
-		setStorageBackend(backend);
-		process.stderr.write(`[pai-daemon] Federation backend: ${backend.backendType}\n`);
-		startIndexScheduler();
-		if (backend.supportsPostgresFeatures) {
-			startEmbedScheduler();
-			migrateFtsConfig(backend).catch((e) => {
-				const msg = e instanceof Error ? e.message : String(e);
-				process.stderr.write(`[pai-daemon] FTS config migration failed: ${msg}\n`);
-			});
-		} 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);
-		if (cacheKeepaliveTimer) clearInterval(cacheKeepaliveTimer);
-		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
-export { serve as t };
-//# sourceMappingURL=daemon-DXlaVCkw.mjs.map