@tekmidian/pai 0.66.1 → 0.66.3

package/dist/{context-handover-cache-pkHzmL3c.mjs → context-handover-cache-DcPEW6vf.mjs}

@@ -1,19 +1,113 @@
-import { _ as warn, c as ok, i as err, n as dim, r as encodeDir, s as now, t as bold } from "./utils-C9HsYDpO.mjs";
-import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "./migrate-BD7D8EEh.mjs";
-import { n as ensurePaiMarker, t as discoverPaiMarkers } from "./pai-marker-D1MMswkz.mjs";
-import { i as getRegistryBackend } from "./factory-CNpPQQ-5.mjs";
-import { a as paiHomePath, o as resolvePaiFile, r as migratePaiFile } from "./pai-home-Cm9rcJgX.mjs";
-import { D as readWorkersSection, k as resolveModelCapability, t as buildRunEnv, v as defaultWorkersConfig } from "./run-env-DRcp7A8K.mjs";
-import { d as resolveTarget, n as ensureProxyRunning, p as ensureNoMcpConfig, t as DEFAULT_PROXY_PORT, v as workersLogDir } from "./server-DgmAHyFK.mjs";
-import { k as storageBackend, n as daemonConfig } from "./state-HyjqTihC.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { c as ok, g as warn, i as err, n as dim, r as encodeDir, s as now, t as bold } from "./utils-DddRwMsG.mjs";
+import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, t as buildEncodedDirMap } from "./migrate-Bq0esMOa.mjs";
+import { n as ensurePaiMarker, t as discoverPaiMarkers } from "./pai-marker-DXVpFsYz.mjs";
+import { i as getRegistryBackend } from "./factory-BUnZgnKW.mjs";
+import { y as writeJsonAtomic } from "./config-Ddc4DIPk.mjs";
+import { a as paiHomePath, o as resolvePaiFile, r as migratePaiFile } from "./pai-home-UncxWxlX.mjs";
+import { r as daemonPidPath } from "./runtime-paths-Bw3Jk8qJ.mjs";
+import { D as readWorkersSection, k as resolveModelCapability, t as buildRunEnv, v as defaultWorkersConfig } from "./run-env-CQRnxNht.mjs";
+import { C as itermUuid, F as appendLedger, P as worktreesDir, T as sessionMapPath, ct as resolveTarget, lt as ensureNoMcpConfig, nt as DEFAULT_PROXY_PORT, pt as workersLogDir, rt as ensureProxyRunning } from "./run-D9YbWsnL.mjs";
+import { i as sendToSession, n as fetchLiveSessions } from "./aibroker-client-WCZi_tn-.mjs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, setPriority, tmpdir, userInfo } from "node:os";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
 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";
+import { createInterface } from "node:readline";
 
+//#region src/cli/commands/detect.ts
+/**
+* Project detection logic for PAI.
+*
+* detectProject(cwd) — given a filesystem path, returns the best matching
+* project from the registry:
+*   1. Exact path match
+*   2. Longest parent match (project whose root_path is an ancestor of cwd)
+*
+* Exported for use by the CLI `pai project detect` command and the MCP
+* `project_detect` tool.
+*/
+/**
+* Detect which registered project a filesystem path belongs to.
+*
+* @param cwd  Absolute path to detect (defaults to process.cwd())
+* @returns    The best matching project, or null if no match
+*/
+async function detectProject(cwd) {
+	const target = resolve(cwd ?? process.cwd());
+	const backend = await getRegistryBackend();
+	const projects = await backend.listProjectsByPathLengthDesc({ excludeArchived: true });
+	let matched = null;
+	let matchType = "exact";
+	for (const p of projects) {
+		const root = resolve(p.root_path);
+		if (target === root) {
+			matched = p;
+			matchType = "exact";
+			break;
+		}
+		if (!matched && target.startsWith(root + "/")) {
+			matched = p;
+			matchType = "parent";
+			break;
+		}
+	}
+	if (!matched) return null;
+	const sessionCount = await backend.countSessionsForProject(matched.id);
+	const lastDate = await backend.getMostRecentSessionDate(matched.id);
+	const relative = matchType === "parent" ? target.slice(resolve(matched.root_path).length + 1) : null;
+	return {
+		id: matched.id,
+		slug: matched.slug,
+		display_name: matched.display_name,
+		root_path: matched.root_path,
+		encoded_dir: matched.encoded_dir,
+		type: matched.type,
+		status: matched.status,
+		session_count: sessionCount,
+		last_session_date: lastDate,
+		match_type: matchType,
+		relative_path: relative
+	};
+}
+/**
+* Format a DetectedProject for human-readable CLI output.
+*/
+function formatDetection(d) {
+	const lines = [
+		`slug:         ${d.slug}`,
+		`display_name: ${d.display_name}`,
+		`root_path:    ${d.root_path}`,
+		`type:         ${d.type}`,
+		`status:       ${d.status}`,
+		`match:        ${d.match_type}${d.relative_path ? ` (+${d.relative_path})` : ""}`,
+		`sessions:     ${d.session_count}`
+	];
+	if (d.last_session_date) lines.push(`last_session: ${d.last_session_date}`);
+	return lines.join("\n");
+}
+/**
+* Format a DetectedProject as JSON for machine consumption.
+*/
+function formatDetectionJson(d) {
+	return JSON.stringify({
+		slug: d.slug,
+		display_name: d.display_name,
+		root_path: d.root_path,
+		encoded_dir: d.encoded_dir,
+		type: d.type,
+		status: d.status,
+		match_type: d.match_type,
+		relative_path: d.relative_path,
+		session_count: d.session_count,
+		last_session_date: d.last_session_date
+	}, null, 2);
+}
+
+//#endregion
 //#region src/registry/moved.ts
 /**
 * moved.ts — reconnect a project to transcripts that moved out from under it.
@@ -553,6 +647,386 @@ async function cmdScan(opts = {}) {
 	} else process.stderr.write(`[registry-scan] ${result.projectsScanned} projects, ${result.sessionsScanned} sessions (${result.projectsNew}+${result.sessionsNew} new).\n`);
 }
 
+//#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
+//#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/hooks/ts/lib/pai-paths.ts
 /**
@@ -2228,6 +2702,82 @@ async function extractAndStoreTriples$1(backend, params) {
 	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;
+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 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
 /**
@@ -3171,6 +3721,664 @@ function cleanup() {
 	saveIfDirty();
 }
 
+//#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/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/hooks/ts/lib/context-handover-cache.ts
 /**
@@ -3203,5 +4411,5 @@ function writeContextHandoverCache(cache) {
 }
 
 //#endregion
-export { archiveSessionFilesToSessionsDir as A, claudeProjectsDir as B, findLatestNote as C, appendCheckpoint as D, addWorkToSessionNote as E, performScan as F, scanTranscriptFolders as H, resolveHome as I, saveScanConfig as L, cmdScan as M, loadScanConfig as N, finalizeSessionNote as O, migrateScanConfig as P, upsertProject as R, applyContinue as S, readBodyFile as T, transcriptFiles as U, findMovedProjects as V, spawnSummarizer as _, enqueue as a, updateTodoContinue as b, loadQueue as c, migrateWorkQueue as d, contentToText as f, migrateSummaryCooldowns as g, handleSessionSummary as h, dequeue as i, findNotesDir$1 as j, getCurrentNotePath as k, markCompleted as l, getGitContext as m, writeContextHandoverCache as n, getStats as o, findLatestJsonl as p, cleanup as r, hasPendingOrProcessingOfType as s, readContextHandoverCache as t, markFailed as u, extractAndStoreTriples$1 as v, findNotesDir as w, appendCheckpointToNote as x, sessionIdFromTranscript as y, upsertSession as z };
-//# sourceMappingURL=context-handover-cache-pkHzmL3c.mjs.map
+export { shutdownRequested as $, indexInProgress as A, claudeProjectsDir as At, setEmbedInProgress as B, handleSessionSummary as C, loadScanConfig as Ct, daemonConfig as D, saveScanConfig as Dt, cacheKeepaliveTimer as E, resolveHome as Et, notificationConfig as F, formatDetection as Ft, setLastIndexTime as G, setIndexInProgress as H, passFailures as I, formatDetectionJson as It, setRegistryBackend as J, setLastVaultIndexTime as K, registryBackend as L, lastEmbedTime as M, scanTranscriptFolders as Mt, lastIndexTime as N, transcriptFiles as Nt, embedInProgress as O, upsertProject as Ot, lastVaultIndexTime as P, detectProject as Pt, setVaultIndexInProgress as Q, setCacheKeepaliveTimer as R, getGitContext as S, cmdScan as St, spawnSummarizer as T, performScan as Tt, setIndexSchedulerTimer as U, setEmbedSchedulerTimer as V, setLastEmbedTime as W, setStartTime as X, setShutdownRequested as Y, setStorageBackend as Z, markCompleted as _, buildWakeupContext as _t, sessionKeepaliveLedgerSummary as a, updateTodoContinue as at, contentToText as b, reexecBackground as bt, removeDaemonPidfile as c, findLatestNote as ct, cleanup as d, addWorkToSessionNote as dt, startTime as et, dequeue as f, appendCheckpoint as ft, loadQueue as g, findNotesDir$1 as gt, hasPendingOrProcessingOfType as h, archiveSessionFilesToSessionsDir as ht, runSessionKeepaliveTick as i, sessionIdFromTranscript as it, indexSchedulerTimer as j, findMovedProjects as jt, embedSchedulerTimer as k, upsertSession as kt, resolveDaemonPid as l, findNotesDir as lt, getStats as m, getCurrentNotePath as mt, writeContextHandoverCache as n, vaultIndexInProgress as nt, parseSessionUsage as o, appendCheckpointToNote as ot, enqueue as p, finalizeSessionNote as pt, setNotificationConfig as q, loadSessionKeepaliveState as r, extractAndStoreTriples$1 as rt, totalUsageTokens as s, applyContinue as st, readContextHandoverCache as t, storageBackend as tt, writeDaemonPidfile as u, readBodyFile as ut, markFailed as v, migrateIdentityFile as vt, migrateSummaryCooldowns as w, migrateScanConfig as wt, findLatestJsonl as x, runPassChild as xt, migrateWorkQueue as y, PassSpawnError as yt, setDaemonConfig as z };
+//# sourceMappingURL=context-handover-cache-DcPEW6vf.mjs.map