@tekmidian/pai 0.71.0 → 0.71.1

package/dist/indexer-backend-1tkR2y1-.mjs

@@ -0,0 +1,4188 @@
+import { B as readWorkersSection, E as isLocalProvider, H as resolveModelCapability, Kt as loadStatusConfig, Ot as loadStatuses, Tt as isLive, Xt as writeContinueToForge, fn as workersLogDir, in as ensureNoMcpConfig, w as defaultWorkersConfig } from "./config-CH2Xj7BG.mjs";
+import { c as migratePaiFile, d as resolvePaiFile, r as daemonPidPath, u as paiHomePath } from "./runtime-paths-BKtuLoJm.mjs";
+import { b as writeJsonAtomic, c as loadConfig, f as readMainConfigRaw, n as CONFIG_FILE, p as writeMainConfigRaw } from "./config-D7w6FDaM.mjs";
+import { t as appendLedger } from "./ledger-D6xicYlV.mjs";
+import { x as worktreesDir } from "./worktree-BO_SncO-.mjs";
+import { a as itermUuid, u as sessionMapPath } from "./scope-B_kKDJhY.mjs";
+import { i as loopbackRouterChoice, t as buildRunEnv } from "./run-env-DpRktidn.mjs";
+import { h as resolveTarget } from "./routing-D6nQ__Ar.mjs";
+import { c as DEFAULT_PROXY_PORT, l as ensureProxyRunning } from "./launch-BkE8NqUd.mjs";
+import { i as getRegistryBackend, r as createStorageBackend } from "./factory-DXisI5XK.mjs";
+import { n as fetchLiveSessions, r as sendToSession } from "./aibroker-client-eRILToKG.mjs";
+import { Ut as probeRouter } from "./run-DwHfR1WP.mjs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, loadavg, setPriority, tmpdir, userInfo } from "node:os";
+import { basename, delimiter, dirname, join } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { copyFileSync as copyFileSync$1, existsSync as existsSync$1, linkSync as linkSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { basename as basename$1, join as join$1, resolve as resolve$1 } from "path";
+import { homedir as homedir$1 } from "os";
+
+//#region src/session/checkpoint-block.ts
+/**
+* Shared "## Continue" checkpoint logic for a project's TODO.md.
+*
+* WHY THIS MODULE EXISTS
+* ----------------------
+* Before this, `pause.ts` and `handover.ts` each carried their own copy of
+* findProjectTodo / stripContinueSection / block-builder. Both wrote the same
+* fixed four-line block, and both stripped any existing ## Continue section
+* unconditionally. The consequence was that a rich, model-authored checkpoint
+* could never survive:
+*
+*   1. `pai pause` had no way to accept a body, so the model printed its
+*      checkpoint to the terminal and it was lost.
+*   2. Even if a body had been written by hand, the session-stop hook runs
+*      `pai session handover` on every clean exit, which regenerated the
+*      generic block and erased it.
+*
+* So there are two jobs here:
+*
+*   - AUTHORED writes (`pai pause --body-file`) carry the model's markdown
+*     verbatim, wrapped in explicit start/end markers.
+*   - AUTO writes (hooks) must never destroy an authored checkpoint belonging
+*     to the *same* session. They may replace a stale one left by an earlier
+*     session, otherwise TODO.md would show a checkpoint that no longer
+*     describes where the work stands.
+*
+* PARSING
+* -------
+* A rich body can legitimately contain `---` rules and `##` headings, which the
+* old heuristic scanner treated as section terminators. Authored blocks are
+* therefore delimited by an explicit HTML-comment pair; the legacy heuristic is
+* kept only as a fallback for blocks written before this change.
+*/
+/** Locations searched for a project TODO.md, in priority order. */
+const TODO_LOCATIONS = [
+	"Notes/TODO.md",
+	".claude/Notes/TODO.md",
+	"tasks/todo.md",
+	"TODO.md"
+];
+const MARKER_OPEN = "<!-- pai:checkpoint";
+const MARKER_CLOSE = "<!-- /pai:checkpoint -->";
+/**
+* Markers for a handover that has been superseded but not thrown away.
+*
+* Deliberately NOT `pai:checkpoint`: `locateContinue` scans for that marker and
+* for the `## Continue` heading, so an archived block written verbatim would be
+* found as the live section and rewritten in place of it. Archived entries are
+* inert by construction — different marker, no heading.
+*/
+const ARCHIVE_OPEN = "<!-- pai:archived-handover";
+const ARCHIVE_CLOSE = "<!-- /pai:archived-handover -->";
+const ARCHIVE_HEADING = "## Previous handovers";
+/**
+* How many superseded handovers TODO.md keeps.
+*
+* Enough that a handover survives a run of sessions that each end without
+* pausing, which is the sequence that destroyed one on 2026-08-04. Not
+* unbounded: TODO.md is read by a human at the top of every session, and a file
+* that grows without limit stops being read, which is its own kind of loss.
+*/
+const ARCHIVE_LIMIT = 5;
+const CONTINUE_HEADING = "## Continue";
+function findProjectTodo(rootPath) {
+	for (const rel of TODO_LOCATIONS) {
+		const full = join(rootPath, rel);
+		if (existsSync(full)) try {
+			return {
+				path: full,
+				content: readFileSync(full, "utf8")
+			};
+		} catch {}
+	}
+	return null;
+}
+/**
+* Resolve the TODO.md to write to, creating Notes/ if nothing exists yet.
+* Returns null only when the directory could not be created.
+*/
+function resolveTodoTarget(rootPath, opts = {}) {
+	const found = findProjectTodo(rootPath);
+	if (found) return found;
+	const notesDir = join(rootPath, "Notes");
+	if (opts.create !== false) try {
+		if (!existsSync(notesDir)) mkdirSync(notesDir, { recursive: true });
+	} catch {
+		return null;
+	}
+	return {
+		path: join(notesDir, "TODO.md"),
+		content: ""
+	};
+}
+/**
+* Parse a `<!-- pai:checkpoint key="value" ... -->` marker line.
+* Returns null when the line is not a marker.
+*/
+function parseMarker(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith(MARKER_OPEN)) return null;
+	const attrs = {};
+	for (const m of trimmed.matchAll(/([a-zA-Z][\w-]*)="([^"]*)"/g)) attrs[m[1]] = m[2];
+	return {
+		authored: attrs.authored === "model" ? "model" : "auto",
+		session: attrs.session || void 0,
+		sessionId: attrs["session-id"] || void 0,
+		ts: attrs.ts || void 0
+	};
+}
+/**
+* Lines an auto-generated block is made of. Anything else in a section is
+* content somebody put there deliberately.
+*
+* The blockquote marker is optional on every pattern. These lines appear
+* quoted when the block builder emits them as its header, and unquoted when a
+* caller passes the same text as a BODY — which the session-stop hook does: it
+* builds `Working directory: ${cwd}` and hands it over as state. Matching only
+* the quoted form made such a body read as content, which is how a session
+* that did no work at all overwrote a real handover on 2026-08-04. A line that
+* merely restates the generated header is boilerplate wherever it sits.
+*/
+const BOILERPLATE_PATTERNS = [
+	/^##\s+Continue$/,
+	/^<!--\s*\/?pai:checkpoint/,
+	/^>?\s*\*\*Last session:\*\*/,
+	/^>?\s*\*\*Paused at:\*\*/,
+	/^>?\s*Working directory:/,
+	/^>?\s*Resume with:/,
+	/^>?\s*_No checkpoint body was recorded/,
+	/^-{3,}$/
+];
+/** A blank line, with or without a blockquote marker. */
+const BLANK_LINE = /^>?\s*$/;
+/**
+* True when a section contains nothing but generated header lines.
+*
+* This is the guard that stops an auto write from destroying content it did
+* not author. A session that hit the old clobbering bug may have worked around
+* it by hand — writing its state into a subsection underneath the generated
+* header lines, in an unmarked block. Those blocks predate the marker, so
+* authorship cannot be read off them; the only safe signal is whether anything
+* beyond boilerplate is present.
+*/
+function isBoilerplateOnly(lines) {
+	return lines.every((line) => {
+		const t = line.trim();
+		return BLANK_LINE.test(t) || BOILERPLATE_PATTERNS.some((re) => re.test(t));
+	});
+}
+/**
+* True when a checkpoint body says something the generated header does not.
+*
+* "Has a body" and "has something to say" are not the same question, and the
+* preservation rules care only about the second. An unattended writer that
+* emits a single line restating the working directory has produced a body by
+* any string test and a handover by none.
+*/
+function hasSubstance(body) {
+	const text = (body ?? "").trim();
+	if (!text) return false;
+	return !isBoilerplateOnly(text.split("\n"));
+}
+/**
+* Extract the non-boilerplate content of a section, or "" if there is none.
+*
+* Interior blank lines are kept. They are not decoration — in Markdown they
+* are what separates a paragraph from the table or list that follows, so
+* dropping them (as this did while it treated every blank line as boilerplate)
+* silently welds a checkpoint body into one unreadable run.
+*/
+function extractSectionContent(lines) {
+	const kept = [];
+	for (const line of lines) {
+		const t = line.trim();
+		if (BOILERPLATE_PATTERNS.some((re) => re.test(t))) continue;
+		kept.push(line);
+	}
+	return trimBlankEdges(collapseBlankRuns(kept)).join("\n");
+}
+/** Drop leading and trailing blank lines, leaving interior spacing alone. */
+function trimBlankEdges(lines) {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && BLANK_LINE.test(lines[start].trim())) start += 1;
+	while (end > start && BLANK_LINE.test(lines[end - 1].trim())) end -= 1;
+	return lines.slice(start, end);
+}
+/**
+* Collapse runs of blank lines to a single blank.
+*
+* Removing a boilerplate line leaves the blank that surrounded it behind, so
+* stripping the header can open a three-line gap in the middle of the body.
+* One blank line is all Markdown needs.
+*/
+function collapseBlankRuns(lines) {
+	const out = [];
+	let lastWasBlank = false;
+	for (const line of lines) {
+		const isBlank = BLANK_LINE.test(line.trim());
+		if (isBlank && lastWasBlank) continue;
+		out.push(line);
+		lastWasBlank = isBlank;
+	}
+	return out;
+}
+/**
+* Locate the existing ## Continue section.
+*
+* When the section carries an explicit marker pair, the close marker defines
+* the end — this is what lets a rich body contain `---` and `##` safely.
+* Otherwise the legacy heuristic applies: stop at the first `---` or the next
+* `##` heading.
+*/
+function locateContinue(content) {
+	const lines = content.split("\n");
+	const startIdx = lines.findIndex((l) => l.trim() === CONTINUE_HEADING);
+	if (startIdx === -1) return null;
+	let meta = null;
+	let markerIdx = -1;
+	for (let i = startIdx + 1; i < Math.min(startIdx + 6, lines.length); i++) {
+		const parsed = parseMarker(lines[i]);
+		if (parsed) {
+			meta = parsed;
+			markerIdx = i;
+			break;
+		}
+		if (lines[i].trim() !== "") break;
+	}
+	let endIdx = lines.length;
+	if (markerIdx !== -1) {
+		const closeIdx = lines.findIndex((l, i) => i > markerIdx && l.trim() === MARKER_CLOSE);
+		if (closeIdx !== -1) endIdx = closeIdx + 1;
+		else endIdx = heuristicEnd(lines, startIdx);
+	} else endIdx = heuristicEnd(lines, startIdx);
+	let trailingEnd = endIdx;
+	while (trailingEnd < lines.length && lines[trailingEnd].trim() === "") trailingEnd += 1;
+	if (trailingEnd < lines.length && lines[trailingEnd].trim() === "---") trailingEnd += 1;
+	else trailingEnd = endIdx;
+	return {
+		startIdx,
+		endIdx: trailingEnd,
+		meta,
+		lines: lines.slice(startIdx, trailingEnd)
+	};
+}
+/**
+* Legacy scanner for blocks written before checkpoint markers existed.
+*
+* Terminates on a horizontal rule or the next level-1 or level-2 heading. Note
+* the `(?!#)` — `###` is a *subsection* of `## Continue`, not a terminator. The
+* original scanner stopped at any run of `#`, which meant a `### Restored
+* state` subsection fell outside the section entirely and could not be seen,
+* let alone carried forward.
+*
+* `#{1,2}` rather than `##`, because matching only `##` did not stop at an H1
+* and therefore ATE IT. A TODO.md whose `## Continue` block precedes its
+* `# TODO` title had the title absorbed into the section and destroyed on the
+* next regenerate — reported independently by three sessions on 2026-08-03,
+* one of which lost it three times and recovered from git each time.
+*
+* An H1 is a document-level heading. It can never be part of a `## Continue`
+* section, so treating it as a terminator is not a heuristic improvement but a
+* structural fact.
+*/
+function heuristicEnd(lines, startIdx) {
+	for (let i = startIdx + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed === "---" || /^#{1,2}(?!#)/.test(trimmed) && trimmed !== CONTINUE_HEADING) return i;
+	}
+	return lines.length;
+}
+/** Remove the ## Continue section, returning the remainder of the document. */
+function stripContinue(content) {
+	const found = locateContinue(content);
+	if (!found) return content;
+	const lines = content.split("\n");
+	const before = lines.slice(0, found.startIdx);
+	const after = lines.slice(found.endIdx);
+	while (after.length > 0 && after[0].trim() === "") after.shift();
+	return [...before, ...after].join("\n");
+}
+function escapeAttr(value) {
+	return value.replace(/"/g, "'");
+}
+function buildContinueBlock(opts) {
+	const ts = opts.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+	const attrs = [
+		`authored="${opts.authored}"`,
+		`session="${escapeAttr(opts.sessionLine)}"`,
+		opts.sessionId ? `session-id="${escapeAttr(opts.sessionId)}"` : null,
+		`ts="${ts}"`
+	].filter(Boolean).join(" ");
+	const header = [
+		`> **Last session:** ${opts.sessionLine}`,
+		`> **Paused at:** ${ts}`,
+		">",
+		`> Working directory: ${opts.cwd}`
+	];
+	if (opts.sessionId) header.push(">", `> Resume with: \`claude --resume ${opts.sessionId}\``);
+	const body = (opts.body ?? "").trim();
+	const parts = [
+		CONTINUE_HEADING,
+		"",
+		`${MARKER_OPEN} ${attrs} -->`,
+		"",
+		...header
+	];
+	if (body) parts.push("", body);
+	else parts.push(">", "> _No checkpoint body was recorded — see the latest session note._");
+	parts.push("", MARKER_CLOSE, "", "---", "");
+	return parts.join("\n");
+}
+/**
+* Write the ## Continue block, honouring the preservation rules.
+*
+* An AUTO write is unattended — it fires from the session-stop and pre-compact
+* hooks — so it operates under one governing rule: **never destroy content it
+* did not author.** Three cases follow from that:
+*
+*   1. An authored checkpoint for the SAME session is left untouched. The hooks
+*      fire after the model has already recorded the real state; overwriting it
+*      with metadata is the bug this module exists to fix.
+*
+*      "Same session" is decided by the Claude session UUID whenever both sides
+*      know it, and only falls back to the human-readable session line when one
+*      of them does not. The line is derived from the session note filename,
+*      and `session-stop.sh` *renames and renumbers that file* — via `session
+*      slug --apply` and `session cleanup --execute` — before it reaches the
+*      handover step. So the key the hook computes at exit is not the key the
+*      model wrote seconds earlier, and a filename-keyed comparison mismatches
+*      by construction. Observed live on 2026-08-01: notes renumbered twice
+*      within a single session. The UUID is the only identifier that holds
+*      still.
+*   2. An authored checkpoint from an EARLIER session is stale — TODO.md would
+*      otherwise keep pointing at the wrong session — so it is replaced. Its
+*      content is not lost: `pai pause` mirrors every authored body into the
+*      session note.
+*   3. An UNMARKED block predates the marker, so authorship cannot be read off
+*      it. If it is nothing but generated header lines it is replaced. If it
+*      carries anything else, that content was put there deliberately — quite
+*      possibly as a hand-rolled workaround for the very clobbering this fixes —
+*      and is carried forward into the new block rather than dropped.
+*
+* A MODEL write always replaces: the model is authoring the checkpoint, and a
+* newer one supersedes an older one.
+*/
+/**
+* Do an existing checkpoint and an incoming write describe the same session?
+*
+* The UUID is authoritative when both sides carry one: it is assigned by Claude
+* Code and never changes for the life of the session. The session line is a
+* derived, mutable label and is only consulted when there is no UUID to compare
+* — a checkpoint written before `--session-id` was threaded through, or an auto
+* write from a caller that was not given one.
+*/
+function isSameSession(meta, opts) {
+	if (meta.sessionId && opts.sessionId) return meta.sessionId === opts.sessionId;
+	return meta.session === opts.sessionLine;
+}
+/**
+* How long a model-authored checkpoint is protected from automated overwriting.
+*
+* Sized for the race, not for the session: the gap between a model writing its
+* checkpoint and a hook firing is seconds to minutes, and an hour covers even a
+* slow checkpoint on a loaded machine. Anything genuinely from an earlier
+* session is hours or days old and still falls through to case 2, which is what
+* keeps TODO.md from freezing on a checkpoint nobody will ever replace.
+*/
+const AUTHORED_GRACE_MS = 3600 * 1e3;
+/** Was this checkpoint written recently enough to still belong to the run in progress? */
+function isRecent(meta, now) {
+	if (!meta.ts) return false;
+	const then = Date.parse(meta.ts);
+	if (Number.isNaN(then)) return false;
+	const nowMs = now ? Date.parse(now) : Date.now();
+	if (Number.isNaN(nowMs)) return false;
+	return nowMs - then < AUTHORED_GRACE_MS;
+}
+/**
+* Turn a live checkpoint block into an inert archive entry.
+*
+* Two things have to go: the `## Continue` heading and the `pai:checkpoint`
+* marker. Both are what `locateContinue` looks for, so leaving either in place
+* would let a later write treat the archive as the live section — and the next
+* one after that would then archive the archive. Everything else is kept
+* verbatim, because the body is the whole reason this exists.
+*/
+function toArchiveEntry(lines, meta) {
+	const out = [];
+	const label = meta?.session ?? "Unknown session";
+	const stamp = meta?.ts ? ` — checkpointed ${meta.ts}` : "";
+	out.push(`${ARCHIVE_OPEN} session="${label}"${meta?.ts ? ` ts="${meta.ts}"` : ""} -->`);
+	out.push("");
+	out.push(`### ${label}${stamp}`);
+	out.push("");
+	for (const line of lines) {
+		if (line.trim() === CONTINUE_HEADING) continue;
+		if (line.trim().startsWith(MARKER_OPEN)) continue;
+		if (line.trim() === MARKER_CLOSE) continue;
+		if (line.trim() === "---") continue;
+		out.push(line);
+	}
+	while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
+	out.push("");
+	out.push(ARCHIVE_CLOSE);
+	return out;
+}
+/**
+* Put a superseded handover into the archive section, newest first.
+*
+* `rest` is the document with the Continue section already stripped. The
+* archive lives immediately below it so a reader meets the current handover
+* first and the previous ones directly after, rather than hunting for them at
+* the bottom of a file that also holds the project's open work.
+*/
+function archiveInto(rest, entry) {
+	const lines = rest.split("\n");
+	const headingIdx = lines.findIndex((l) => l.trim() === ARCHIVE_HEADING);
+	if (headingIdx === -1) return [
+		ARCHIVE_HEADING,
+		"",
+		...entry,
+		"",
+		"---",
+		"",
+		rest.trimStart()
+	].join("\n");
+	const before = lines.slice(0, headingIdx + 1);
+	const after = lines.slice(headingIdx + 1);
+	while (after.length > 0 && after[0].trim() === "") after.shift();
+	const merged = [
+		...entry,
+		"",
+		...after
+	];
+	const kept = [];
+	let seen = 0;
+	for (let i = 0; i < merged.length; i++) {
+		if (merged[i].trim().startsWith(ARCHIVE_OPEN)) {
+			seen += 1;
+			if (seen > ARCHIVE_LIMIT) {
+				while (i < merged.length && merged[i].trim() !== ARCHIVE_CLOSE) i++;
+				continue;
+			}
+		}
+		kept.push(merged[i]);
+	}
+	return [
+		...before,
+		"",
+		...kept
+	].join("\n");
+}
+function applyContinue(opts) {
+	if (!opts.dryRun) try {
+		const cfg = loadStatusConfig(opts.rootPath);
+		if (cfg.sink === "forge") {
+			const block = buildContinueBlock(opts);
+			if (opts.authored === "auto" && !hasSubstance(opts.body)) return {
+				action: "preserved",
+				path: null,
+				block
+			};
+			writeContinueToForge(opts.rootPath, cfg, block, {});
+			return {
+				action: "written",
+				path: null,
+				block
+			};
+		}
+	} catch (e) {
+		const why = e instanceof Error ? e.message : String(e);
+		console.error(`handover: forge write failed (${why}) - wrote Notes/TODO.md instead`);
+	}
+	const target = resolveTodoTarget(opts.rootPath, { create: !opts.dryRun });
+	if (!target) return {
+		action: "failed",
+		path: null,
+		block: buildContinueBlock(opts),
+		error: "Could not resolve or create a TODO.md target"
+	};
+	const existing = locateContinue(target.content);
+	let carriedForward = false;
+	let effectiveBody = opts.body;
+	let archiveEntry = null;
+	if (opts.authored === "auto" && existing) {
+		if (existing.meta?.authored === "model" && isSameSession(existing.meta, opts)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta
+		};
+		if (existing.meta && !hasSubstance(opts.body) && !isBoilerplateOnly(existing.lines)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta ?? void 0
+		};
+		if (existing.meta?.authored === "model" && isRecent(existing.meta, opts.timestamp) && !isBoilerplateOnly(existing.lines)) return {
+			action: "preserved",
+			path: target.path,
+			block: buildContinueBlock(opts),
+			preservedMeta: existing.meta
+		};
+		if (existing.meta?.authored === "model" && !isBoilerplateOnly(existing.lines) && !isSameSession(existing.meta, opts)) archiveEntry = toArchiveEntry(existing.lines, existing.meta);
+		if (!existing.meta && !isBoilerplateOnly(existing.lines)) {
+			const salvaged = extractSectionContent(existing.lines);
+			if (salvaged) {
+				effectiveBody = [
+					"_Carried forward from the previous checkpoint (author unknown — this",
+					"block predates checkpoint authorship markers):_",
+					"",
+					salvaged
+				].join("\n");
+				carriedForward = true;
+			}
+		}
+	}
+	const block = buildContinueBlock({
+		...opts,
+		body: effectiveBody
+	});
+	if (opts.dryRun) return {
+		action: "written",
+		path: target.path,
+		block,
+		carriedForward,
+		archived: !!archiveEntry
+	};
+	const rest = stripContinue(target.content).trimStart();
+	const newContent = block + (archiveEntry ? archiveInto(rest, archiveEntry) : rest);
+	const tmpPath = `${target.path}.continue.tmp`;
+	try {
+		writeFileSync(tmpPath, newContent, "utf8");
+		renameSync(tmpPath, target.path);
+	} catch (err) {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+		} catch {}
+		return {
+			action: "failed",
+			path: target.path,
+			block,
+			error: String(err)
+		};
+	}
+	return {
+		action: "written",
+		path: target.path,
+		block,
+		carriedForward,
+		archived: !!archiveEntry
+	};
+}
+/** ADAPTER_DIR (harness adapter root) — mirrors pai-paths.ts's resolveAdapterDir(),
+*  kept self-contained here to avoid importing pai-paths.ts's process.exit(1)
+*  validation side effect. PAI_DIR is the deprecated alias, same as there. */
+function getPaiDir() {
+	const envDir = process.env.ADAPTER_DIR || process.env.PAI_DIR;
+	if (envDir) try {
+		return realpathSync(envDir);
+	} catch {
+		return envDir;
+	}
+	return join(homedir(), ".claude");
+}
+/**
+* Find the notes directory for a project — local first, then the central
+* ~/.claude/projects/<encoded>/Notes fallback. Never creates.
+*/
+function findNotesDir$1(rootPath, encodedDir) {
+	for (const rel of [
+		"Notes",
+		"notes",
+		".claude/Notes"
+	]) {
+		const p = join(rootPath, rel);
+		if (existsSync(p)) return p;
+	}
+	const central = join(getPaiDir(), "projects", encodedDir, "Notes");
+	if (existsSync(central)) return central;
+	return null;
+}
+/**
+* Find the current (highest-numbered) session note: current month, then the
+* previous month, then a flat notesDir as legacy fallback.
+*/
+function findLatestNote(notesDir) {
+	const findIn = (dir) => {
+		if (!existsSync(dir)) return null;
+		let files;
+		try {
+			files = readdirSync(dir);
+		} catch {
+			return null;
+		}
+		const notes = files.filter((f) => /^\d{3,4}[\s_-].*\.md$/.test(f)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] ?? "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] ?? "0", 10);
+		});
+		return notes.length > 0 ? join(dir, notes[notes.length - 1]) : null;
+	};
+	const now = /* @__PURE__ */ new Date();
+	const current = findIn(join(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (current) return current;
+	const prev = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findIn(join(notesDir, String(prev.getFullYear()), String(prev.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findIn(notesDir);
+}
+/**
+* Append the checkpoint body to a session note.
+*
+* TODO.md's ## Continue is a single slot that every later checkpoint
+* overwrites. The session note is the durable record, so the body goes to both.
+* Idempotent per timestamp: re-running with the same stamp will not duplicate.
+*/
+function appendCheckpointToNote(notePath, body, timestamp) {
+	const heading = `## Pause Checkpoint — ${timestamp ?? (/* @__PURE__ */ new Date()).toISOString()}`;
+	let existing;
+	try {
+		existing = readFileSync(notePath, "utf8");
+	} catch (err) {
+		return {
+			appended: false,
+			error: String(err)
+		};
+	}
+	if (existing.includes(heading)) return { appended: false };
+	const block = `\n\n---\n\n${heading}\n\n${body.trim()}\n`;
+	const tmpPath = `${notePath}.checkpoint.tmp`;
+	try {
+		writeFileSync(tmpPath, existing.trimEnd() + block, "utf8");
+		renameSync(tmpPath, notePath);
+	} catch (err) {
+		try {
+			if (existsSync(tmpPath)) renameSync(tmpPath, `${tmpPath}.dead`);
+		} catch {}
+		return {
+			appended: false,
+			error: String(err)
+		};
+	}
+	return { appended: true };
+}
+/** Read a checkpoint body from a file, or from stdin when path is "-". */
+function readBodyFile(path) {
+	if (path === "-") return readFileSync(0, "utf8");
+	return readFileSync(path, "utf8");
+}
+
+//#endregion
+//#region src/hooks/ts/lib/context-handover-cache.ts
+/**
+* context-handover-cache.ts — the well-known file where the threshold-
+* triggered pre-compaction handover (see ../../../daemon/context-handover-
+* worker.ts) is written, and where context-compression-hook.ts looks for it
+* at compaction time.
+*
+* Deliberately dependency-light (fs/os/path only). The daemon worker that
+* WRITES this file needs the heavier machinery in session-summary-worker.ts
+* (spawning Claude, git log, etc.), but the PreCompact hook that READS it
+* runs as a short-lived process on every compaction and must not drag in
+* daemon state, database pools, or anything else that module graph carries —
+* this file is the shared seam so neither side has to.
+*/
+function contextHandoverCachePath(sessionId) {
+	return join(tmpdir(), `pai-context-handover-${sessionId}.json`);
+}
+function readContextHandoverCache(sessionId) {
+	const path = contextHandoverCachePath(sessionId);
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeContextHandoverCache(cache) {
+	writeFileSync(contextHandoverCachePath(cache.sessionId), JSON.stringify(cache, null, 2), "utf-8");
+}
+/** A handover older than this is not "current" even when generated after the
+*  previous compaction: a session fills its window over hours, and a cache
+*  written at the start of that fill misses everything since. */
+const HANDOVER_MAX_AGE_MS = 7200 * 1e3;
+
+//#endregion
+//#region src/daemon/daemon-pid.ts
+/**
+* daemon-pid.ts — the one way PAI finds the running daemon's PID.
+*
+* Never by command-line pattern: `pgrep -f` matches any process whose argv
+* mentions the text (a worker whose spec quotes it, an editor), and the caller
+* then signals the wrong process. The service manager knows the PID; when none
+* is in use (`pai daemon serve` in a container) the daemon's own pidfile does.
+*/
+const LAUNCHD_LABEL = "com.pai.pai-daemon";
+const SYSTEMD_UNIT = "pai-daemon.service";
+/** `pid = N` from `launchctl print gui/<uid>/<label>`; undefined when not running. */
+function parseLaunchctlPid(out) {
+	const m = /^\s*pid = (\d+)\s*$/m.exec(out);
+	return m ? Number(m[1]) : void 0;
+}
+/** `MainPID=N` from `systemctl --user show -p MainPID`; 0 means not running. */
+function parseSystemdMainPid(out) {
+	const n = Number(/^MainPID=(\d+)\s*$/m.exec(out)?.[1]);
+	return n > 0 ? n : void 0;
+}
+const run = (cmd, args) => {
+	const r = spawnSync(cmd, args, { encoding: "utf8" });
+	return {
+		status: r.status,
+		stdout: r.stdout ?? ""
+	};
+};
+/** Start time of a process (epoch ms) or undefined when it does not exist. */
+function processStart(pid, sh) {
+	const r = sh("ps", [
+		"-o",
+		"lstart=",
+		"-p",
+		String(pid)
+	]);
+	if (r.status !== 0 || !r.stdout.trim()) return void 0;
+	const t = Date.parse(r.stdout.trim());
+	return Number.isNaN(t) ? void 0 : t;
+}
+/**
+* PID from the pidfile, only if that process is alive and started no later
+* than the pidfile was written (ps start times have 1 s resolution). A process
+* that started after the file is a reused PID and is not the daemon.
+*/
+function pidfilePid(path = daemonPidPath(), sh = run) {
+	try {
+		const pid = parseInt(readFileSync(path, "utf8").trim(), 10);
+		if (!(pid > 0)) return void 0;
+		const started = processStart(pid, sh);
+		if (started === void 0 || started > statSync(path).mtimeMs + 2e3) return void 0;
+		return pid;
+	} catch {
+		return;
+	}
+}
+/** The running daemon's PID: service manager first, pidfile second, else undefined. */
+function resolveDaemonPid(plat = process.platform, sh = run, path = daemonPidPath()) {
+	if (plat === "darwin") {
+		const r = sh("launchctl", ["print", `gui/${process.getuid?.() ?? userInfo().uid}/${LAUNCHD_LABEL}`]);
+		const pid = r.status === 0 ? parseLaunchctlPid(r.stdout) : void 0;
+		if (pid) return pid;
+	} else if (plat === "linux") {
+		const r = sh("systemctl", [
+			"--user",
+			"show",
+			"-p",
+			"MainPID",
+			SYSTEMD_UNIT
+		]);
+		const pid = r.status === 0 ? parseSystemdMainPid(r.stdout) : void 0;
+		if (pid) return pid;
+	}
+	return pidfilePid(path, sh);
+}
+function writeDaemonPidfile(path = daemonPidPath()) {
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, `${process.pid}\n`, "utf8");
+	} catch {}
+}
+/** Remove the pidfile only if it is ours (a newer daemon may own it). */
+function removeDaemonPidfile(path = daemonPidPath()) {
+	try {
+		if (parseInt(readFileSync(path, "utf8").trim(), 10) === process.pid) unlinkSync(path);
+	} catch {}
+}
+
+//#endregion
+//#region src/memory/embed-pass.ts
+/**
+* Embed-pass policy: time budget, yield rules and the record of the last pass.
+*
+* An embed pass over a multi-million chunk backlog is hours of CPU. It runs
+* under a wall-clock budget (embedMaxMinutes), at low priority, and steps aside
+* while a local-model worker holds the machine or the load average is high.
+*/
+const DEFAULT_EMBED_MAX_MINUTES = 60;
+const DEFAULT_EMBED_MAX_LOAD = 8;
+/** Modest batch: small enough that a budget or yield check lands within seconds. */
+const EMBED_PASS_BATCH_SIZE = 25;
+/** True when a running or queued worker uses a provider on this machine. */
+function localWorkerBusy(logDir, providers) {
+	try {
+		return loadStatuses(logDir).some((s) => {
+			const p = providers[s.provider];
+			return s.state === "running" && !!p && isLocalProvider(p.baseUrl) && isLive(s);
+		});
+	} catch {
+		return false;
+	}
+}
+/** Reason to hold the pass back right now, or null to go ahead. */
+function embedYieldReason(o) {
+	if (o.localBusy) return "local-model worker running";
+	if (o.load > o.maxLoad) return `load average ${o.load.toFixed(1)} above ${o.maxLoad}`;
+	return null;
+}
+/** The live yield check for a pass: reads the load average and the worker statuses. */
+function liveYieldCheck(maxLoad) {
+	return () => {
+		let logDir = "";
+		let providers = {};
+		try {
+			const { workers } = readWorkersSection();
+			logDir = workersLogDir(workers);
+			providers = workers.providers ?? {};
+		} catch {}
+		return embedYieldReason({
+			load: loadavg()[0],
+			maxLoad,
+			localBusy: logDir ? localWorkerBusy(logDir, providers) : false
+		});
+	};
+}
+const OUTCOME_TEXT = {
+	done: "done",
+	budget: "budget hit",
+	yielded: "yielded"
+};
+/** The `pai daemon status` lines for the embed backlog and the last pass. */
+function formatEmbedStatus(s) {
+	const lines = [];
+	if (typeof s.embedBacklog === "number") lines.push(`Embed:       ${s.embedBacklog} chunks without vectors`);
+	const p = s.lastEmbedPass;
+	if (p) lines.push(`Last embed:  ${OUTCOME_TEXT[p.outcome]}, ${p.embedded} chunks at ${p.at}${p.reason ? ` (${p.reason})` : ""}`);
+	return lines;
+}
+
+//#endregion
+//#region src/daemon/quiet.ts
+/**
+* Daemon quiet mode: for benchmark and overnight runs, defer every maintenance
+* job (registry scan, index/embed passes, triple extraction, the nightly
+* cycle, disk-scanning housekeeping) and run each deferred kind once when
+* quiet ends. Session notes, summaries and the context handover are never
+* gated: compaction needs them.
+*
+* State lives in config.yaml as `quiet: { on: true, until?: <ISO> }`, so the
+* CLI and the daemon share it without IPC. Jobs ask `deferIfQuiet(kind)` at
+* their dispatch point; `flushDeferredIfEnded` (polled by the daemon) runs the
+* registered runner of each deferred kind once.
+*/
+/** How often the daemon checks whether quiet has ended. */
+const QUIET_POLL_MS = 3e4;
+/** Parse the `quiet` config value. An expired `until` reads as off. */
+function parseQuiet(raw, now = Date.now()) {
+	if (!raw || typeof raw !== "object") return { on: false };
+	const q = raw;
+	if (q.on !== true) return { on: false };
+	if (q.until === void 0 || q.until === null) return { on: true };
+	const until = typeof q.until === "number" ? q.until : Date.parse(String(q.until));
+	if (Number.isNaN(until)) return { on: true };
+	return until > now ? {
+		on: true,
+		until
+	} : { on: false };
+}
+/** Next local time-of-day HH:MM strictly after `now`. Throws on bad input. */
+function nextOccurrence(hhmm, now = Date.now()) {
+	const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+	if (!m || Number(m[1]) > 23 || Number(m[2]) > 59) throw new Error(`--until expects HH:MM (00:00-23:59), got "${hhmm}"`);
+	const d = new Date(now);
+	d.setHours(Number(m[1]), Number(m[2]), 0, 0);
+	if (d.getTime() <= now) d.setDate(d.getDate() + 1);
+	return d.getTime();
+}
+let source = () => readMainConfigRaw()["quiet"];
+/** Current state, read fresh from config; an unreadable config reads as not quiet. */
+function readQuiet(now = Date.now()) {
+	try {
+		return parseQuiet(source(), now);
+	} catch {
+		return { on: false };
+	}
+}
+/** CLI side: persist quiet on (optionally until `until` epoch ms) or off. */
+function writeQuiet(on, until) {
+	const raw = readMainConfigRaw();
+	if (on) raw["quiet"] = until === void 0 ? { on: true } : {
+		on: true,
+		until: new Date(until).toISOString()
+	};
+	else delete raw["quiet"];
+	writeMainConfigRaw(raw);
+}
+/** One-line description for `pai daemon quiet status` and `pai daemon status`. */
+function describeQuiet(s) {
+	if (!s.on) return "off";
+	return s.until === void 0 ? "on (until `pai daemon quiet off`)" : `on until ${new Date(s.until).toLocaleString()}`;
+}
+const deferred = /* @__PURE__ */ new Set();
+const runners = /* @__PURE__ */ new Map();
+/** What to run (once) for a kind when quiet ends. */
+function registerQuietRunner(kind, run) {
+	runners.set(kind, run);
+}
+/** True (and the kind is remembered for later) while quiet; false = run now. */
+function deferIfQuiet(kind, now = Date.now()) {
+	if (!readQuiet(now).on) return false;
+	if (!deferred.has(kind)) process.stderr.write(`[pai-daemon] quiet: deferring ${kind}.\n`);
+	deferred.add(kind);
+	return true;
+}
+/**
+* When quiet is over, run each deferred kind once, in a fixed order. Returns
+* the kinds run. A runner that throws is logged and not retried.
+*/
+async function flushDeferredIfEnded(now = Date.now()) {
+	if (readQuiet(now).on || deferred.size === 0) return [];
+	const kinds = [
+		"registry-scan",
+		"index",
+		"maintenance",
+		"embed",
+		"triple-extraction",
+		"obsidian-sync"
+	].filter((k) => deferred.has(k));
+	deferred.clear();
+	for (const kind of kinds) try {
+		await runners.get(kind)?.();
+	} catch (e) {
+		process.stderr.write(`[pai-daemon] quiet: deferred ${kind} failed: ${e instanceof Error ? e.message : String(e)}\n`);
+	}
+	process.stderr.write(`[pai-daemon] quiet ended: ran deferred ${kinds.join(", ")}.\n`);
+	return kinds;
+}
+/** Daemon side: poll for the end of quiet. */
+function startQuietWatcher() {
+	const timer = setInterval(() => void flushDeferredIfEnded(), QUIET_POLL_MS);
+	if (timer.unref) timer.unref();
+}
+
+//#endregion
+//#region src/audit/session-usage.ts
+/**
+* session-usage.ts — parse the usage numbers out of a Claude Code session
+* (or subagent, or pai-worker event-mirror) JSONL transcript.
+*
+* All three log shapes share the same assistant-message envelope
+* ({ type: "assistant", message: { id, model, usage } }), so one parser
+* covers `pai audit tokens session` and the per-log readings feeding
+* `pai audit tokens spawn`.
+*
+* Streaming writes one JSONL line per content block of the same logical
+* turn, repeating message.id and usage each time — summing every line would
+* multiply usage by the block count. Keeping only the first line seen per
+* message.id is what the reference script (and this parser) count instead.
+*/
+const USAGE_KEYS = [
+	"cache_read_input_tokens",
+	"cache_creation_input_tokens",
+	"input_tokens",
+	"output_tokens"
+];
+function emptyTotals() {
+	return {
+		cache_read_input_tokens: 0,
+		cache_creation_input_tokens: 0,
+		input_tokens: 0,
+		output_tokens: 0
+	};
+}
+/**
+* `type:"system"` `subtype:"compact_boundary"` lines mark a compaction.
+* turnIndex is the count of assistant turns already folded when it fired,
+* so it lines up with the turn numbering the text/JSON report prints.
+*/
+function isCompactBoundary(line) {
+	return line.type === "system" && line.subtype === "compact_boundary";
+}
+function parseCompactionEvent(line, turnIndex) {
+	const meta = line.compactMetadata;
+	if (!meta || typeof meta.preTokens !== "number") return null;
+	return {
+		trigger: meta.trigger ?? "unknown",
+		preTokens: meta.preTokens,
+		turnIndex
+	};
+}
+/**
+* `type:"system"` `subtype:"model_refusal_fallback"` lines mark an
+* automatic model switch fired by an API safety refusal (e.g. "cyber"
+* category), not a user or config choice — worth flagging separately since
+* it can rebuild the whole prompt cache mid-session.
+*/
+function isModelFallback(line) {
+	return line.type === "system" && line.subtype === "model_refusal_fallback";
+}
+function parseFallbackEvent(line, turnIndex) {
+	return {
+		turnIndex,
+		from: line.originalModel ?? "unknown",
+		to: line.fallbackModel ?? "unknown",
+		category: line.apiRefusalCategory ?? "unknown",
+		scope: line.scope ?? "unknown"
+	};
+}
+/**
+* Fold one already-parsed JSONL line into a report being accumulated.
+* Exported separately so both the streaming file reader below and tests
+* (which build fixtures as arrays of objects, not files) share one path.
+* Returns the turn's context value when a new turn was counted, else null
+* (non-assistant line, no usage, or a duplicate message.id already seen).
+*/
+function foldAssistantLine(report, seenIds, line, threshold) {
+	if (line.type !== "assistant") return null;
+	const message = line.message;
+	const usage = message?.usage;
+	if (!usage) return null;
+	const id = message?.id ?? line.uuid;
+	if (id) {
+		if (seenIds.has(id)) return null;
+		seenIds.add(id);
+	}
+	report.turns++;
+	for (const key of USAGE_KEYS) {
+		const v = usage[key];
+		if (typeof v === "number") report.totals[key] += v;
+	}
+	const context = (Number(usage.cache_read_input_tokens) || 0) + (Number(usage.cache_creation_input_tokens) || 0) + (Number(usage.input_tokens) || 0);
+	if (report.firstTurnContext === null) {
+		report.firstTurnContext = context;
+		report.firstTurnAt = line.timestamp ?? null;
+	}
+	const atMs = line.timestamp ? Date.parse(line.timestamp) : NaN;
+	if (!Number.isNaN(atMs)) {
+		if (report.lastTurnAtMs !== null && atMs - report.lastTurnAtMs > 3600 * 1e3) report.idleGapsOver60min++;
+		report.lastTurnAtMs = atMs;
+	}
+	report.lastTurnContext = context;
+	report.maxContext = report.maxContext === null ? context : Math.max(report.maxContext, context);
+	if (context > threshold) report.turnsAboveThreshold++;
+	if ((Number(usage.cache_creation_input_tokens) || 0) > 2e4) report.cacheRebuildTurns++;
+	const model = message?.model ?? "unknown";
+	report.models[model] = (report.models[model] ?? 0) + 1;
+	if (report.lastModel !== null && report.lastModel !== model) report.modelSwitches.push({
+		turnIndex: report.turns,
+		from: report.lastModel,
+		to: model,
+		cacheRead: Number(usage.cache_read_input_tokens) || 0,
+		cacheCreation: Number(usage.cache_creation_input_tokens) || 0
+	});
+	report.lastModel = model;
+	const split = usage.cache_creation;
+	if (split) {
+		report.cacheCreationSplit.ephemeral5m += Number(split.ephemeral_5m_input_tokens) || 0;
+		report.cacheCreationSplit.ephemeral1h += Number(split.ephemeral_1h_input_tokens) || 0;
+	}
+	return context;
+}
+/**
+* True for a real human-authored `type:"user"` prompt line: content is a
+* plain string, or a content array with no `tool_result` block. Claude Code
+* encodes tool results as `type:"user"` messages whose content array is
+* entirely (or partly) tool_result blocks — those must not count as prompts.
+*/
+function isRealUserPrompt(line) {
+	if (line.type !== "user") return false;
+	if (line.isMeta) return false;
+	if (line.origin?.kind && line.origin.kind !== "human") return false;
+	const content = line.message?.content;
+	if (typeof content === "string") return true;
+	if (Array.isArray(content)) return !content.some((block) => block?.type === "tool_result");
+	return false;
+}
+/** Plain text of a real user prompt: the string content, or its first text block. */
+function extractUserPromptText(line) {
+	const content = line.message?.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.find((b) => b?.type === "text")?.text ?? "";
+	return "";
+}
+/**
+* Parse a session/subagent/worker-event JSONL file into a usage report.
+* `keepaliveWord`, when given, counts real user prompts whose text exactly
+* matches it (trimmed) — the sessions.cacheKeepalive beat prompt — into
+* `keepaliveBeats`; omitted, `keepaliveBeats` stays null.
+*/
+async function parseSessionUsage(path, threshold = 2e5, keepaliveWord) {
+	const report = {
+		path,
+		sizeBytes: existsSync(path) ? readFileSync(path).byteLength : 0,
+		turns: 0,
+		totals: emptyTotals(),
+		models: {},
+		firstTurnContext: null,
+		lastTurnContext: null,
+		cacheCreationSplit: {
+			ephemeral5m: 0,
+			ephemeral1h: 0
+		},
+		avgContext: null,
+		maxContext: null,
+		turnsAboveThreshold: 0,
+		cacheRebuildTurns: 0,
+		userPrompts: 0,
+		promptExposure: 0,
+		compactions: [],
+		firstTurnAt: null,
+		lastModel: null,
+		modelSwitches: [],
+		fallbacks: [],
+		lastTurnAtMs: null,
+		idleGapsOver60min: 0,
+		keepaliveBeats: keepaliveWord ? 0 : null
+	};
+	const seenIds = /* @__PURE__ */ new Set();
+	let contextSum = 0;
+	const rl = createInterface({
+		input: createReadStream(path, "utf8"),
+		crlfDelay: Infinity
+	});
+	for await (const raw of rl) {
+		if (!raw.trim()) continue;
+		let obj;
+		try {
+			obj = JSON.parse(raw);
+		} catch {
+			continue;
+		}
+		if (obj.type === "user") {
+			if (isRealUserPrompt(obj)) {
+				report.userPrompts++;
+				if (keepaliveWord && extractUserPromptText(obj).trim() === keepaliveWord) report.keepaliveBeats = (report.keepaliveBeats ?? 0) + 1;
+			}
+			continue;
+		}
+		if (isCompactBoundary(obj)) {
+			const event = parseCompactionEvent(obj, report.turns);
+			if (event) report.compactions.push(event);
+			continue;
+		}
+		if (isModelFallback(obj)) {
+			report.fallbacks.push(parseFallbackEvent(obj, report.turns));
+			continue;
+		}
+		const context = foldAssistantLine(report, seenIds, obj, threshold);
+		if (context !== null) {
+			contextSum += context;
+			report.promptExposure += report.userPrompts;
+		}
+	}
+	report.avgContext = report.turns > 0 ? Math.round(contextSum / report.turns) : null;
+	return report;
+}
+function totalUsageTokens(totals) {
+	return totals.cache_read_input_tokens + totals.cache_creation_input_tokens + totals.input_tokens + totals.output_tokens;
+}
+
+//#endregion
+//#region src/daemon/session-keepalive.ts
+/**
+* session-keepalive.ts — idle-triggered prompt-cache keepalive beat for live
+* interactive Claude Code sessions (`sessions.cacheKeepalive`, see config.ts
+* and docs/cache-keepalive.md, "Interactive sessions").
+*
+* One beat = one trivial prompt typed into a session through AIBroker's
+* send_to_session (src/cli/lib/aibroker-client.ts), sent with `noReply: true`
+* so the target sees only the bare word typed into its input line and
+* nothing is queued into its mailbox as a peer message demanding a reply.
+* A cache READ refreshes the provider's ephemeral prompt-cache TTL at
+* roughly 0.1x the cost of the 2x rewrite a cold cache forces on the next
+* real prompt.
+*
+* Distinct from workers/keepalive.ts, which beats a *worker provider's*
+* cache on a fixed timer regardless of activity: this only beats a session
+* that has actually been idle long enough to be at risk, and only inside a
+* configured working-hours window, so it never fires while the user is
+* present at the keyboard or overnight when nobody will read the reply
+* before the cache would have expired anyway.
+*/
+function sessionKeepaliveStatePath() {
+	return paiHomePath("session-keepalive.json");
+}
+function emptyEntry() {
+	return {
+		beats: 0,
+		lastRealPromptKey: null,
+		lastBeatAt: null
+	};
+}
+function loadSessionKeepaliveState(path = sessionKeepaliveStatePath()) {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return {};
+	}
+}
+function saveSessionKeepaliveState(state, path = sessionKeepaliveStatePath()) {
+	writeJsonAtomic(path, state, {
+		backup: false,
+		label: path
+	});
+}
+/** Parse "HH:MM-HH:MM" into minutes-since-midnight. Throws on a malformed
+*  spec — an explicit config error beats a window that is silently always
+*  on or always off. */
+function parseActiveHours(spec) {
+	const m = spec.match(/^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/);
+	if (!m) throw new Error(`sessions.cacheKeepalive.activeHours: invalid "${spec}" (want "HH:MM-HH:MM")`);
+	return {
+		startMin: Number(m[1]) * 60 + Number(m[2]),
+		endMin: Number(m[3]) * 60 + Number(m[4])
+	};
+}
+/**
+* Whether `now` (local time) sits inside the window. A window that wraps
+* midnight (e.g. "22:00-06:00") is honoured by inverting the test instead of
+* requiring startMin < endMin.
+*/
+function isWithinActiveHours(now, spec) {
+	const { startMin, endMin } = parseActiveHours(spec);
+	const nowMin = now.getHours() * 60 + now.getMinutes();
+	if (startMin <= endMin) return nowMin >= startMin && nowMin < endMin;
+	return nowMin >= startMin || nowMin < endMin;
+}
+/**
+* Full path to a live session's transcript under ~/.claude/projects, or null
+* when none is found — the case for a session too new to have written a file
+* yet. A worker running in a worktree DOES write a transcript here (Claude
+* Code encodes its worktree cwd as the project dir name), so workers are not
+* excluded "for free" — see isWorkerSession.
+*/
+function findSessionTranscript(sessionId, projectsDir = join(homedir(), ".claude", "projects")) {
+	let projectDirs;
+	try {
+		projectDirs = readdirSync(projectsDir);
+	} catch {
+		return null;
+	}
+	for (const projectDir of projectDirs) {
+		const candidate = join(projectsDir, projectDir, `${sessionId}.jsonl`);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+/**
+* AIBroker's `fetchLiveSessions()` identifies a session by its iTerm2 pane id
+* (e.g. an AIBroker/iTerm UUID), not the Claude session id `<uuid>.jsonl`
+* transcripts are named after — the two are unrelated identifiers. The
+* status line bridges them on every refresh via `claude-session-map.json`
+* (see `recordSessionMapEntry` in ../workers/scope.ts): this picks, among the
+* map entries whose `term` pane UUID matches, the most recently written one.
+* Returns null when the pane has no (fresh enough) mapped Claude session.
+*/
+function resolveClaudeSessionIdFromMap(paneId, logDir) {
+	const path = sessionMapPath(logDir);
+	if (!paneId || !existsSync(path)) return null;
+	let map;
+	try {
+		map = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	let best = null;
+	for (const entry of Object.values(map)) {
+		if (!entry.term || itermUuid(entry.term) !== paneId) continue;
+		if (!best || entry.ts > best.ts) best = entry;
+	}
+	return best?.session ?? null;
+}
+/** Claude Code's project-dir encoding of a cwd: every "/" becomes "-". */
+function encodeProjectDirName(cwd) {
+	return cwd.replace(/\//g, "-");
+}
+/**
+* Is this live "claude"-kind session actually a worker pane rather than an
+* interactive one? `claude -p` workers running in a worktree write their
+* transcript under ~/.claude/projects too (encoded cwd = the worktree dir),
+* so a missing transcript is NOT how workers get excluded — this predicate
+* is. Either signal is enough:
+*   (a) the transcript's project-dir name is the encoded form of a path
+*       under <logDir>/worktrees (every worker worktree lives there), or
+*   (b) the broker's session name/paiName names a path under the workers
+*       log dir or one of its worktrees (best-effort: AIBroker does not
+*       guarantee this, but honors it when present).
+*/
+function isWorkerSession(meta, transcriptPath, logDir) {
+	const worktreesPrefix = encodeProjectDirName(worktreesDir(logDir));
+	if (transcriptPath) {
+		if ((transcriptPath.split("/").slice(0, -1).pop() ?? "").startsWith(worktreesPrefix)) return true;
+	}
+	const rawPrefix = worktreesDir(logDir);
+	for (const field of [meta.name, meta.paiName]) if (field && (field.includes(rawPrefix) || field.includes(logDir))) return true;
+	return false;
+}
+function isMidTurn(line) {
+	if (!line) return false;
+	if (line.type === "user" && isRealUserPrompt(line)) return true;
+	if (line.type === "assistant") {
+		const stopReason = line.message?.stop_reason;
+		if (stopReason === void 0 || stopReason === null) return true;
+		return stopReason !== "end_turn" && stopReason !== "stop_sequence";
+	}
+	return false;
+}
+function readTranscriptSnapshot(path) {
+	let lines;
+	try {
+		lines = readFileSync(path, "utf8").split("\n");
+	} catch {
+		return {
+			context: null,
+			midTurn: false,
+			lastRealPrompt: null
+		};
+	}
+	let lastLine = null;
+	let context = null;
+	let lastRealPrompt = null;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const raw = lines[i].trim();
+		if (!raw) continue;
+		let obj;
+		try {
+			obj = JSON.parse(raw);
+		} catch {
+			continue;
+		}
+		if (lastLine === null) lastLine = obj;
+		if (context === null && obj.type === "assistant" && obj.message?.usage) {
+			const usage = obj.message.usage;
+			context = (Number(usage.cache_read_input_tokens) || 0) + (Number(usage.cache_creation_input_tokens) || 0) + (Number(usage.input_tokens) || 0);
+		}
+		if (lastRealPrompt === null && isRealUserPrompt(obj)) lastRealPrompt = {
+			key: obj.uuid ?? obj.timestamp ?? String(i),
+			text: extractUserPromptText(obj).trim()
+		};
+		if (context !== null && lastRealPrompt !== null) break;
+	}
+	return {
+		context,
+		midTurn: isMidTurn(lastLine),
+		lastRealPrompt
+	};
+}
+/** Ledger event tag; `pai daemon keepalive` and any log-tailer key off this. */
+const SESSION_KEEPALIVE_EVENT = "SESSION-KEEPALIVE";
+function sessionKeepaliveLedgerPath() {
+	const { workers } = readWorkersSection();
+	return join(workersLogDir(workers), "ledger.log");
+}
+/** The counts/last lines `pai daemon keepalive` prints, scoped to this event. */
+function sessionKeepaliveLedgerSummary(path = sessionKeepaliveLedgerPath(), lastN = 10) {
+	if (!existsSync(path)) return {
+		sent: 0,
+		skipped: 0,
+		lastLines: []
+	};
+	const lines = readFileSync(path, "utf8").split("\n").filter((l) => l.includes(SESSION_KEEPALIVE_EVENT));
+	const sent = lines.filter((l) => / result=sent(\s|$)/.test(l)).length;
+	return {
+		sent,
+		skipped: lines.length - sent,
+		lastLines: lines.slice(-lastN)
+	};
+}
+function defaultDeps() {
+	const { workers } = readWorkersSection();
+	const logDir = workersLogDir(workers);
+	return {
+		now: () => /* @__PURE__ */ new Date(),
+		fetchLiveSessions,
+		resolveClaudeSessionId: (paneId) => resolveClaudeSessionIdFromMap(paneId, logDir),
+		findTranscript: (id) => findSessionTranscript(id),
+		mtimeMs: (p) => {
+			try {
+				return statSync(p).mtimeMs;
+			} catch {
+				return null;
+			}
+		},
+		readSnapshot: readTranscriptSnapshot,
+		sendBeat: (id, text) => sendToSession(id, text, void 0, { noReply: true }),
+		loadState: () => loadSessionKeepaliveState(),
+		saveState: (s) => saveSessionKeepaliveState(s),
+		ledger: (kv) => appendLedger(sessionKeepaliveLedgerPath(), SESSION_KEEPALIVE_EVENT, kv)
+	};
+}
+/**
+* One tick over every live interactive session: beat the ones that qualify,
+* skip (with a reason) the ones that don't. Returns one result per live
+* "claude"-kind session for tests to assert against; writes the ledger line
+* and (when any counter changed) the state file as side effects.
+*/
+async function runSessionKeepaliveTick(config, overrides = {}) {
+	if (!config.enabled) return [];
+	const d = {
+		...defaultDeps(),
+		...overrides
+	};
+	const sessions = await d.fetchLiveSessions();
+	const state = d.loadState();
+	const now = d.now();
+	const { workers } = readWorkersSection();
+	const logDir = workersLogDir(workers);
+	const results = [];
+	let anyChanged = false;
+	for (const s of sessions) {
+		if (s.kind !== "claude") continue;
+		const paneId = s.sessionId;
+		const claudeId = d.resolveClaudeSessionId(paneId);
+		if (!claudeId) {
+			d.ledger({
+				session: null,
+				pane: paneId,
+				result: "skipped:unmapped"
+			});
+			results.push({
+				sessionId: paneId,
+				result: "skipped:unmapped"
+			});
+			continue;
+		}
+		const sessionId = claudeId;
+		const entry = { ...state[sessionId] ?? emptyEntry() };
+		let changed = false;
+		const transcript = d.findTranscript(sessionId);
+		if (isWorkerSession(s, transcript, logDir)) {
+			d.ledger({
+				session: sessionId,
+				pane: paneId,
+				result: "skipped:worker"
+			});
+			results.push({
+				sessionId,
+				result: "skipped:worker"
+			});
+			continue;
+		}
+		if (!transcript) {
+			d.ledger({
+				session: sessionId,
+				pane: paneId,
+				result: "skipped:no-transcript"
+			});
+			results.push({
+				sessionId,
+				result: "skipped:no-transcript"
+			});
+			continue;
+		}
+		const snapshot = d.readSnapshot(transcript);
+		if (snapshot.lastRealPrompt && snapshot.lastRealPrompt.key !== entry.lastRealPromptKey) {
+			entry.lastRealPromptKey = snapshot.lastRealPrompt.key;
+			if (snapshot.lastRealPrompt.text !== config.prompt) entry.beats = 0;
+			changed = true;
+		}
+		const mtime = d.mtimeMs(transcript);
+		const idleMin = mtime === null ? null : (now.getTime() - mtime) / 6e4;
+		const skip = mtime === null || idleMin === null ? "no-mtime" : idleMin < config.idleMinutes ? `idle:${idleMin.toFixed(1)}min` : !isWithinActiveHours(now, config.activeHours) ? "hours" : snapshot.context === null || snapshot.context < config.minContextTokens ? "context" : snapshot.midTurn ? "mid-turn" : entry.beats >= config.maxBeats ? "max-beats" : null;
+		const ledgerBase = {
+			session: sessionId,
+			pane: paneId,
+			idle_min: idleMin === null ? null : idleMin.toFixed(1),
+			context: snapshot.context
+		};
+		if (skip) {
+			d.ledger({
+				...ledgerBase,
+				beat: `${entry.beats}/${config.maxBeats}`,
+				result: `skipped:${skip}`
+			});
+			results.push({
+				sessionId,
+				result: `skipped:${skip}`
+			});
+		} else if ((await d.sendBeat(paneId, config.prompt)).ok) {
+			entry.beats += 1;
+			entry.lastBeatAt = now.toISOString();
+			changed = true;
+			d.ledger({
+				...ledgerBase,
+				beat: `${entry.beats}/${config.maxBeats}`,
+				result: "sent"
+			});
+			results.push({
+				sessionId,
+				result: "sent"
+			});
+		} else {
+			d.ledger({
+				...ledgerBase,
+				beat: `${entry.beats}/${config.maxBeats}`,
+				result: "skipped:send-failed"
+			});
+			results.push({
+				sessionId,
+				result: "skipped:send-failed"
+			});
+		}
+		if (changed) {
+			state[sessionId] = entry;
+			anyChanged = true;
+		}
+	}
+	if (anyChanged) d.saveState(state);
+	return results;
+}
+
+//#endregion
+//#region src/memory/wakeup.ts
+/**
+* Wake-up context system — progressive context loading inspired by mempalace.
+*
+* Layers:
+*   L0 Identity     (~100 tokens)   — user identity from ~/.pai/identity.txt. Always loaded.
+*   L1 Essential Story (~500-800t)  — top session notes for the project, key lines extracted.
+*   L2 On-Demand                    — triggered by topic queries (handled by memory_search).
+*   L3 Deep Search                  — unlimited federated memory search (memory_search tool).
+*/
+/** Maximum tokens for the L1 essential story block. Approx 4 chars/token.
+* Measured 2026-09-20: 800 tokens was mostly stale bullets. Reduced to 300.
+*/
+const L1_TOKEN_BUDGET = 300;
+L1_TOKEN_BUDGET * 4;
+/** Maximum session notes to scan when building L1. Reduced from 10 to 3 (2026-09-20). */
+const L1_MAX_NOTES = 3;
+/** Sections to extract from session notes (in priority order). */
+const EXTRACT_SECTIONS = [
+	"Work Done",
+	"Key Decisions",
+	"Next Steps",
+	"Checkpoint"
+];
+/** Identity file location. */
+const IDENTITY_FILE = () => join(homedir(), ".pai", "identity.txt");
+/**
+* Load L0 identity. Prefers the PAI_HOME location (identity.txt migrated by
+* `pai config migrate`), falling back to the legacy ~/.pai/identity.txt so a
+* not-yet-migrated file keeps working. Returns "" if neither exists. Never
+* throws.
+*/
+function loadL0Identity(opts = {}) {
+	const newPath = opts.newPath ?? paiHomePath("identity.txt");
+	const legacyPath = opts.legacyPath ?? IDENTITY_FILE();
+	const path = existsSync(newPath) ? newPath : legacyPath;
+	if (!existsSync(path)) return "";
+	try {
+		return readFileSync(path, "utf-8").trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Move ~/.pai/identity.txt into PAI_HOME, following the same copy /
+* verify-byte-identical / rename-aside semantics as every other per-user
+* file (see migratePaiFile). `from`/`to` are overridable for tests.
+*/
+function migrateIdentityFile(opts = {}) {
+	return migratePaiFile(opts.to ?? paiHomePath("identity.txt"), [opts.from ?? IDENTITY_FILE()], { dryRun: opts.dryRun });
+}
+/**
+* Find the Notes directory for a project given its root_path from the registry.
+* Checks local Notes/ first, then central ~/.claude/projects/... path.
+*/
+function findNotesDirForProject(rootPath) {
+	const localCandidates = [
+		join(rootPath, "Notes"),
+		join(rootPath, "notes"),
+		join(rootPath, ".claude", "Notes")
+	];
+	for (const p of localCandidates) if (existsSync(p)) return p;
+	const encoded = rootPath.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+	const centralNotes = join(homedir(), ".claude", "projects", encoded, "Notes");
+	if (existsSync(centralNotes)) return centralNotes;
+	return null;
+}
+/**
+* Recursively find all .md session note files in a Notes directory.
+* Handles both flat layout (Notes/*.md) and month-subdirectory layout
+* (Notes/YYYY/MM/*.md). Returns files sorted newest-first by filename
+* (note numbers are monotonically increasing, so lexicographic = newest-last,
+* so we reverse).
+*/
+function findSessionNotes(notesDir) {
+	const result = [];
+	const scanDir = (dir) => {
+		if (!existsSync(dir)) return;
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true }).map((e) => ({
+				name: e.name,
+				isDir: e.isDirectory()
+			}));
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDir) scanDir(fullPath);
+			else if (entry.name.match(/^\d{3,4}[\s_-].*\.md$/)) result.push(fullPath);
+		}
+	};
+	scanDir(notesDir);
+	const dateOf = (p) => basename(p).match(/(\d{4}-\d{2}-\d{2})/)?.[1] ?? "";
+	const numberOf = (p) => parseInt(basename(p).match(/^(\d+)/)?.[1] ?? "0", 10);
+	const mtimeOf = (p) => {
+		try {
+			return statSync(p).mtimeMs;
+		} catch {
+			return 0;
+		}
+	};
+	result.sort((a, b) => {
+		const dateA = dateOf(a);
+		const dateB = dateOf(b);
+		if (dateA !== dateB) {
+			if (!dateA) return 1;
+			if (!dateB) return -1;
+			return dateB.localeCompare(dateA);
+		}
+		const byNumber = numberOf(b) - numberOf(a);
+		if (byNumber !== 0) return byNumber;
+		return mtimeOf(b) - mtimeOf(a);
+	});
+	return result;
+}
+/**
+* Extract the most important lines from a session note.
+* Prioritises: Work Done items, Key Decisions, Next Steps, Checkpoint headings.
+* Returns a condensed string under maxChars.
+*/
+function normalizeLine(line) {
+	return line.replace(/^(- \[[ x]\] |- |\* |\d+\.\s)/, "").trim().replace(/\s+/g, " ");
+}
+function extractKeyLines(content, maxChars, seen = /* @__PURE__ */ new Set(), seenLabels = /* @__PURE__ */ new Set()) {
+	const lines = content.split("\n");
+	const selected = [];
+	let inTargetSection = false;
+	let currentSection = "";
+	let charCount = 0;
+	let pendingLabel = null;
+	for (const line of lines) {
+		const h2Match = line.match(/^## (.+)$/);
+		const h3Match = line.match(/^### (.+)$/);
+		if (h2Match) {
+			currentSection = h2Match[1];
+			inTargetSection = EXTRACT_SECTIONS.some((s) => currentSection.toLowerCase().includes(s.toLowerCase()));
+			pendingLabel = null;
+			continue;
+		}
+		if (h3Match) {
+			if (inTargetSection) pendingLabel = h3Match[1];
+			continue;
+		}
+		if (!inTargetSection) continue;
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("<!--") || trimmed === "---") continue;
+		if (trimmed.startsWith("- ") || trimmed.startsWith("* ") || trimmed.match(/^\d+\./) || trimmed.startsWith("**")) {
+			const normalized = normalizeLine(trimmed);
+			if (seen.has(normalized)) continue;
+			let labelText = "";
+			let labelKey = "";
+			if (pendingLabel !== null) {
+				labelKey = pendingLabel.toLowerCase().trim();
+				if (!seenLabels.has(labelKey)) labelText = `[${pendingLabel}]`;
+			}
+			if (charCount + labelText.length + trimmed.length + 2 > maxChars) break;
+			if (labelText) {
+				selected.push(labelText);
+				seenLabels.add(labelKey);
+				charCount += labelText.length + 1;
+			}
+			pendingLabel = null;
+			seen.add(normalized);
+			selected.push(trimmed);
+			charCount += trimmed.length + 1;
+		}
+	}
+	return selected.join("\n");
+}
+/**
+* Build the L1 essential story block.
+*
+* Reads the most recent session notes for the project and extracts the key
+* lines (Work Done, Key Decisions, Next Steps) within the token budget.
+*
+* @param rootPath   The project root path (from the registry).
+* @param tokenBudget  Max tokens to consume. Default 800 (~3200 chars).
+* @returns Formatted L1 block, or empty string if no notes found.
+*/
+function buildL1EssentialStory(rootPath, tokenBudget = L1_TOKEN_BUDGET) {
+	const charBudget = tokenBudget * 4;
+	const notesDir = findNotesDirForProject(rootPath);
+	if (!notesDir) return "";
+	const noteFiles = findSessionNotes(notesDir).slice(0, L1_MAX_NOTES);
+	if (noteFiles.length === 0) return "";
+	const sections = [];
+	const seen = /* @__PURE__ */ new Set();
+	const seenLabels = /* @__PURE__ */ new Set();
+	let remaining = charBudget;
+	for (const noteFile of noteFiles) {
+		if (remaining <= 50) break;
+		let content;
+		try {
+			content = readFileSync(noteFile, "utf-8");
+		} catch {
+			continue;
+		}
+		const name = basename(noteFile);
+		const titleMatch = name.match(/^\d+ - (\d{4}-\d{2}-\d{2}) - (.+)\.md$/);
+		const dateLabel = titleMatch ? titleMatch[1] : "";
+		const titleLabel = titleMatch ? titleMatch[2] : name.replace(/^\d+ - /, "").replace(/\.md$/, "");
+		const perNoteChars = Math.min(remaining, Math.floor(charBudget / noteFiles.length) + 200);
+		const extracted = extractKeyLines(content, perNoteChars, seen, seenLabels);
+		const hasContentLine = extracted.split("\n").some((l) => !/^\[.*\]$/.test(l));
+		if (!extracted || !hasContentLine) continue;
+		const noteBlock = `[${dateLabel} - ${titleLabel}]\n${extracted}`;
+		sections.push(noteBlock);
+		remaining -= noteBlock.length + 1;
+	}
+	if (sections.length === 0) return "";
+	return sections.join("\n\n");
+}
+/**
+* Build the combined wake-up context block (L0 + L1).
+*
+* Returns a formatted string suitable for injection as a system-reminder,
+* or an empty string if both layers are empty.
+*
+* @param rootPath   Project root path for L1 note lookup. Optional.
+* @param tokenBudget  L1 token budget. Default 800.
+* @param opts.skipStory  Skip the L1 essential story. Set when a handover
+*   checkpoint was already injected — the story re-summarises the same note
+*   the handover came from, at lower quality.
+*/
+function buildWakeupContext(rootPath, tokenBudget = L1_TOKEN_BUDGET, opts = {}) {
+	const identity = loadL0Identity();
+	const essentialStory = rootPath && !opts.skipStory ? buildL1EssentialStory(rootPath, tokenBudget) : "";
+	if (!identity && !essentialStory) return "";
+	const parts = [];
+	if (identity) parts.push(`## L0 Identity\n\n${identity}`);
+	if (essentialStory) parts.push(`## L1 Essential Story\n\n${essentialStory}`);
+	return parts.join("\n\n");
+}
+
+//#endregion
+//#region src/obsidian/enabled.ts
+/** Switch for the Obsidian integration that WRITES into the PAI-generated vault (sync, master notes, symlinks): `obsidian: { enabled: true }` in config.yaml (default off). Reading/indexing `vaultPath` is separate: `vaultIndex.enabled`. */
+const OBSIDIAN_DISABLED_MESSAGE = "Obsidian sync is disabled. Enable it with: pai config set obsidian.enabled true";
+/** Read fresh from config; an unreadable config reads as disabled. */
+function obsidianEnabled() {
+	try {
+		const o = readMainConfigRaw()["obsidian"];
+		return !!o && typeof o === "object" && o.enabled === true;
+	} catch {
+		return false;
+	}
+}
+/** Vault indexing (read-only, `vaultPath`) is on unless `vaultIndex: { enabled: false }`; independent of `obsidian.enabled`. */
+function vaultIndexEnabled() {
+	try {
+		const v = readMainConfigRaw()["vaultIndex"];
+		return !(v && typeof v === "object" && v.enabled === false);
+	} catch {
+		return true;
+	}
+}
+
+//#endregion
+//#region src/hooks/ts/lib/pai-paths.ts
+/**
+* PAI Path Resolution - Single Source of Truth
+*
+* This module provides consistent path resolution across all PAI hooks.
+*
+* Two different things live here, and they must not be confused:
+*
+* - ADAPTER_DIR (~/.claude by default) is the Claude Code harness adapter —
+*   fixed, hardcoded paths the harness itself loads from (Hooks/, skills/,
+*   agents/, commands/, settings.json, statusline-command.sh,
+*   tab-color-command.sh). It is harness-specific: a future harness would
+*   need its own adapter directory with its own conventions.
+* - PAI_HOME (~/.pai by default — see ../../../config/pai-home.ts) is
+*   where PAI's own state lives: everything hooks WRITE (History/,
+*   agent-sessions.json, session-routing.json, ...) resolves there, with a
+*   fallback to the pre-2026-09-19 ADAPTER_DIR location and a one-time
+*   stderr notice, exactly like every other PAI_HOME file.
+*
+* ALSO loads .env file from ADAPTER_DIR so all hooks get environment
+* variables without relying on Claude Code's settings.json injection.
+*
+* Usage in hooks:
+*   import { ADAPTER_DIR, HOOKS_DIR, SKILLS_DIR, historyDir } from './lib/pai-paths';
+*/
+/**
+* Load .env file and inject into process.env
+* Must run BEFORE ADAPTER_DIR resolution so .env can set ADAPTER_DIR/PAI_DIR if needed
+*/
+function loadEnvFile() {
+	const possiblePaths = [resolve$1(process.env.ADAPTER_DIR || process.env.PAI_DIR || "", ".env"), resolve$1(homedir$1(), ".claude", ".env")];
+	for (const envPath of possiblePaths) if (existsSync$1(envPath)) try {
+		const content = readFileSync$1(envPath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex > 0) {
+				const key = trimmed.substring(0, eqIndex).trim();
+				let value = trimmed.substring(eqIndex + 1).trim();
+				if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+				value = value.replace(/\$HOME/g, homedir$1());
+				value = value.replace(/^~(?=\/|$)/, homedir$1());
+				if (process.env[key] === void 0) process.env[key] = value;
+			}
+		}
+		break;
+	} catch {}
+}
+loadEnvFile();
+function defaultAdapterDir() {
+	return resolve$1(homedir$1(), ".claude");
+}
+/**
+* Never print when stdout/stderr is a data channel, not a human: hook
+* bundles and worker-status-line.mjs set PAI_QUIET_NOTICES=1 via their
+* esbuild banner (scripts/build-hooks.mjs), and a `pai worker run
+* --output-format json` invocation is detected directly off argv since its
+* env can't be set before this module's static imports resolve.
+*/
+function suppressDeprecationNotices() {
+	if (process.env.PAI_QUIET_NOTICES === "1") return true;
+	const idx = process.argv.indexOf("--output-format");
+	return idx !== -1 && process.argv[idx + 1] === "json";
+}
+/**
+* At most once per process — a `globalThis` flag rather than a module-level
+* `let` because hooks and the CLI can end up with more than one instance of
+* this module loaded into the same process (separate bundles), each with its
+* own module scope; only a property on the shared global survives that.
+*/
+function warnPaiDirDeprecatedOnce(message) {
+	const g = globalThis;
+	if (g.__paiDirNoticePrinted || suppressDeprecationNotices()) return;
+	g.__paiDirNoticePrinted = true;
+	process.stderr.write(`pai: ${message}\n`);
+}
+/**
+* Smart ADAPTER_DIR detection with fallback
+* Priority:
+* 1. ADAPTER_DIR environment variable (if set) — warns once if PAI_DIR is
+*    ALSO set and resolves to a different path (naming both).
+* 2. PAI_DIR environment variable (deprecated alias, one release) — warns
+*    once only when it differs from the default adapter root; PAI_DIR set to
+*    the same value as the default is the operator's current, correct
+*    setting and stays silent.
+* 3. ~/.claude (standard location)
+*/
+function resolveAdapterDir() {
+	if (process.env.ADAPTER_DIR) {
+		const adapterDir = resolve$1(process.env.ADAPTER_DIR);
+		if (process.env.PAI_DIR) {
+			const paiDir = resolve$1(process.env.PAI_DIR);
+			if (paiDir !== adapterDir) warnPaiDirDeprecatedOnce(`ADAPTER_DIR (${adapterDir}) and PAI_DIR (${paiDir}) are both set and differ — ADAPTER_DIR wins. PAI_DIR still works for one release.`);
+		}
+		return adapterDir;
+	}
+	if (process.env.PAI_DIR) {
+		const paiDir = resolve$1(process.env.PAI_DIR);
+		if (paiDir !== defaultAdapterDir()) warnPaiDirDeprecatedOnce("PAI_DIR is deprecated — use ADAPTER_DIR for the harness adapter root (~/.claude). PAI_DIR still works for one release.");
+		return paiDir;
+	}
+	return defaultAdapterDir();
+}
+/** The Claude Code harness adapter root — NOT PAI's state home. See module doc above. */
+const ADAPTER_DIR = resolveAdapterDir();
+/**
+* Adapter directories — fixed paths the Claude Code harness itself loads
+* from. These stay under ADAPTER_DIR; they are not PAI state.
+*/
+const HOOKS_DIR = join$1(ADAPTER_DIR, "Hooks");
+const SKILLS_DIR = join$1(ADAPTER_DIR, "skills");
+const AGENTS_DIR = join$1(ADAPTER_DIR, "agents");
+const COMMANDS_DIR = join$1(ADAPTER_DIR, "commands");
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/paths.ts
+/**
+* Path utilities — encoding, Notes/Sessions directory discovery and creation.
+*/
+const PROJECTS_DIR = join$1(ADAPTER_DIR, "projects");
+/**
+* Encode a path the same way Claude Code does:
+* - Replace / with -
+* - Replace . with -
+* - Replace space with -
+*/
+function encodePath(path) {
+	return path.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+}
+/** Get the project directory for a given working directory. */
+function getProjectDir(cwd) {
+	return join$1(PROJECTS_DIR, encodePath(cwd));
+}
+/** Get the Notes directory for a project (central location). */
+function getNotesDir(cwd) {
+	return join$1(getProjectDir(cwd), "Notes");
+}
+/**
+* Find Notes directory — checks local first, falls back to central.
+* Does NOT create the directory.
+*/
+function findNotesDir(cwd) {
+	if (basename$1(cwd).toLowerCase() === "notes" && existsSync$1(cwd)) return {
+		path: cwd,
+		isLocal: true
+	};
+	const localPaths = [
+		join$1(cwd, "Notes"),
+		join$1(cwd, "notes"),
+		join$1(cwd, ".claude", "Notes")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return {
+		path,
+		isLocal: true
+	};
+	return {
+		path: getNotesDir(cwd),
+		isLocal: false
+	};
+}
+/** Get the sessions/ directory from a project directory path. */
+function getSessionsDirFromProjectDir(projectDir) {
+	return join$1(projectDir, "sessions");
+}
+/** Ensure the sessions/ directory exists (from project dir path). */
+function ensureSessionsDirFromProjectDir(projectDir) {
+	const sessionsDir = getSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(sessionsDir)) {
+		mkdirSync$1(sessionsDir, { recursive: true });
+		console.error(`Created sessions directory: ${sessionsDir}`);
+	}
+	return sessionsDir;
+}
+/**
+* Publish every project-root .jsonl into sessions/ as well, WITHOUT removing it.
+*
+* This used to renameSync, and that is how PAI destroyed its users' sessions.
+*
+* `claude --resume <uuid>` finds a transcript only at the project root. Move it
+* into sessions/ and the session becomes permanently unresumable — measured
+* 2026-08-04: `claude --resume b3462801` (867 KB of real work, sessions/ only)
+* answers "No conversation found with session ID", while a top-level id is found
+* fine. Nothing warned; the id still looked valid everywhere PAI displayed it.
+*
+* The damage was not occasional. This ran from a UserPromptSubmit hook excluding
+* only the CURRENT session, so every prompt anyone typed unresumed every other
+* session in the project. One PAI project measured 1 transcript at top level
+* against 52 underneath. Among the casualties was 046bb712 — the exact id PAI's
+* own handover tells the user to resume.
+*
+* A hardlink satisfies both sides, which is why this is a two-line fix rather
+* than a redesign: the archive genuinely has consumers that read sessions/
+* (session-summary-worker, registry/moved, session/autosave), and `--resume`
+* needs the root path. One inode, two names, no copy, no window where the file
+* is missing from either place.
+*
+* Never unlink the source. Tidying up another tool's store was the whole
+* mistake; a stale duplicate is free, a lost session is not. Every caller of
+* `transcriptFiles()` was checked before choosing this — they all test emptiness
+* (`.length > 0`), never count, so the duplicate cannot skew a project's stats.
+*
+* `excludeFile` keeps a hook from archiving the transcript it is itself watching
+* being written. It is not a "finished sessions only" guard and must not be read
+* as one: it excludes exactly one file, the caller's own, so with two sessions
+* live in one project each still archives the other mid-turn. A consumer that
+* needs "finished only" has to enforce that itself — this function cannot know
+* what is live.
+*
+* Returns the number of files newly archived.
+*/
+function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
+	const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
+	if (!existsSync$1(projectDir)) return 0;
+	const files = readdirSync$1(projectDir);
+	let archivedCount = 0;
+	for (const file of files) {
+		if (!file.endsWith(".jsonl") || file === excludeFile) continue;
+		const sourcePath = join$1(projectDir, file);
+		const destPath = join$1(sessionsDir, file);
+		if (existsSync$1(destPath)) continue;
+		try {
+			linkSync$1(sourcePath, destPath);
+			if (!silent) console.error(`Archived ${file} → sessions/ (still resumable)`);
+			archivedCount++;
+		} catch (error) {
+			try {
+				copyFileSync$1(sourcePath, destPath);
+				if (!silent) console.error(`Copied ${file} → sessions/ (hardlink unavailable)`);
+				archivedCount++;
+			} catch {
+				if (!silent) console.error(`Could not archive ${file}: ${error}`);
+			}
+		}
+	}
+	return archivedCount;
+}
+/** Find TODO.md — check local first, fallback to central. */
+function findTodoPath(cwd) {
+	const localPaths = [
+		join$1(cwd, "TODO.md"),
+		join$1(cwd, "notes", "TODO.md"),
+		join$1(cwd, "Notes", "TODO.md"),
+		join$1(cwd, ".claude", "TODO.md")
+	];
+	for (const path of localPaths) if (existsSync$1(path)) return path;
+	return join$1(getNotesDir(cwd), "TODO.md");
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/session-notes.ts
+/**
+* Session note creation, editing, checkpointing, renaming, and finalization.
+*/
+/** Get or create the YYYY/MM subdirectory for the current month inside notesDir. */
+function getMonthDir(notesDir) {
+	const now = /* @__PURE__ */ new Date();
+	const monthDir = join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0"));
+	if (!existsSync$1(monthDir)) mkdirSync$1(monthDir, { recursive: true });
+	return monthDir;
+}
+/**
+* Get the next note number (4-digit format: 0001, 0002, etc.).
+* Numbers are scoped per YYYY/MM directory.
+*/
+function getNextNoteNumber(notesDir) {
+	const files = readdirSync$1(getMonthDir(notesDir)).filter((f) => f.match(/^\d{3,4}[\s_-]/)).sort();
+	if (files.length === 0) return "0001";
+	let maxNumber = 0;
+	for (const file of files) {
+		const digitMatch = file.match(/^(\d+)/);
+		if (digitMatch) {
+			const num = parseInt(digitMatch[1], 10);
+			if (num > maxNumber) maxNumber = num;
+		}
+	}
+	return String(maxNumber + 1).padStart(4, "0");
+}
+/**
+* Get the current (latest) note file path, or null if none exists.
+* Searches current month → previous month → flat notesDir (legacy).
+*/
+function getCurrentNotePath(notesDir) {
+	if (!existsSync$1(notesDir)) return null;
+	const findLatestIn = (dir) => {
+		if (!existsSync$1(dir)) return null;
+		const files = readdirSync$1(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+			return parseInt(a.match(/^(\d+)/)?.[1] || "0", 10) - parseInt(b.match(/^(\d+)/)?.[1] || "0", 10);
+		});
+		if (files.length === 0) return null;
+		return join$1(dir, files[files.length - 1]);
+	};
+	const now = /* @__PURE__ */ new Date();
+	const found = findLatestIn(join$1(notesDir, String(now.getFullYear()), String(now.getMonth() + 1).padStart(2, "0")));
+	if (found) return found;
+	const prevDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+	const prevFound = findLatestIn(join$1(notesDir, String(prevDate.getFullYear()), String(prevDate.getMonth() + 1).padStart(2, "0")));
+	if (prevFound) return prevFound;
+	return findLatestIn(notesDir);
+}
+/**
+* Create a new session note.
+* Format: "NNNN - YYYY-MM-DD - New Session.md" filed into YYYY/MM subdirectory.
+* Claude MUST rename at session end with a meaningful description.
+*/
+function createSessionNote(notesDir, description) {
+	const noteNumber = getNextNoteNumber(notesDir);
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const monthDir = getMonthDir(notesDir);
+	const filename = `${noteNumber} - ${date} - New Session.md`;
+	const filepath = join$1(monthDir, filename);
+	writeFileSync$1(filepath, `# Session ${noteNumber}: ${description}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+<!-- PAI will add completed work here during session -->
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`);
+	console.error(`Created session note: ${filename}`);
+	return filepath;
+}
+/** Append a checkpoint to the current session note. */
+function appendCheckpoint(notePath, checkpoint) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found, recreating: ${notePath}`);
+		try {
+			const parentDir = join$1(notePath, "..");
+			if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+			const noteFilename = basename$1(notePath);
+			const numberMatch = noteFilename.match(/^(\d+)/);
+			writeFileSync$1(notePath, `# Session ${numberMatch ? numberMatch[1] : "0000"}: Recovered\n\n**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}\n**Status:** In Progress\n\n---\n\n## Work Done\n\n<!-- PAI will add completed work here during session -->\n\n---\n\n## Next Steps\n\n<!-- To be filled at session end -->\n\n---\n\n**Tags:** #Session\n`);
+			console.error(`Recreated session note: ${noteFilename}`);
+		} catch (err) {
+			console.error(`Failed to recreate note: ${err}`);
+			return;
+		}
+	}
+	const content = readFileSync$1(notePath, "utf-8");
+	const checkpointText = `\n### Checkpoint ${(/* @__PURE__ */ new Date()).toISOString()}\n\n${checkpoint}\n`;
+	const nextStepsIndex = content.indexOf("## Next Steps");
+	writeFileSync$1(notePath, nextStepsIndex !== -1 ? content.substring(0, nextStepsIndex) + checkpointText + content.substring(nextStepsIndex) : content + checkpointText);
+	console.error(`Checkpoint added to: ${basename$1(notePath)}`);
+}
+/** Add work items to the "Work Done" section of a session note. */
+function addWorkToSessionNote(notePath, workItems, sectionTitle) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	let workText = "";
+	if (sectionTitle) workText += `\n### ${sectionTitle}\n\n`;
+	for (const item of workItems) {
+		const checkbox = item.completed !== false ? "[x]" : "[ ]";
+		workText += `- ${checkbox} **${item.title}**\n`;
+		if (item.details && item.details.length > 0) for (const detail of item.details) workText += `  - ${detail}\n`;
+	}
+	const workDoneMatch = content.match(/## Work Done\n\n(<!-- .*? -->)?/);
+	if (workDoneMatch) {
+		const insertPoint = content.indexOf(workDoneMatch[0]) + workDoneMatch[0].length;
+		content = content.substring(0, insertPoint) + workText + content.substring(insertPoint);
+	} else {
+		const nextStepsIndex = content.indexOf("## Next Steps");
+		if (nextStepsIndex !== -1) content = content.substring(0, nextStepsIndex) + workText + "\n" + content.substring(nextStepsIndex);
+	}
+	writeFileSync$1(notePath, content);
+	console.error(`Added ${workItems.length} work item(s) to: ${basename$1(notePath)}`);
+}
+/** Sanitize a string for use in a filename. */
+function sanitizeForFilename(str) {
+	return str.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+/**
+* Return true if the candidate string should be rejected as a meaningful name.
+* Rejects file paths, shebangs, timestamps, system noise, XML tags, hashes, etc.
+*/
+function isMeaninglessCandidate(text) {
+	const t = text.trim();
+	if (!t) return true;
+	if (t.length < 5) return true;
+	if (t.startsWith("/") || t.startsWith("~")) return true;
+	if (t.startsWith("#!")) return true;
+	if (t.includes("[object Object]")) return true;
+	if (/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]+)?$/.test(t)) return true;
+	if (/^\d{1,2}:\d{2}(:\d{2})?(\s*(AM|PM))?$/i.test(t)) return true;
+	if (/^<[a-z-]+[\s/>]/i.test(t)) return true;
+	if (/^[0-9a-f]{10,}$/i.test(t)) return true;
+	if (/^Exit code \d+/i.test(t)) return true;
+	if (/^Error:/i.test(t)) return true;
+	if (/^This session is being continued/i.test(t)) return true;
+	if (/^\(Bash completed/i.test(t)) return true;
+	if (/^Task Notification$/i.test(t)) return true;
+	if (/^New Session$/i.test(t)) return true;
+	if (/^Recovered Session$/i.test(t)) return true;
+	if (/^Continued Session$/i.test(t)) return true;
+	if (/^Untitled Session$/i.test(t)) return true;
+	if (/^Context Compression$/i.test(t)) return true;
+	if (/^[A-Fa-f0-9]{8,}\s+Output$/i.test(t)) return true;
+	return false;
+}
+/**
+* Extract a meaningful name from session note content and summary.
+* Looks at Work Done section headers, bold text, and summary.
+*/
+function extractMeaningfulName(noteContent, summary) {
+	const workDoneMatch = noteContent.match(/## Work Done\n\n([\s\S]*?)(?=\n---|\n## Next)/);
+	if (workDoneMatch) {
+		const workDoneSection = workDoneMatch[1];
+		const subheadings = workDoneSection.match(/### ([^\n]+)/g);
+		if (subheadings && subheadings.length > 0) {
+			const firstHeading = subheadings[0].replace("### ", "").trim();
+			if (!isMeaninglessCandidate(firstHeading) && firstHeading.length > 5 && firstHeading.length < 60) return sanitizeForFilename(firstHeading);
+		}
+		const boldMatches = workDoneSection.match(/\*\*([^*]+)\*\*/g);
+		if (boldMatches && boldMatches.length > 0) {
+			const firstBold = boldMatches[0].replace(/\*\*/g, "").trim();
+			if (!isMeaninglessCandidate(firstBold) && firstBold.length > 3 && firstBold.length < 50) return sanitizeForFilename(firstBold);
+		}
+		const numberedItems = workDoneSection.match(/^\d+\.\s+\*\*([^*]+)\*\*/m);
+		if (numberedItems && !isMeaninglessCandidate(numberedItems[1])) return sanitizeForFilename(numberedItems[1]);
+	}
+	if (summary && summary.length > 5 && summary !== "Session completed." && !isMeaninglessCandidate(summary)) {
+		const cleanSummary = summary.replace(/[^\w\s-]/g, " ").trim().split(/\s+/).slice(0, 5).join(" ");
+		if (cleanSummary.length > 3 && !isMeaninglessCandidate(cleanSummary)) return sanitizeForFilename(cleanSummary);
+	}
+	return "";
+}
+/**
+* Rename a session note with a meaningful name.
+* Always uses "NNNN - YYYY-MM-DD - Description.md" format.
+* Returns the new path, or original path if rename fails.
+*/
+function renameSessionNote(notePath, meaningfulName) {
+	if (!meaningfulName || !existsSync$1(notePath)) return notePath;
+	const dir = join$1(notePath, "..");
+	const oldFilename = basename$1(notePath);
+	const correctMatch = oldFilename.match(/^(\d{3,4}) - (\d{4}-\d{2}-\d{2}) - .*\.md$/);
+	const legacyMatch = oldFilename.match(/^(\d{3,4})_(\d{4}-\d{2}-\d{2})_.*\.md$/);
+	const match = correctMatch || legacyMatch;
+	if (!match) return notePath;
+	const [, noteNumber, date] = match;
+	const titleCaseName = meaningfulName.replace(/[\/\\:\0]/g, " ").split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
+	const newFilename = `${noteNumber.padStart(4, "0")} - ${date} - ${titleCaseName}.md`;
+	const newPath = join$1(dir, newFilename);
+	if (newFilename === oldFilename) return notePath;
+	try {
+		renameSync$1(notePath, newPath);
+		console.error(`Renamed note: ${oldFilename} → ${newFilename}`);
+		return newPath;
+	} catch (error) {
+		console.error(`Could not rename note: ${error}`);
+		return notePath;
+	}
+}
+/**
+* Finalize session note — mark as complete, add summary, rename with meaningful name.
+* IDEMPOTENT: subsequent calls are no-ops if already finalized.
+* Returns the final path (may be renamed).
+*/
+function finalizeSessionNote(notePath, summary) {
+	if (!existsSync$1(notePath)) {
+		console.error(`Note file not found: ${notePath}`);
+		return notePath;
+	}
+	let content = readFileSync$1(notePath, "utf-8");
+	if (content.includes("**Status:** Completed")) {
+		console.error(`Note already finalized: ${basename$1(notePath)}`);
+		return notePath;
+	}
+	content = content.replace("**Status:** In Progress", "**Status:** Completed");
+	if (!content.includes("**Completed:**")) {
+		const completionTime = (/* @__PURE__ */ new Date()).toISOString();
+		content = content.replace("---\n\n## Work Done", `**Completed:** ${completionTime}\n\n---\n\n## Work Done`);
+	}
+	const nextStepsMatch = content.match(/## Next Steps\n\n(<!-- .*? -->)/);
+	if (nextStepsMatch) content = content.replace(nextStepsMatch[0], `## Next Steps\n\n${summary || "Session completed."}`);
+	writeFileSync$1(notePath, content);
+	console.error(`Session note finalized: ${basename$1(notePath)}`);
+	const meaningfulName = extractMeaningfulName(content, summary);
+	if (meaningfulName) return renameSessionNote(notePath, meaningfulName);
+	return notePath;
+}
+
+//#endregion
+//#region src/hooks/ts/lib/project-utils/todo.ts
+/**
+* TODO.md management — creation, task updates, checkpoints, and Continue section.
+*/
+/**
+* Ensure TODO.md exists. Creates it with default structure if missing.
+* Returns the path to the TODO.md file.
+*/
+function ensureTodoMd(cwd) {
+	const todoPath = findTodoPath(cwd);
+	if (!existsSync$1(todoPath)) {
+		const parentDir = join$1(todoPath, "..");
+		if (!existsSync$1(parentDir)) mkdirSync$1(parentDir, { recursive: true });
+		writeFileSync$1(todoPath, `# TODO
+
+## Current Session
+
+- [ ] (Tasks will be tracked here)
+
+## Backlog
+
+- [ ] (Future tasks)
+
+---
+
+*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`);
+		console.error(`Created TODO.md: ${todoPath}`);
+	}
+	return todoPath;
+}
+/**
+* The Claude Code session UUID, read off the transcript path.
+*
+* Claude Code names a transcript `<session-uuid>.jsonl`, so the hooks that
+* receive a transcript path are holding the session's identity without knowing
+* it. Both session-end writers had one available and neither used it.
+*
+* Shape-checked rather than trusted: only a UUID is returned, so a renamed,
+* archived or otherwise unexpected filename yields undefined and the caller
+* falls back to the session line rather than writing a `session-id` that
+* identifies nothing. A wrong id is worse than none — it would make two
+* different sessions compare equal.
+*/
+function sessionIdFromTranscript(transcriptPath) {
+	if (!transcriptPath) return void 0;
+	const base = basename$1(transcriptPath).replace(/\.jsonl$/, "");
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(base) ? base : void 0;
+}
+/**
+* Update the ## Continue section at the top of TODO.md.
+*
+* This is the unattended writer: the pre-compact hook and the daemon's
+* work-queue worker both come through here. It used to build its own block and
+* strip the existing section with `/## Continue\n[\s\S]*?\n---\n+/` — a
+* non-greedy match to the first `---`, which cuts a rich checkpoint in half at
+* the first horizontal rule inside its body and leaves the remainder orphaned
+* in the document.
+*
+* More importantly it was the writer that actually destroyed model-authored
+* checkpoints: `pai pause` wrote one, then this ran seconds later on session
+* end and replaced it with `Working directory: … Check the latest session note
+* for details.`
+*
+* It now delegates to the shared checkpoint module in "auto" mode, which means
+* it inherits the preservation rules rather than reimplementing them. Guarding
+* here rather than at each of the three call sites is deliberate: any future
+* caller inherits the behaviour without knowing it exists.
+*/
+function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
+	ensureTodoMd(cwd);
+	const result = applyContinue({
+		rootPath: cwd,
+		authored: "auto",
+		sessionLine: noteFilename.replace(/\.md$/, ""),
+		sessionId,
+		cwd,
+		body: state?.trim() || void 0
+	});
+	if (result.action === "preserved") {
+		console.error("TODO.md ## Continue left intact — authored checkpoint for this session");
+		return;
+	}
+	if (result.path === null) {
+		console.error(result.action === "written" ? "handover written to forge issue" : "forge handover left intact — nothing to say");
+		return;
+	}
+	if (result.action === "failed") {
+		console.error(`TODO.md ## Continue update failed: ${result.error}`);
+		return;
+	}
+	try {
+		const todoPath = result.path;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let content = readFileSync$1(todoPath, "utf-8");
+		content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
+		content = content.trimEnd() + `\n\n---\n\n*Last updated: ${now}*\n`;
+		writeFileSync$1(todoPath, content);
+	} catch {}
+	console.error(result.carriedForward ? "TODO.md ## Continue section updated (previous content carried forward)" : "TODO.md ## Continue section updated");
+}
+
+//#endregion
+//#region src/daemon/templates/session-summary-prompt.ts
+/**
+* Build the prompt string to send to the summarizer model.
+*
+* Returns a single string suitable for piping to `claude --model <model> --print`.
+*/
+function buildSessionSummaryPrompt(params) {
+	const { userMessages, gitLog, cwd, date, filesModified, existingNote } = params;
+	const userSection = userMessages.length > 0 ? userMessages.map((m, i) => `[${i + 1}] ${m}`).join("\n\n") : "(No user messages extracted)";
+	const gitSection = gitLog.trim() || "(No git commits during this session)";
+	const filesSection = filesModified && filesModified.length > 0 ? filesModified.map((f) => `- ${f}`).join("\n") : "";
+	return `You are summarizing a coding session. Given the user messages and git commits below, write a session note.
+
+Project directory: ${cwd}
+Date: ${date}
+
+Focus on:
+- What problems were encountered and how they were solved
+- Key architectural decisions and their rationale
+- What was built (reference actual files and code patterns)
+- What was left unfinished or needs follow-up
+
+Do NOT include:
+- Mechanical metadata (token counts, checkpoint timestamps)
+- System messages or tool results verbatim
+- Generic descriptions — be specific about what happened
+- Markdown frontmatter or YAML headers
+${existingNote ? `\nAn existing session note is provided below. Merge the new information into it,
+preserving what was already written. Add new work items and update the summary.
+Do NOT duplicate existing content.
+
+EXISTING NOTE:
+${existingNote}
+` : ""}
+Format your response EXACTLY as follows (no extra text before or after):
+
+TOPIC: [A short topic label, max 60 characters, describing the WORK DONE — not quoting user messages. Format as "Topic1, Topic2, and Topic3" if multiple themes. Example: "Session Summary Worker, Topic Detection"]
+
+# Session: [Descriptive title summarizing what was ACCOMPLISHED, max 60 characters. Describe the work done, not the user's request. Bad: "Dark Mode Button Does Nothing". Good: "Dark Mode Toggle, Keyboard IPC, and Audio Fix"]
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+[Organize by theme, not chronologically. Group related work under descriptive bullet points.
+Use checkbox format: - [x] for completed items, - [ ] for incomplete items.
+Include specific file names, function names, and technical details.]
+
+## Key Decisions
+
+[List important choices made during the session with brief rationale.
+Skip this section entirely if no significant decisions were made.]
+
+## Known Issues
+
+[What was left unfinished, bugs discovered, or follow-up items needed.
+Skip this section entirely if nothing is pending.]
+
+---
+
+USER MESSAGES:
+${userSection}
+
+GIT COMMITS:
+${gitSection}
+${filesSection ? `\nFILES MODIFIED:\n${filesSection}` : ""}`;
+}
+
+//#endregion
+//#region src/daemon/templates/triple-extraction-prompt.ts
+/**
+* triple-extraction-prompt.ts — Prompt template for KG triple extraction.
+*
+* Used by the session-summary-worker to extract structured facts from
+* a completed session summary and store them in the temporal knowledge graph.
+*/
+function buildTripleExtractionPrompt(params) {
+	return `Extract structured entities and relations from this coding session.
+
+Output a single JSON object with two arrays: "entities" and "relations".
+
+Entity types: project | person | concept | tool | file | version | decision | technology | organization
+
+Rules:
+- Be SPECIFIC: entity names must be concrete (e.g., "FSRS", "Glidr", "the owner")
+- Use snake_case relation verb phrases (e.g., "uses_algorithm", "decided_to", "shipped_version")
+- Skip opinions, speculation, and "we should" statements
+- Skip entities obvious from project metadata unless they have a meaningful relation
+- Maximum 15 relations per session — pick the most important
+- Each entity should have a brief description (1 sentence, what it is in this context)
+- Each relation must reference entity names that appear in the entities array
+
+Example output:
+{
+  "entities": [
+    {"name": "Glidr", "type": "project", "description": "Flashcard app using FSRS spaced repetition"},
+    {"name": "FSRS", "type": "concept", "description": "Free Spaced Repetition Scheduler algorithm"},
+    {"name": "the owner", "type": "person", "description": "Developer of Glidr and Quassl"},
+    {"name": "Quassl", "type": "project", "description": "iOS app being rewritten in Flutter"},
+    {"name": "Flutter", "type": "technology", "description": "Cross-platform mobile framework"}
+  ],
+  "relations": [
+    {"source": "Glidr", "relation": "uses_algorithm", "target": "FSRS"},
+    {"source": "Glidr", "relation": "shipped_version", "target": "1.0.5"},
+    {"source": "the owner", "relation": "decided_to_rewrite", "target": "Quassl"},
+    {"source": "Quassl", "relation": "migrating_to", "target": "Flutter"}
+  ]
+}
+
+PROJECT: ${params.projectSlug}
+
+SESSION CONTENT:
+${params.sessionContent}
+
+GIT COMMITS:
+${params.gitLog}
+
+Output ONLY the JSON object with no surrounding prose, no code fences, no trailing commas, and no comments.
+
+JSON object (entities + relations):`;
+}
+
+//#endregion
+//#region src/workers/daemon-llm.ts
+/**
+* daemon-llm.ts — provider-routed LLM spawns for daemon-side background calls.
+*
+* Session summaries, context handovers and KG extraction used to spawn a bare
+* `claude --model <tier>` with the ambient environment: on a machine whose
+* only login is a worker provider that spawn either dies (no Anthropic
+* credentials) or bills Anthropic outside the provider abstraction. This
+* module routes those spawns through the same registry and env build the
+* worker runner uses (`buildRunEnv`), resolving the tier alias to the
+* provider's concrete model id. With no usable provider configured it falls
+* back to the historical behaviour: the tier alias itself, ambient env minus
+* the Anthropic API key.
+*/
+/** Timeout per tier (ms) — a class-appropriate budget, not a per-model one. */
+const LLM_TIMEOUT_MS = {
+	haiku: 6e4,
+	sonnet: 12e4,
+	opus: 3e5
+};
+/** Resolve a tier to the provider's concrete model id: the fast capability
+*  for the cheap tier, the default model for the middle and top tiers. */
+function tierModel(provider, tier) {
+	return resolveModelCapability(provider, tier === "haiku" ? "fast" : "default");
+}
+/**
+* Containment every daemon-side LLM spawn carries. These calls are
+* text-in/text-out: the prompt carries the context, the answer is the
+* product, and nothing about summarizing a session justifies a tool. An
+* unrestricted background summarizer was observed on 2026-09-18 (01:33-01:51)
+* rewriting the live config with a schema-shaped dump while the daemon ran;
+* with the tool grant empty and MCP strictly empty, that class of damage is
+* structurally impossible rather than merely unlikely.
+*/
+function containmentArgs(logDir) {
+	return [
+		"--strict-mcp-config",
+		"--mcp-config",
+		ensureNoMcpConfig(logDir),
+		"--allowedTools",
+		"",
+		"--tools",
+		""
+	];
+}
+/** The historical fallback: tier alias as the model id, ambient env with the
+*  Anthropic API key stripped (so the CLI uses its interactive login). */
+function legacyPlan(tier, config) {
+	const { ANTHROPIC_API_KEY: _drop, ...env } = process.env;
+	return {
+		model: tier,
+		args: [
+			"--model",
+			tier,
+			...containmentArgs(workersLogDir(config ?? defaultWorkersConfig())),
+			"-p",
+			"--no-session-persistence"
+		],
+		env,
+		timeoutMs: LLM_TIMEOUT_MS[tier],
+		provider: null
+	};
+}
+/**
+* Plan a daemon-side LLM spawn for a tier. Provider resolution failures (no
+* config, workers off, no usable provider) fall back to the tier-alias path;
+* a configured-but-broken provider (unreadable key file) throws, because
+* silently degrading to Anthropic billing is worse than a failed summary.
+*/
+async function planLlmSpawn(tier, configPath, probe = probeRouter) {
+	let provider = null;
+	let providerName = null;
+	let config = null;
+	try {
+		const { workers } = readWorkersSection(configPath);
+		config = workers;
+		if (workers.enabled) {
+			const target = resolveTarget(workers, workersLogDir(workers), { sessionEnv: {} });
+			provider = target.provider;
+			providerName = target.providerName;
+		}
+	} catch {
+		provider = null;
+		providerName = null;
+	}
+	if (!provider || !providerName || !config) return legacyPlan(tier, config);
+	const logDir = workersLogDir(config);
+	let proxyUrl;
+	if (provider.protocol === "openai") {
+		mkdirSync(logDir, { recursive: true });
+		proxyUrl = `${await ensureProxyRunning(DEFAULT_PROXY_PORT, logDir)}/${providerName}`;
+	}
+	const model = tierModel(provider, tier);
+	const viaRouter = proxyUrl ? void 0 : await loopbackRouterChoice(provider, providerName, void 0, probe);
+	return {
+		model,
+		args: [
+			"--model",
+			model,
+			...containmentArgs(logDir),
+			"-p",
+			"--no-session-persistence"
+		],
+		env: buildRunEnv(provider, true, proxyUrl, providerName, viaRouter),
+		timeoutMs: LLM_TIMEOUT_MS[tier],
+		provider: providerName
+	};
+}
+
+//#endregion
+//#region src/memory/kg-extraction.ts
+/**
+* kg-extraction.ts — Shared KG triple extraction logic.
+*
+* Extracted from session-summary-worker.ts so both the worker and the
+* CLI backfill (`pai kg backfill`) can use the same code path.
+*
+* Provides:
+*   - findClaudeBinary()       — locate the claude CLI
+*   - spawnClaude()            — generic prompt -> response runner (provider-routed)
+*   - extractAndStoreTriples() — run the extractor prompt and persist triples to Postgres
+*/
+/**
+* Find the `claude` CLI binary. Checks common installation locations first
+* (launchd PATH is minimal so bare "claude" often won't resolve).
+*/
+function findClaudeBinary$1() {
+	const candidates = [
+		join(homedir(), ".local", "bin", "claude"),
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude"
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return "claude";
+}
+/**
+* Spawn the claude CLI with a prompt on stdin and return stdout.
+*
+* Routed through the provider registry (planLlmSpawn): the tier resolves to
+* the configured provider's model id and the env carries its base URL and
+* token. With no provider configured it degrades to the historical behaviour
+* — the tier alias itself, ambient env minus ANTHROPIC_API_KEY.
+*/
+async function spawnClaude(prompt, tier = "sonnet") {
+	const claudeBin = findClaudeBinary$1();
+	if (!claudeBin) {
+		process.stderr.write("[kg-extraction] claude CLI not found.\n");
+		return null;
+	}
+	let plan;
+	try {
+		plan = await planLlmSpawn(tier);
+	} catch (e) {
+		process.stderr.write(`[kg-extraction] could not plan ${tier} spawn: ${e}\n`);
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const child = spawn(claudeBin, plan.args, {
+			env: plan.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			process.stderr.write(`[kg-extraction] ${plan.model} spawn error: ${err.message}\n`);
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (code !== 0) {
+				process.stderr.write(`[kg-extraction] ${plan.model} exited ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[kg-extraction] ${plan.model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, plan.timeoutMs);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Slice text down to the outermost JSON structure, dropping any surrounding
+* prose or code-fence artifacts the LLM added around the JSON object/array.
+* Returns the input unchanged if no opening brace/bracket is found.
+*/
+function extractJsonSpan(text) {
+	const firstBrace = text.indexOf("{");
+	const firstBracket = text.indexOf("[");
+	let start = -1;
+	let closeChar = "";
+	if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+		start = firstBrace;
+		closeChar = "}";
+	} else if (firstBracket !== -1) {
+		start = firstBracket;
+		closeChar = "]";
+	}
+	if (start === -1) return text;
+	const end = text.lastIndexOf(closeChar);
+	if (end === -1 || end <= start) return text;
+	return text.slice(start, end + 1);
+}
+/**
+* Extract structured KG triples from a session summary and store them in
+* Postgres. Idempotent: if a (subject, predicate) pair already has the same
+* object, no new row is added; if the object differs, the old triple is
+* invalidated (valid_to = NOW()) and a new one is inserted.
+*
+* Best-effort: per-triple errors are caught and logged but never thrown.
+* Returns a small stats object so callers can report progress.
+*/
+async function extractAndStoreTriples$1(backend, params) {
+	const stats = {
+		extracted: 0,
+		added: 0,
+		superseded: 0
+	};
+	const jsonOutput = await spawnClaude(buildTripleExtractionPrompt({
+		sessionContent: params.summaryText,
+		projectSlug: params.projectSlug,
+		gitLog: params.gitLog ?? ""
+	}), params.model ?? "sonnet");
+	if (!jsonOutput) return stats;
+	let cleaned = jsonOutput.replace(/^```json\s*/m, "").replace(/^```\s*/m, "").replace(/\s*```$/m, "").trim();
+	cleaned = extractJsonSpan(cleaned);
+	let triples;
+	try {
+		const parsed = JSON.parse(cleaned);
+		if (Array.isArray(parsed)) triples = parsed;
+		else if (parsed && typeof parsed === "object" && Array.isArray(parsed.relations)) {
+			const newFmt = parsed;
+			if (Array.isArray(newFmt.entities)) {
+				const tenantId = params.tenantId ?? "default";
+				for (const entity of newFmt.entities) {
+					if (!entity.name) continue;
+					try {
+						await backend.upsertKgEntity({
+							name: entity.name,
+							type: entity.type ?? "unknown",
+							description: entity.description,
+							tenantId
+						});
+					} catch (entityErr) {
+						process.stderr.write(`[kg-extraction] entity upsert error (${entity.name}): ${entityErr}\n`);
+					}
+				}
+			}
+			triples = newFmt.relations.map((r) => ({
+				subject: r.source,
+				predicate: r.relation,
+				object: r.target
+			}));
+		} else {
+			process.stderr.write(`[kg-extraction] Unexpected JSON shape — neither array nor {entities,relations}\n`);
+			return stats;
+		}
+	} catch (e) {
+		const collapse = (s) => s.replace(/\s+/g, " ").trim();
+		const head200 = collapse(jsonOutput.slice(0, 200));
+		const tail200 = collapse(jsonOutput.slice(-200));
+		process.stderr.write(`[kg-extraction] JSON parse failed: ${e}. head200="${head200}" tail200="${tail200}"\n`);
+		return stats;
+	}
+	if (!Array.isArray(triples)) return stats;
+	stats.extracted = triples.length;
+	for (const t of triples) {
+		if (!t.subject || !t.predicate || !t.object) continue;
+		try {
+			const existing = await backend.queryKgTriples({
+				subject: t.subject,
+				predicate: t.predicate,
+				project_id: params.projectId ?? void 0
+			});
+			if (existing.find((e) => e.object === t.object && !e.valid_to)) continue;
+			const supersedes = existing.find((e) => e.object !== t.object && !e.valid_to);
+			if (supersedes) {
+				await backend.invalidateKgTriple(supersedes.id);
+				stats.superseded++;
+			}
+			await backend.addKgTriple({
+				subject: t.subject,
+				predicate: t.predicate,
+				object: t.object,
+				project_id: params.projectId ?? void 0,
+				source_session: params.sessionId,
+				confidence: "EXTRACTED"
+			});
+			stats.added++;
+		} catch (tripleErr) {
+			process.stderr.write(`[kg-extraction] store error (${t.subject}): ${tripleErr}\n`);
+		}
+	}
+	return stats;
+}
+
+//#endregion
+//#region src/daemon/daemon/state.ts
+/** RegistryBackend-based access (projects, sessions, tags, aliases, links, compaction_log). */
+let registryBackend;
+let storageBackend;
+let daemonConfig;
+let startTime = Date.now();
+/** True while a project index pass is running. */
+let indexInProgress = false;
+let lastIndexTime = 0;
+let indexSchedulerTimer = null;
+/** True while an embedding pass is running. */
+let embedInProgress = false;
+let lastEmbedTime = 0;
+/** Outcome of the latest embed pass (budget hit, yielded, done), null before the first. */
+let lastEmbedPass = null;
+let embedSchedulerTimer = null;
+/** True while a vault index pass is running. */
+let vaultIndexInProgress = false;
+let lastVaultIndexTime = 0;
+/** Interval timer of the worker prompt-cache keepalive (null = not armed). */
+let cacheKeepaliveTimer = null;
+/** Mutable notification config — loaded from disk at startup, patchable at runtime. */
+let notificationConfig;
+/**
+* Set to true when a SIGTERM/SIGINT is received so that long-running loops
+* (embed, index) can detect the signal and exit their inner loops before the
+* pool/backend is closed.
+*/
+let shutdownRequested = false;
+function setRegistryBackend(b) {
+	registryBackend = b;
+}
+function setStorageBackend(b) {
+	storageBackend = b;
+}
+function setDaemonConfig(c) {
+	daemonConfig = c;
+}
+function setStartTime(t) {
+	startTime = t;
+}
+function setNotificationConfig(c) {
+	notificationConfig = c;
+}
+function setShutdownRequested(v) {
+	shutdownRequested = v;
+}
+function setIndexInProgress(v) {
+	indexInProgress = v;
+}
+function setLastIndexTime(v) {
+	lastIndexTime = v;
+}
+function setIndexSchedulerTimer(v) {
+	indexSchedulerTimer = v;
+}
+function setEmbedInProgress(v) {
+	embedInProgress = v;
+}
+function setLastEmbedPass(v) {
+	lastEmbedPass = v;
+}
+function setLastEmbedTime(v) {
+	lastEmbedTime = v;
+}
+function setEmbedSchedulerTimer(v) {
+	embedSchedulerTimer = v;
+}
+function setVaultIndexInProgress(v) {
+	vaultIndexInProgress = v;
+}
+function setLastVaultIndexTime(v) {
+	lastVaultIndexTime = v;
+}
+function setCacheKeepaliveTimer(v) {
+	cacheKeepaliveTimer = v;
+}
+/** Failing passes by name ("index" | "embed" | "vault"); absent = healthy. */
+const passFailures = /* @__PURE__ */ new Map();
+
+//#endregion
+//#region src/daemon/session-summary-worker.ts
+/**
+* session-summary-worker.ts — AI-powered session note generation
+*
+* Processes `session-summary` work items by:
+*   1. Finding the current session's JSONL transcript
+*   2. Extracting user messages and assistant context
+*   3. Gathering git commits from the session period
+*   4. Spawning Claude (sonnet for compaction, opus for session end) to generate a structured summary
+*   5. Comparing the new topic against the existing note's topic
+*   6. Creating a NEW note if the topic shifted, or updating the existing one
+*
+* Topic detection: the summarizer outputs a TOPIC: line as the first line of
+* its response. This is compared against the existing note's title using word
+* overlap. If overlap is below ~30%, a new note is created.
+*
+* Designed to run inside the daemon's work queue worker. All errors are
+* thrown (not swallowed) so the work queue retry logic handles them.
+*/
+/** Minimum interval between summaries for the same project (ms). */
+const SUMMARY_COOLDOWN_MS = 1800 * 1e3;
+/** Maximum JSONL content to feed to the summarizer (characters). */
+/** Max JSONL chars per model. Opus/Sonnet can handle much more than Haiku. */
+const MAX_JSONL_CHARS = {
+	haiku: 5e4,
+	sonnet: 2e5,
+	opus: 5e5
+};
+/** Maximum user messages to include in the prompt. */
+const MAX_USER_MESSAGES = 30;
+/** File tracking last summary timestamps per project — resolved under
+*  PAI_HOME, falling back to the pre-2026-09-19 ~/.config/pai location. */
+function oldCooldownFile() {
+	return join(homedir(), ".config", "pai", "summary-cooldowns.json");
+}
+function cooldownFilePath() {
+	return resolvePaiFile(paiHomePath("summary-cooldowns.json"), [oldCooldownFile()], "pai config migrate");
+}
+function migrateSummaryCooldowns(opts = {}) {
+	return migratePaiFile(paiHomePath("summary-cooldowns.json"), [oldCooldownFile()], opts);
+}
+/** Claude Code projects directory. */
+const CLAUDE_PROJECTS_DIR = () => join(homedir(), ".claude", "projects");
+function loadCooldowns() {
+	try {
+		const file = cooldownFilePath();
+		if (existsSync(file)) return JSON.parse(readFileSync(file, "utf-8"));
+	} catch {}
+	return {};
+}
+function saveCooldowns(cooldowns) {
+	try {
+		const file = paiHomePath("summary-cooldowns.json");
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(file, JSON.stringify(cooldowns, null, 2), "utf-8");
+	} catch {}
+}
+function isOnCooldown(cwd) {
+	const lastRun = loadCooldowns()[cwd];
+	if (!lastRun) return false;
+	return Date.now() - lastRun < SUMMARY_COOLDOWN_MS;
+}
+function markCooldown(cwd) {
+	const cooldowns = loadCooldowns();
+	cooldowns[cwd] = Date.now();
+	const cutoff = Date.now() - 1440 * 60 * 1e3;
+	for (const key of Object.keys(cooldowns)) if (cooldowns[key] < cutoff) delete cooldowns[key];
+	saveCooldowns(cooldowns);
+}
+/**
+* Encode a cwd path the same way Claude Code does for its project directories.
+* Replaces /, space, dot, and hyphen with -.
+*/
+function encodeProjectPath(cwd) {
+	return cwd.replace(/[\/\s.\-]/g, "-");
+}
+/**
+* Find the most recently modified JSONL file for the given project.
+*
+* Claude Code stores transcripts in:
+*   ~/.claude/projects/<encoded-path>/sessions/*.jsonl
+*   ~/.claude/projects/<encoded-path>/<uuid>.jsonl (legacy)
+*/
+function findLatestJsonl(cwd) {
+	const encoded = encodeProjectPath(cwd);
+	const projectDir = join(CLAUDE_PROJECTS_DIR(), encoded);
+	if (!existsSync(projectDir)) {
+		process.stderr.write(`[session-summary] No Claude project dir found: ${projectDir}\n`);
+		return null;
+	}
+	const candidates = [];
+	const sessionsDir = join(projectDir, "sessions");
+	if (existsSync(sessionsDir)) try {
+		for (const f of readdirSync(sessionsDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(sessionsDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	try {
+		for (const f of readdirSync(projectDir)) {
+			if (!f.endsWith(".jsonl")) continue;
+			const fullPath = join(projectDir, f);
+			try {
+				const st = statSync(fullPath);
+				candidates.push({
+					path: fullPath,
+					mtime: st.mtimeMs
+				});
+			} catch {}
+		}
+	} catch {}
+	if (candidates.length === 0) {
+		process.stderr.write(`[session-summary] No JSONL files found in ${projectDir}\n`);
+		return null;
+	}
+	candidates.sort((a, b) => b.mtime - a.mtime);
+	return candidates[0].path;
+}
+/**
+* Parse a JSONL transcript and extract relevant content.
+* Filters noise, truncates to model-appropriate size from the end of the file.
+*/
+function extractFromJsonl(jsonlPath, tier = "sonnet") {
+	const result = {
+		userMessages: [],
+		filesModified: [],
+		sessionStartTime: ""
+	};
+	let raw;
+	try {
+		raw = readFileSync(jsonlPath, "utf-8");
+	} catch (e) {
+		throw new Error(`Could not read JSONL at ${jsonlPath}: ${e}`);
+	}
+	const maxChars = MAX_JSONL_CHARS[tier] ?? 2e5;
+	if (raw.length > maxChars) {
+		const truncPoint = raw.indexOf("\n", raw.length - maxChars);
+		raw = truncPoint >= 0 ? raw.slice(truncPoint + 1) : raw.slice(-MAX_JSONL_CHARS);
+	}
+	const lines = raw.trim().split("\n");
+	const seenMessages = /* @__PURE__ */ new Set();
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry.timestamp && !result.sessionStartTime) result.sessionStartTime = String(entry.timestamp);
+		if (entry.type === "user") {
+			const msg = entry.message;
+			if (msg?.content) {
+				const text = contentToText(msg.content);
+				if (text && !isNoise(text) && !seenMessages.has(text)) {
+					seenMessages.add(text);
+					result.userMessages.push(text.slice(0, 500));
+				}
+			}
+		}
+		if (entry.type === "assistant") {
+			const msg = entry.message;
+			if (msg?.content && Array.isArray(msg.content)) {
+				for (const block of msg.content) if (block.type === "tool_use") {
+					const name = block.name;
+					const input = block.input;
+					if ((name === "Edit" || name === "Write") && input?.file_path) {
+						const fp = String(input.file_path);
+						if (!result.filesModified.includes(fp)) result.filesModified.push(fp);
+					}
+				}
+			}
+		}
+	}
+	if (result.userMessages.length > MAX_USER_MESSAGES) result.userMessages = result.userMessages.slice(-MAX_USER_MESSAGES);
+	return result;
+}
+/** Convert Claude content (string or content block array) to plain text. */
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		if (typeof c === "string") return c;
+		const block = c;
+		if (block?.text) return String(block.text);
+		if (block?.content) return String(block.content);
+		return "";
+	}).join(" ").trim();
+	return "";
+}
+/** Filter out noise entries that shouldn't be included in the summary. */
+function isNoise(text) {
+	if (!text || text.length < 3) return true;
+	if (text.includes("<task-notification>")) return true;
+	if (text.includes("[object Object]")) return true;
+	if (text.startsWith("<system-reminder>")) return true;
+	if (/^(yes|ok|sure|go|continue|weiter|thanks|thank you)\.?$/i.test(text.trim())) return true;
+	if (text.startsWith("Tool Result:") || text.startsWith("tool_result")) return true;
+	return false;
+}
+/**
+* Get git log for the session period.
+* Falls back gracefully if git is not available or the dir is not a repo.
+*/
+async function getGitContext(cwd, sinceTime) {
+	let since = "6 hours ago";
+	if (sinceTime) {
+		const asNum = Number(sinceTime);
+		if (!isNaN(asNum) && asNum > 1e9) since = (/* @__PURE__ */ new Date(asNum * 1e3)).toISOString();
+		else since = sinceTime;
+	}
+	try {
+		const { execFile: execFileCb } = await import("node:child_process");
+		const { promisify } = await import("node:util");
+		const { stdout } = await promisify(execFileCb)("git", [
+			"log",
+			"--format=%h %ai %s",
+			`--since=${since}`,
+			"--stat",
+			"--no-color"
+		], {
+			cwd,
+			timeout: 1e4,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Find the `claude` CLI binary.
+* Checks PATH first, then common installation locations.
+*/
+function findClaudeBinary() {
+	const candidates = [
+		join(homedir(), ".local", "bin", "claude"),
+		join(homedir(), ".claude", "local", "claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude"
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return candidate;
+	} catch {}
+	return "claude";
+}
+/**
+* Spawn a Claude model via the CLI to generate a session summary.
+* Pipes the prompt via stdin. Tier selection (resolved to the configured
+* provider's model id, falling back to the tier alias when no provider is
+* configured — see planLlmSpawn):
+*   - opus: session end (best quality for final summary, runs once)
+*   - sonnet: auto-compaction (good quality for incremental checkpoints, runs often)
+*   - haiku: fallback / budget mode
+* Returns the generated text, or null if spawning fails.
+*/
+async function spawnSummarizer(prompt, tier = "sonnet") {
+	const claudeBin = findClaudeBinary();
+	if (!claudeBin) {
+		process.stderr.write("[session-summary] Claude CLI not found in PATH or common locations.\n");
+		return null;
+	}
+	let plan;
+	try {
+		plan = await planLlmSpawn(tier);
+	} catch (e) {
+		process.stderr.write(`[session-summary] could not plan ${tier} spawn: ${e}\n`);
+		return null;
+	}
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolve) => {
+		let timer = null;
+		const child = spawn(claudeBin, plan.args, {
+			env: plan.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			process.stderr.write(`[session-summary] ${plan.model} spawn error: ${err.message}\n`);
+			resolve(null);
+		});
+		child.on("close", (code) => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (code !== 0) {
+				process.stderr.write(`[session-summary] ${plan.model} exited with code ${code}: ${stderr.slice(0, 300)}\n`);
+				resolve(null);
+			} else resolve(stdout.trim() || null);
+		});
+		timer = setTimeout(() => {
+			process.stderr.write(`[session-summary] ${plan.model} timed out — killing process.\n`);
+			child.kill("SIGTERM");
+			resolve(null);
+		}, plan.timeoutMs);
+		child.stdin.write(prompt);
+		child.stdin.end();
+	});
+}
+/**
+* Extract the TOPIC: line from the summarizer output.
+* Returns the topic string, or null if not found.
+*/
+function extractTopic(summaryText) {
+	const match = summaryText.match(/^TOPIC:\s*(.+)$/m);
+	if (!match) return null;
+	return match[1].trim();
+}
+/**
+* Extract the topic from an existing session note.
+* First checks for a <!-- TOPIC: ... --> comment (stored by previous summaries).
+* Falls back to the H1 "# Session NNNN: Title" line.
+*
+* The HTML comment is the reliable source because the H1 gets renamed by
+* renameSessionNote, which can add/change words and cause false topic shifts.
+*/
+function extractExistingNoteTitle(notePath) {
+	try {
+		const content = readFileSync(notePath, "utf-8");
+		const topicComment = content.match(/<!-- TOPIC:\s*(.+?)\s*-->/);
+		if (topicComment) return topicComment[1].trim();
+		const match = content.match(/^# Session \d+:\s*(.+)$/m);
+		if (match) return match[1].trim();
+	} catch {}
+	return null;
+}
+/**
+* Compute word overlap ratio between two topic strings.
+* Returns a value in [0, 1] — 1.0 means identical word sets.
+*
+* Uses lowercased, normalized words. Stop words and very short words
+* are excluded to avoid false positives on common terms.
+*/
+function computeTopicOverlap(topicA, topicB) {
+	const stopWords = new Set([
+		"a",
+		"an",
+		"the",
+		"and",
+		"or",
+		"but",
+		"in",
+		"on",
+		"at",
+		"to",
+		"for",
+		"of",
+		"with",
+		"by",
+		"from",
+		"is",
+		"was",
+		"are",
+		"were",
+		"be",
+		"been",
+		"being",
+		"have",
+		"has",
+		"had",
+		"do",
+		"does",
+		"did",
+		"will",
+		"would",
+		"could",
+		"should",
+		"may",
+		"might",
+		"can",
+		"shall",
+		"this",
+		"that",
+		"these",
+		"those",
+		"it",
+		"its",
+		"new",
+		"session",
+		"work",
+		"done"
+	]);
+	const normalize = (text) => {
+		const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+		return new Set(words);
+	};
+	const wordsA = normalize(topicA);
+	const wordsB = normalize(topicB);
+	if (wordsA.size === 0 || wordsB.size === 0) return 0;
+	let intersection = 0;
+	for (const w of wordsA) if (wordsB.has(w)) intersection++;
+	const union = new Set([...wordsA, ...wordsB]).size;
+	return union > 0 ? intersection / union : 0;
+}
+/** Threshold: below this overlap ratio, we consider topics different. */
+const TOPIC_OVERLAP_THRESHOLD = .15;
+/**
+* Write (or update) the session note with the AI-generated summary.
+*
+* Strategy:
+*   - Find the current month's latest note
+*   - If it's from today, compare topics:
+*     - Same topic (overlap >= 30%) → update existing note
+*     - Different topic (overlap < 30%) → create a NEW note
+*   - If it's from a different day, create a new note
+*/
+/**
+* Return true if the summarizer output has a meaningful body — i.e. content
+* beyond the TOPIC:/title/metadata/horizontal-rule scaffolding.
+*
+* A summary that is only headers (no Work Done items) must NOT create or update
+* a note: doing so births an empty-bodied scaffold that later rename/finalize
+* can strip to a footer-only stub. This is the born-stub failure mode.
+*/
+function summaryHasContent(summaryText) {
+	return summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*(Date|Status|Completed):\*\*.*$/gm, "").replace(/^#{1,6}\s.*$/gm, "").replace(/^---$/gm, "").replace(/<!--[\s\S]*?-->/g, "").trim().length > 0;
+}
+function writeSessionNote(cwd, summaryText, filesModified, sessionId) {
+	if (!summaryHasContent(summaryText)) {
+		process.stderr.write(`[session-summary] Summary has no meaningful body — skipping note write.\n`);
+		return null;
+	}
+	const notesInfo = findNotesDir(cwd);
+	let notePath = sessionId && findNoteBySessionId(notesInfo.path, sessionId) || getCurrentNotePath(notesInfo.path);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const newTopic = extractTopic(summaryText);
+	if (notePath) {
+		const noteFilename = basename(notePath);
+		const dateMatch = noteFilename.match(/(\d{4}-\d{2}-\d{2})/);
+		if ((dateMatch ? dateMatch[1] : "") === today) {
+			const existingTitle = extractExistingNoteTitle(notePath);
+			let topicShifted = false;
+			if (newTopic && existingTitle) {
+				const overlap = computeTopicOverlap(newTopic, existingTitle);
+				process.stderr.write(`[session-summary] Topic overlap: ${(overlap * 100).toFixed(1)}% (new="${newTopic}", existing="${existingTitle}")\n`);
+				if (overlap < TOPIC_OVERLAP_THRESHOLD) {
+					topicShifted = true;
+					process.stderr.write(`[session-summary] Topic shift detected (word overlap) — creating new note.\n`);
+				}
+			}
+			if (!topicShifted) {
+				const boundaryPath = join(notesInfo.path, "topic-boundary.json");
+				if (existsSync(boundaryPath)) try {
+					const boundary = JSON.parse(readFileSync(boundaryPath, "utf-8"));
+					if (boundary.timestamp) {
+						if (Date.now() - new Date(boundary.timestamp).getTime() < 1800 * 1e3) {
+							topicShifted = true;
+							process.stderr.write(`[session-summary] Topic shift detected (boundary marker) — ${boundary.previousProject} → ${boundary.suggestedProject}\n`);
+						}
+					}
+					unlinkSync(boundaryPath);
+				} catch {}
+			}
+			if (topicShifted) notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+			else {
+				updateNoteWithSummary(notePath, summaryText);
+				process.stderr.write(`[session-summary] Updated existing note: ${noteFilename}\n`);
+			}
+		} else notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+	} else notePath = createNoteFromSummary(notesInfo.path, summaryText, sessionId);
+	if (notePath) {
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		if (titleMatch) {
+			const title = titleMatch[1].trim();
+			if (title.length > 5 && title.length < 80) {
+				const newPath = renameSessionNote(notePath, title);
+				if (newPath !== notePath) notePath = newPath;
+			}
+		}
+	}
+	return notePath;
+}
+/**
+* Update an existing session note's Work Done section with AI-generated content.
+*/
+function updateNoteWithSummary(notePath, summaryText) {
+	if (!existsSync(notePath)) return;
+	let content = readFileSync(notePath, "utf-8");
+	const newTopic = extractTopic(summaryText);
+	if (newTopic) if (content.includes("<!-- TOPIC:")) content = content.replace(/<!-- TOPIC:.*?-->/, `<!-- TOPIC: ${newTopic} -->`);
+	else content = content.replace(/^(# Session .+)$/m, `$1\n<!-- TOPIC: ${newTopic} -->`);
+	const workDoneMatch = summaryText.match(/## Work Done\n\n([\s\S]*?)(?=\n## Key Decisions|\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (workDoneMatch) {
+		const aiWorkContent = workDoneMatch[1].trim();
+		const sectionHeader = `\n### AI Summary (${(/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0]})\n\n${aiWorkContent}\n`;
+		const nextStepsIdx = content.indexOf("## Next Steps");
+		const knownIssuesIdx = content.indexOf("## Known Issues");
+		const insertBefore = knownIssuesIdx !== -1 ? knownIssuesIdx : nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+		content = content.slice(0, insertBefore) + sectionHeader + "\n" + content.slice(insertBefore);
+	}
+	const decisionsMatch = summaryText.match(/## Key Decisions\n\n([\s\S]*?)(?=\n## Known Issues|\n\*\*Tags|\n$)/);
+	if (decisionsMatch) {
+		const decisions = decisionsMatch[1].trim();
+		if (decisions && !content.includes("## Key Decisions")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Key Decisions\n\n${decisions}\n\n` + content.slice(insertAt);
+		}
+	}
+	const issuesMatch = summaryText.match(/## Known Issues\n\n([\s\S]*?)(?=\n\*\*Tags|\n$)/);
+	if (issuesMatch) {
+		const issues = issuesMatch[1].trim();
+		if (issues && !content.includes("## Known Issues")) {
+			const nextStepsIdx = content.indexOf("## Next Steps");
+			const insertAt = nextStepsIdx !== -1 ? nextStepsIdx : content.length;
+			content = content.slice(0, insertAt) + `## Known Issues\n\n${issues}\n\n` + content.slice(insertAt);
+		}
+	}
+	writeFileSync(notePath, content, "utf-8");
+}
+/**
+* Create a brand new session note from the AI summary.
+*/
+/**
+* Find the note this session already owns, by the marker its first write left.
+*
+* The previous resolver, getCurrentNotePath, returned the numerically highest
+* note in the month directory. That is a position, not an identity, and it is
+* why one session produced many notes: whenever a session's own note was not
+* the current maximum — two sessions in one project, or a number collision, of
+* which one corpus had 110 — the lookup missed and the checkpoint created a
+* new file instead of updating. Measured consequence in that corpus: 303 of
+* 407 notes sat in 31 same-title groups, 48 of them sharing a single title.
+*
+* Matching on the session id makes the answer exact: a session either has a
+* note or it does not, regardless of what else the directory contains.
+*/
+function findNoteBySessionId(notesDir, sessionId) {
+	if (!sessionId || !existsSync(notesDir)) return null;
+	const marker = `<!-- SESSION: ${sessionId} -->`;
+	const now = /* @__PURE__ */ new Date();
+	const dirs = [0, -1].map((delta) => {
+		const d = new Date(now.getFullYear(), now.getMonth() + delta, 1);
+		return join(notesDir, String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, "0"));
+	});
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		for (const f of readdirSync(dir)) {
+			if (!f.endsWith(".md")) continue;
+			const p = join(dir, f);
+			try {
+				if (readFileSync(p, "utf-8").includes(marker)) return p;
+			} catch {}
+		}
+	}
+	return null;
+}
+function createNoteFromSummary(notesDir, summaryText, sessionId) {
+	try {
+		const notePath = createSessionNote(notesDir, "New Session");
+		const noteFilename = basename(notePath);
+		const numberMatch = noteFilename.match(/^(\d+)/);
+		const noteNumber = numberMatch ? numberMatch[1] : "0000";
+		const titleMatch = summaryText.match(/^# Session:\s*(.+)$/m);
+		const title = titleMatch ? titleMatch[1].trim() : "New Session";
+		const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+		const topic = extractTopic(summaryText);
+		const aiBody = summaryText.replace(/^TOPIC:.*$/m, "").replace(/^# Session:.*$/m, "").replace(/^\*\*Date:\*\*.*$/m, "").replace(/^\*\*Status:\*\*.*$/m, "").replace(/^---$/m, "").trim();
+		writeFileSync(notePath, `# Session ${noteNumber}: ${title}
+${topic ? `<!-- TOPIC: ${topic} -->` : ""}${sessionId ? `\n<!-- SESSION: ${sessionId} -->` : ""}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+${aiBody}
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`, "utf-8");
+		process.stderr.write(`[session-summary] Created AI-powered note: ${noteFilename}\n`);
+		return notePath;
+	} catch (e) {
+		process.stderr.write(`[session-summary] Failed to create note: ${e}\n`);
+		return null;
+	}
+}
+/**
+* Look up the integer project_id from the registry backend for a given slug.
+* Returns null if not found.
+*/
+async function lookupProjectId(slug) {
+	try {
+		return (await (await getRegistryBackend()).getProjectBySlug(slug))?.id ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract structured KG triples from a session summary and store them.
+*
+* This is best-effort: any error is logged but never propagated.
+* Requires Postgres backend — silently no-ops on SQLite.
+*/
+async function extractAndStoreTriples(params) {
+	try {
+		if (!storageBackend?.supportsPostgresFeatures) return;
+		if (deferIfQuiet("triple-extraction")) return;
+		const cfg = daemonConfig;
+		if (cfg && cfg.kg_extraction_enabled === false) {
+			process.stderr.write("[session-summary] Triple extraction disabled via kg_extraction_enabled=false.\n");
+			return;
+		}
+		const result = await extractAndStoreTriples$1(storageBackend, {
+			summaryText: params.summaryText,
+			projectSlug: params.projectSlug,
+			projectId: params.projectId,
+			sessionId: params.sessionId,
+			gitLog: params.gitLog,
+			model: "sonnet"
+		});
+		process.stderr.write(`[session-summary] Triple extraction complete: ${result.extracted} extracted, ${result.added} added, ${result.superseded} superseded.\n`);
+	} catch (err) {
+		process.stderr.write(`[session-summary] Triple extraction failed: ${err}\n`);
+	}
+}
+/**
+* Process a `session-summary` work item.
+*
+* This is the main function called by work-queue-worker.ts.
+* Throws on fatal errors (work queue will retry with backoff).
+*/
+async function handleSessionSummary(payload) {
+	const { cwd, sessionId, projectSlug, transcriptPath, force } = payload;
+	if (!cwd) throw new Error("session-summary payload missing cwd");
+	process.stderr.write(`[session-summary] Starting for ${cwd}${sessionId ? ` (session=${sessionId})` : ""}${force ? " (force=true)" : ""}\n`);
+	if (!force && isOnCooldown(cwd)) {
+		process.stderr.write("[session-summary] Skipping — last summary was less than 30 minutes ago.\n");
+		return;
+	}
+	let jsonlPath = transcriptPath || null;
+	if (jsonlPath && !existsSync(jsonlPath)) {
+		process.stderr.write(`[session-summary] Provided transcript path not found: ${jsonlPath}\n`);
+		jsonlPath = null;
+	}
+	if (!jsonlPath) jsonlPath = findLatestJsonl(cwd);
+	if (!jsonlPath) {
+		process.stderr.write("[session-summary] No JSONL transcript found — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Using transcript: ${jsonlPath}\n`);
+	const selectedModel = payload.model ?? (force ? "haiku" : "sonnet");
+	const extracted = extractFromJsonl(jsonlPath, selectedModel);
+	if (extracted.userMessages.length === 0) {
+		process.stderr.write("[session-summary] No user messages found in transcript — skipping.\n");
+		return;
+	}
+	process.stderr.write(`[session-summary] Extracted ${extracted.userMessages.length} user messages, ${extracted.filesModified.length} modified files.\n`);
+	const gitLog = await getGitContext(cwd, extracted.sessionStartTime);
+	if (gitLog) process.stderr.write(`[session-summary] Got git context (${gitLog.split("\n").length} lines).\n`);
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const existingNotePath = getCurrentNotePath(findNotesDir(cwd).path);
+	let existingNote;
+	if (existingNotePath) {
+		const dateMatch = basename(existingNotePath).match(/(\d{4}-\d{2}-\d{2})/);
+		if (dateMatch && dateMatch[1] === today) try {
+			existingNote = readFileSync(existingNotePath, "utf-8");
+		} catch {}
+	}
+	const prompt = buildSessionSummaryPrompt({
+		userMessages: extracted.userMessages,
+		gitLog,
+		cwd,
+		date: today,
+		filesModified: extracted.filesModified,
+		existingNote
+	});
+	process.stderr.write(`[session-summary] Sending ${prompt.length} char prompt to ${selectedModel}...\n`);
+	const summaryText = await spawnSummarizer(prompt, selectedModel);
+	if (!summaryText) {
+		process.stderr.write(`[session-summary] ${selectedModel} did not produce output — falling back to mechanical checkpoint.\n`);
+		markCooldown(cwd);
+		return;
+	}
+	process.stderr.write(`[session-summary] ${selectedModel} produced ${summaryText.length} char summary.\n`);
+	const notePath = writeSessionNote(cwd, summaryText, extracted.filesModified, sessionId);
+	if (notePath) process.stderr.write(`[session-summary] Session note written: ${basename(notePath)}\n`);
+	await extractAndStoreTriples({
+		summaryText,
+		projectSlug: projectSlug ?? basename(cwd),
+		projectId: projectSlug ? await lookupProjectId(projectSlug) : null,
+		sessionId: sessionId ?? cwd,
+		gitLog,
+		model: selectedModel
+	});
+	markCooldown(cwd);
+	process.stderr.write("[session-summary] Done.\n");
+}
+
+//#endregion
+//#region src/daemon/work-queue.ts
+/**
+* work-queue.ts — Persistent work queue for the PAI Daemon
+*
+* Provides a durable, file-backed queue that survives daemon restarts.
+* Items are processed sequentially to avoid concurrent writes to the same
+* session note. Failed items are retried with exponential backoff.
+*
+* Queue file: under PAI_HOME (~/.pai/work-queue.json), falling back
+* to the pre-2026-09-19 ~/.config/pai/work-queue.json location.
+* Written atomically (write temp → rename) to prevent corruption.
+*/
+/** Thrown by a handler when a retry cannot help: markFailed() then fails the item at once. */
+var NonRetryableError = class extends Error {};
+function oldQueueFile() {
+	return join(homedir(), ".config", "pai", "work-queue.json");
+}
+const QUEUE_FILE = resolvePaiFile(paiHomePath("work-queue.json"), [oldQueueFile()], "pai config migrate");
+function migrateWorkQueue(opts = {}) {
+	return migratePaiFile(paiHomePath("work-queue.json"), [oldQueueFile()], opts);
+}
+const MAX_QUEUE_SIZE = 1e3;
+const MAX_QUEUE_FILE_BYTES = 1024 * 1024;
+const COMPLETED_TTL_MS = 3600 * 1e3;
+const FAILED_TTL_MS = 1440 * 60 * 1e3;
+/** Backoff delays in ms by attempt number (0-indexed). */
+const BACKOFF_MS = [
+	5e3,
+	3e4,
+	3e5
+];
+let _queue = [];
+let _dirty = false;
+/** Load queue from disk. Call once at daemon startup. */
+function loadQueue() {
+	if (!existsSync(QUEUE_FILE)) {
+		_queue = [];
+		return;
+	}
+	try {
+		const raw = readFileSync(QUEUE_FILE, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) {
+			process.stderr.write("[work-queue] Invalid queue file format — starting empty.\n");
+			_queue = [];
+			return;
+		}
+		_queue = parsed.map((item) => {
+			if (item.status === "processing") return {
+				...item,
+				status: "pending"
+			};
+			return item;
+		});
+		const stats = getStats();
+		process.stderr.write(`[work-queue] Loaded ${_queue.length} items from disk (pending=${stats.pending}, failed=${stats.failed}).\n`);
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not load queue file: ${e}\n`);
+		_queue = [];
+	}
+}
+/** Persist queue to disk atomically. */
+function saveQueue() {
+	const dir = dirname(QUEUE_FILE);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmpFile = QUEUE_FILE + ".tmp";
+	try {
+		writeFileSync(tmpFile, JSON.stringify(_queue, null, 2), "utf-8");
+		renameSync(tmpFile, QUEUE_FILE);
+		_dirty = false;
+	} catch (e) {
+		process.stderr.write(`[work-queue] Could not persist queue: ${e}\n`);
+	}
+}
+/** Persist only if there are unsaved changes. */
+function saveIfDirty() {
+	if (_dirty) saveQueue();
+}
+/**
+* Enforce the maximum queue size cap.
+* Strategy: first drop oldest completed, then oldest low-priority pending.
+*/
+function enforceMaxSize() {
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const excess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropCompleted = _queue.filter((i) => i.status === "completed").sort((a, b) => a.createdAt.localeCompare(b.createdAt)).slice(0, excess);
+	const dropIds = new Set(toDropCompleted.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropIds.has(i.id));
+	if (_queue.length <= MAX_QUEUE_SIZE) return;
+	const remainingExcess = _queue.length - MAX_QUEUE_SIZE;
+	const toDropLow = _queue.filter((i) => i.status === "pending" && i.priority >= 4).sort((a, b) => a.priority - b.priority || a.createdAt.localeCompare(b.createdAt)).slice(0, remainingExcess);
+	const dropLowIds = new Set(toDropLow.map((i) => i.id));
+	_queue = _queue.filter((i) => !dropLowIds.has(i.id));
+	process.stderr.write(`[work-queue] Pruned queue to ${_queue.length} items (cap=${MAX_QUEUE_SIZE}).\n`);
+}
+/**
+* Add a new work item to the queue.
+* Returns the created WorkItem.
+*/
+function enqueue(params) {
+	const item = {
+		id: randomUUID(),
+		type: params.type,
+		priority: params.priority ?? 3,
+		payload: params.payload,
+		status: "pending",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		attempts: 0,
+		maxAttempts: params.maxAttempts ?? 3
+	};
+	_queue.push(item);
+	enforceMaxSize();
+	_dirty = true;
+	saveIfDirty();
+	process.stderr.write(`[work-queue] Enqueued ${item.type} (id=${item.id}, priority=${item.priority}).\n`);
+	return item;
+}
+/**
+* Pick the next pending item that is ready to process (respects nextRetryAt).
+* Returns null if no eligible item exists.
+* Highest priority (lowest number) is processed first; ties broken by createdAt.
+* Types in `skip` stay pending (quiet mode defers them without dropping them).
+*/
+function dequeue(skip) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const eligible = _queue.filter((i) => {
+		if (i.status !== "pending") return false;
+		if (skip?.has(i.type)) return false;
+		if (i.nextRetryAt && i.nextRetryAt > now) return false;
+		return true;
+	}).sort((a, b) => {
+		if (a.priority !== b.priority) return a.priority - b.priority;
+		return a.createdAt.localeCompare(b.createdAt);
+	});
+	if (eligible.length === 0) return null;
+	const item = eligible[0];
+	item.status = "processing";
+	item.attempts += 1;
+	_dirty = true;
+	saveIfDirty();
+	return item;
+}
+/**
+* Mark an item as completed.
+*/
+function markCompleted(id) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.status = "completed";
+	item.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+	item.error = void 0;
+	_dirty = true;
+	saveIfDirty();
+}
+/**
+* Mark an item as failed.
+* If attempts < maxAttempts, schedules a retry with exponential backoff.
+* Otherwise, leaves status as 'failed'.
+*/
+function markFailed(id, errorMsg, retryable = true) {
+	const item = _queue.find((i) => i.id === id);
+	if (!item) return;
+	item.error = errorMsg;
+	if (retryable && item.attempts < item.maxAttempts) {
+		const backoffMs = BACKOFF_MS[item.attempts - 1] ?? BACKOFF_MS[BACKOFF_MS.length - 1];
+		item.status = "pending";
+		item.nextRetryAt = new Date(Date.now() + backoffMs).toISOString();
+		process.stderr.write(`[work-queue] Item ${id} failed (attempt ${item.attempts}/${item.maxAttempts}), retry in ${backoffMs / 1e3}s: ${errorMsg}\n`);
+	} else {
+		item.status = "failed";
+		process.stderr.write(retryable ? `[work-queue] Item ${id} exhausted retries (${item.maxAttempts} attempts): ${errorMsg}\n` : `[work-queue] Item ${id} failed, not retryable: ${errorMsg}\n`);
+	}
+	_dirty = true;
+	saveIfDirty();
+}
+function getStats() {
+	const stats = {
+		pending: 0,
+		processing: 0,
+		completed: 0,
+		failed: 0,
+		total: _queue.length
+	};
+	for (const item of _queue) stats[item.status]++;
+	return stats;
+}
+/**
+* Returns true if any pending or processing item of the given type exists.
+* Used for debouncing work items that are expensive to run concurrently.
+*/
+function hasPendingOrProcessingOfType(type) {
+	return _queue.some((i) => i.type === type && (i.status === "pending" || i.status === "processing"));
+}
+/**
+* Remove completed and permanently-failed items older than their TTL.
+* Also force-cleans all completed items if the queue file exceeds 1 MB.
+*/
+function cleanup() {
+	const now = Date.now();
+	const before = _queue.length;
+	let forceCleanCompleted = false;
+	try {
+		if (existsSync(QUEUE_FILE)) {
+			const { size } = statSync(QUEUE_FILE);
+			if (size > MAX_QUEUE_FILE_BYTES) {
+				forceCleanCompleted = true;
+				process.stderr.write(`[work-queue] Queue file exceeds 1 MB (${size} bytes) — force-cleaning completed items.\n`);
+			}
+		}
+	} catch {}
+	_queue = _queue.filter((item) => {
+		if (item.status === "completed") {
+			if (forceCleanCompleted) return false;
+			return now - (item.completedAt ? new Date(item.completedAt).getTime() : 0) < COMPLETED_TTL_MS;
+		}
+		if (item.status === "failed") return now - new Date(item.createdAt).getTime() < FAILED_TTL_MS;
+		return true;
+	});
+	const removed = before - _queue.length;
+	const stats = getStats();
+	if (removed > 0 || before === 0) process.stderr.write(`[work-queue] Cleanup: removed ${removed} items. Queue stats: pending=${stats.pending}, processing=${stats.processing}, completed=${stats.completed}, failed=${stats.failed}.\n`);
+	_dirty = removed > 0;
+	saveIfDirty();
+}
+/**
+* Enqueue unless an item of this type is already queued or running, or one
+* started/finished within `windowMs`. Repeat triggers collapse into the one
+* already queued or recently run. Returns the new item, or null when coalesced.
+*/
+function enqueueCoalesced(params, windowMs, now = Date.now()) {
+	if (hasPendingOrProcessingOfType(params.type)) return null;
+	return _queue.some((i) => {
+		if (i.type !== params.type || i.status === "failed") return false;
+		return now - Date.parse(i.completedAt ?? i.createdAt) < windowMs;
+	}) ? null : enqueue(params);
+}
+
+//#endregion
+//#region src/memory/kg-backfill.ts
+/**
+* kg-backfill.ts — Populate the temporal knowledge graph from existing
+* session notes.
+*
+* Walks `Notes/YYYY/MM/*.md` for each registered project, runs the same
+* extractor that the session-summary-worker uses on every NEW summary, and
+* stores triples in Postgres. Idempotent: a state file at
+* ~/.config/pai/kg-backfill-state.json records which note paths have been
+* processed so re-runs skip them.
+*
+* Even without the state file the operation is safe — extractAndStoreTriples
+* uses supersession logic so re-extracting a note never produces duplicates.
+*/
+function oldStateFile() {
+	return join(homedir(), ".config", "pai", "kg-backfill-state.json");
+}
+function statePath() {
+	return resolvePaiFile(paiHomePath("kg-backfill-state.json"), [oldStateFile()], "pai config migrate");
+}
+function migrateKgBackfillState(opts = {}) {
+	return migratePaiFile(paiHomePath("kg-backfill-state.json"), [oldStateFile()], opts);
+}
+function loadState() {
+	try {
+		const file = statePath();
+		if (existsSync(file)) {
+			const raw = JSON.parse(readFileSync(file, "utf-8"));
+			if (raw && typeof raw === "object" && raw.processed) return raw;
+		}
+	} catch {}
+	return { processed: {} };
+}
+function saveState(state) {
+	try {
+		const file = paiHomePath("kg-backfill-state.json");
+		const dir = dirname(file);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(file, JSON.stringify(state, null, 2), "utf-8");
+	} catch (e) {
+		process.stderr.write(`[kg-backfill] failed to save state: ${e}\n`);
+	}
+}
+/**
+* Find all session notes under <project_root>/Notes/YYYY/MM/*.md.
+* Falls back to <project_root>/Notes/*.md (flat layout) when no year/month
+* subdirectories are present.
+*/
+function findProjectNotes(project) {
+	const notesRoot = join(project.root_path, "Notes");
+	if (!existsSync(notesRoot)) return [];
+	const found = [];
+	function walk(dir, depth) {
+		if (depth > 4) return;
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+		for (const name of entries) {
+			const full = join(dir, name);
+			let st;
+			try {
+				st = statSync(full);
+			} catch {
+				continue;
+			}
+			if (st.isDirectory()) walk(full, depth + 1);
+			else if (st.isFile() && name.endsWith(".md") && /^\d{3,4}/.test(name)) found.push({
+				path: full,
+				mtime: st.mtimeMs
+			});
+		}
+	}
+	walk(notesRoot, 0);
+	found.sort((a, b) => a.mtime - b.mtime);
+	return found.map((f) => f.path);
+}
+/**
+* Backfill the knowledge graph from existing session notes.
+*
+* Requires the Postgres backend (KG tables live there). Throws if Postgres
+* is unavailable, since this is an explicit user action.
+*/
+async function backfillKgFromNotes(options = {}) {
+	const result = {
+		notes_processed: 0,
+		triples_extracted: 0,
+		triples_added: 0,
+		triples_superseded: 0,
+		errors: 0
+	};
+	const config = loadConfig();
+	if (config.storageBackend !== "postgres") throw new Error(`kg backfill requires the Postgres backend. Set "storageBackend": "postgres" in ${CONFIG_FILE}.`);
+	const backend = await createStorageBackend(config);
+	if (!backend.supportsPostgresFeatures) throw new Error("Postgres backend unavailable — fell back to SQLite. Cannot backfill KG.");
+	const registry = await getRegistryBackend();
+	let projects;
+	if (options.projectSlug) {
+		const row = await registry.getProjectBySlug(options.projectSlug);
+		if (!row) throw new Error(`Project not found: ${options.projectSlug}`);
+		projects = [row];
+	} else projects = await registry.listProjects({
+		status: "active",
+		orderBy: "slug"
+	});
+	const state = loadState();
+	const work = [];
+	for (const project of projects) {
+		const notes = findProjectNotes(project);
+		for (const notePath of notes) {
+			if (state.processed[notePath]) continue;
+			work.push({
+				project,
+				notePath
+			});
+		}
+	}
+	const total = options.limit ? Math.min(options.limit, work.length) : work.length;
+	for (let i = 0; i < total; i++) {
+		const { project, notePath } = work[i];
+		options.onProgress?.(i + 1, total, notePath);
+		if (options.dryRun) {
+			result.notes_processed++;
+			continue;
+		}
+		let noteContent;
+		try {
+			noteContent = readFileSync(notePath, "utf-8");
+		} catch (e) {
+			process.stderr.write(`[kg-backfill] read failed ${notePath}: ${e}\n`);
+			result.errors++;
+			continue;
+		}
+		try {
+			const stats = await extractAndStoreTriples$1(backend, {
+				summaryText: noteContent,
+				projectSlug: project.slug,
+				projectId: project.id,
+				sessionId: `backfill:${notePath}`,
+				gitLog: "",
+				model: "sonnet"
+			});
+			result.notes_processed++;
+			result.triples_extracted += stats.extracted;
+			result.triples_added += stats.added;
+			result.triples_superseded += stats.superseded;
+			state.processed[notePath] = (/* @__PURE__ */ new Date()).toISOString();
+			if ((i + 1) % 5 === 0) saveState(state);
+		} catch (e) {
+			process.stderr.write(`[kg-backfill] extract failed ${notePath}: ${e}\n`);
+			result.errors++;
+		}
+	}
+	if (!options.dryRun) saveState(state);
+	await backend.close();
+	return result;
+}
+
+//#endregion
+//#region src/daemon/pass-priority.ts
+/**
+* pass-priority.ts — run heavy index/embed pass work at background priority.
+*
+* The daemon also serves MCP, so its own priority must stay normal. The heavy
+* work runs in a child (`pai memory pass <name>`) spawned under
+* `taskpolicy -b nice -n 19` (darwin) or `nice -n 19 ionice -c3` (linux);
+* onnxruntime threads inherit the child's priority. The child reports over
+* stdout as one JSON line: {ok:true,result} or {ok:false,error}.
+*/
+function onPath(bin) {
+	return (process.env.PATH ?? "").split(delimiter).some((d) => d && existsSync(join(d, bin)));
+}
+/**
+* Wrap `node <entry> <passArgs>` in the platform's low-priority incantation.
+* Darwin uses nice 19, not 20: measured on macOS, node started with nice 20
+* reverts to nice 0 within a second; 19 sticks.
+*/
+function buildPassCommand(platform, node, entry, passArgs, have = onPath) {
+	const run = [
+		node,
+		entry,
+		...passArgs
+	];
+	let wrap;
+	if (platform === "darwin") wrap = have("taskpolicy") ? [
+		"taskpolicy",
+		"-b",
+		"nice",
+		"-n",
+		"19"
+	] : [
+		"nice",
+		"-n",
+		"19"
+	];
+	else if (platform === "win32") wrap = [];
+	else wrap = have("ionice") ? [
+		"nice",
+		"-n",
+		"19",
+		"ionice",
+		"-c3"
+	] : [
+		"nice",
+		"-n",
+		"19"
+	];
+	const [cmd, ...rest] = [...wrap, ...run];
+	return {
+		cmd,
+		args: rest
+	};
+}
+/** The CLI entry the child runs: dist/cli/index.mjs next to the daemon's dist. */
+function cliEntry() {
+	return join(dirname(dirname(process.argv[1] ?? "")), "cli", "index.mjs");
+}
+/** Spawning itself failed (binary missing): the caller may fall back in-process. */
+var PassSpawnError = class extends Error {};
+const children = /* @__PURE__ */ new Set();
+process.on("exit", () => children.forEach((c) => c.kill()));
+/**
+* Run one pass in a low-priority child. Resolves with the child's result;
+* rejects with the child's error (pass failure) or PassSpawnError (no child).
+*/
+function runPassChild(name, extraArgs = []) {
+	const { cmd, args } = buildPassCommand(process.platform, process.execPath, cliEntry(), [
+		"memory",
+		"pass",
+		name,
+		...extraArgs
+	]);
+	return new Promise((resolve, reject) => {
+		const child = spawn(cmd, args, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				PAI_PASS_BACKGROUND: "1"
+			}
+		});
+		children.add(child);
+		let out = "";
+		let err = "";
+		child.stdout.on("data", (d) => out += d);
+		child.stderr.on("data", (d) => err = (err + d).slice(-4e3));
+		child.on("error", (e) => {
+			children.delete(child);
+			reject(new PassSpawnError(`cannot spawn ${cmd}: ${e.message}`));
+		});
+		child.on("close", (code, signal) => {
+			children.delete(child);
+			const line = out.trim().split("\n").pop() ?? "";
+			let msg;
+			try {
+				msg = JSON.parse(line);
+			} catch {}
+			if (code === 0 && msg?.ok) return resolve(msg.result);
+			reject(new Error(msg?.error ?? `pass child ${name} exited ${code ?? signal}: ${err.trim().split("\n").pop() ?? ""}`));
+		});
+	});
+}
+/**
+* Inside the wrapper, keep nice at 19: measured on macOS, node's nice resets
+* to 0 about a second after start (5s re-apply interval holds it; the
+* taskpolicy -b QoS is unaffected).
+*/
+function holdNice() {
+	const apply = () => {
+		try {
+			setPriority(process.pid, 19);
+		} catch {}
+	};
+	apply();
+	setInterval(apply, 5e3).unref();
+}
+/**
+* `--background` for CLI commands: re-exec this very command under the
+* low-priority wrapper and exit with its status. Inside the re-exec (or a
+* daemon-spawned pass child, which sets the same env) it only holds nice.
+*/
+function reexecBackground() {
+	if (process.env.PAI_PASS_BACKGROUND === "1") return holdNice();
+	const { cmd, args } = buildPassCommand(process.platform, process.execPath, process.argv[1], process.argv.slice(2));
+	const r = spawnSync(cmd, args, {
+		stdio: "inherit",
+		env: {
+			...process.env,
+			PAI_PASS_BACKGROUND: "1"
+		}
+	});
+	if (r.error) {
+		process.stderr.write(`--background: cannot spawn ${cmd} (${r.error.message}); running at normal priority\n`);
+		return;
+	}
+	process.exit(r.status ?? 1);
+}
+
+//#endregion
+export { setVaultIndexInProgress as $, indexSchedulerTimer as A, DEFAULT_EMBED_MAX_MINUTES as At, setEmbedInProgress as B, applyContinue as Bt, migrateSummaryCooldowns as C, describeQuiet as Ct, embedInProgress as D, startQuietWatcher as Dt, daemonConfig as E, registerQuietRunner as Et, notificationConfig as F, resolveDaemonPid as Ft, setLastEmbedTime as G, setIndexInProgress as H, findNotesDir$1 as Ht, passFailures as I, writeDaemonPidfile as It, setNotificationConfig as J, setLastIndexTime as K, registryBackend as L, readContextHandoverCache as Lt, lastEmbedTime as M, formatEmbedStatus as Mt, lastIndexTime as N, liveYieldCheck as Nt, embedSchedulerTimer as O, writeQuiet as Ot, lastVaultIndexTime as P, removeDaemonPidfile as Pt, setStorageBackend as Q, setCacheKeepaliveTimer as R, writeContextHandoverCache as Rt, handleSessionSummary as S, deferIfQuiet as St, cacheKeepaliveTimer as T, readQuiet as Tt, setIndexSchedulerTimer as U, readBodyFile as Ut, setEmbedSchedulerTimer as V, findLatestNote as Vt, setLastEmbedPass as W, setShutdownRequested as X, setRegistryBackend as Y, setStartTime as Z, markFailed as _, loadSessionKeepaliveState as _t, runPassChild as a, updateTodoContinue as at, findLatestJsonl as b, parseSessionUsage as bt, NonRetryableError as c, finalizeSessionNote as ct, enqueue as d, findNotesDir as dt, shutdownRequested as et, enqueueCoalesced as f, OBSIDIAN_DISABLED_MESSAGE as ft, markCompleted as g, migrateIdentityFile as gt, loadQueue as h, buildWakeupContext as ht, reexecBackground as i, sessionIdFromTranscript as it, lastEmbedPass as j, EMBED_PASS_BATCH_SIZE as jt, indexInProgress as k, DEFAULT_EMBED_MAX_LOAD as kt, cleanup as l, getCurrentNotePath as lt, hasPendingOrProcessingOfType as m, vaultIndexEnabled as mt, buildPassCommand as n, storageBackend as nt, backfillKgFromNotes as o, addWorkToSessionNote as ot, getStats as p, obsidianEnabled as pt, setLastVaultIndexTime as q, cliEntry as r, vaultIndexInProgress as rt, migrateKgBackfillState as s, appendCheckpoint as st, PassSpawnError as t, startTime as tt, dequeue as u, archiveSessionFilesToSessionsDir as ut, migrateWorkQueue as v, runSessionKeepaliveTick as vt, spawnSummarizer as w, nextOccurrence as wt, getGitContext as x, totalUsageTokens as xt, contentToText as y, sessionKeepaliveLedgerSummary as yt, setDaemonConfig as z, appendCheckpointToNote as zt };
+//# sourceMappingURL=indexer-backend-1tkR2y1-.mjs.map