@tekmidian/pai 0.36.0 → 0.36.1

package/dist/{program-BnMNFb4O.mjs → program-C-fUghPv.mjs}

@@ -7,7 +7,7 @@ import { i as indexProject, n as indexAll, t as embedChunks } from "./sync-BWbe8
 import { t as STOP_WORDS } from "./stop-words-Hfu8u22w.mjs";
 import { a as searchMemory, i as populateSlugs } from "./search-Rpk1cSBC.mjs";
 import { n as formatDetection, r as formatDetectionJson, t as detectProject } from "./detect-CdaA48EI.mjs";
-import { _ as transcriptFiles, a as readBodyFile, c as loadScanConfig, d as saveScanConfig, f as upsertProject, g as scanTranscriptFolders, h as findMovedProjects, i as findNotesDir$1, m as claudeProjectsDir, n as applyContinue, o as extractAndStoreTriples, p as upsertSession, r as findLatestNote, s as cmdScan, t as appendCheckpointToNote, u as resolveHome } from "./checkpoint-block-DKYxCkBL.mjs";
+import { _ as findMovedProjects, a as findLatestNote, c as extractAndStoreTriples, f as resolveHome, g as claudeProjectsDir, h as upsertSession, i as applyContinue, l as cmdScan, m as upsertProject, o as findNotesDir$1, p as saveScanConfig, r as appendCheckpointToNote, s as readBodyFile, t as readContextHandoverCache, u as loadScanConfig, v as scanTranscriptFolders, y as transcriptFiles } from "./context-handover-cache-PtNvj_8D.mjs";
 import { a as schedulerLogPath, i as paiSocketPath, n as daemonLogPath, r as daemonPidPath } from "./runtime-paths-rni52zHX.mjs";
 import { t as PaiClient } from "./ipc-client-BmypMNYk.mjs";
 import { a as expandHome, c as UNROUTED, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, s as OWNER_LABEL_PREFIX, t as CONFIG_DIR } from "./config-B64vFg14.mjs";
@@ -3649,7 +3649,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("./daemon-DJEFqV84.mjs");
+		const { serve } = await import("./daemon-DRdoA489.mjs");
 		const { loadConfig: lc, ensureConfigDir } = await import("./config-C_ErGddD.mjs");
 		ensureConfigDir();
 		await serve(lc());
@@ -12375,12 +12375,6 @@ const DEFAULT_AUTOCOMPACT_PCT = 80;
 /** How many of the most recent compact_boundary events to consider, and to
 *  take the minimum of. */
 const MEASURED_TRIGGER_SAMPLE_SIZE = 3;
-/** How many of a project's most-recently-modified transcripts to scan for
-*  compact_boundary events. compact_boundary events cluster in whichever
-*  files were touched most recently — a full-history scan would cost a lot
-*  for a long-lived project and buy nothing this doesn't already get from
-*  the last handful of files. */
-const MEASURED_TRIGGER_MAX_FILES = 8;
 const THRESHOLD_MARGIN_TOKENS = {
 	warmup: 1e5,
 	refresh: 4e4,
@@ -12392,10 +12386,18 @@ const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 function encodeProjectPath(cwd) {
 	return cwd.replace(/[/\s.-]/g, "-");
 }
+/** Every `.jsonl` transcript belonging to a project — top-level (the live
+*  file) and `sessions/` (Claude Code's archive, which mirrors it). No file
+*  is excluded and no ordering is applied here: ordering by EVENT
+*  timestamp, not by file mtime, is the whole point (see
+*  readCompactBoundarySamples) — a file's mtime does not reliably track
+*  which events inside it are recent, and pre-filtering by mtime is exactly
+*  what caused this function to return a stale, pre-regime-change trigger
+*  on real data. */
 function listProjectTranscripts(cwd, projectsDir) {
 	const projectDir = join(projectsDir, encodeProjectPath(cwd));
 	if (!existsSync(projectDir)) return [];
-	const candidates = [];
+	const paths = [];
 	const collect = (dir) => {
 		if (!existsSync(dir)) return;
 		let entries;
@@ -12404,28 +12406,21 @@ function listProjectTranscripts(cwd, projectsDir) {
 		} catch {
 			return;
 		}
-		for (const entry of entries) {
-			if (!entry.endsWith(".jsonl")) continue;
-			const full = join(dir, entry);
-			try {
-				candidates.push({
-					path: full,
-					mtimeMs: statSync(full).mtimeMs
-				});
-			} catch {}
-		}
+		for (const entry of entries) if (entry.endsWith(".jsonl")) paths.push(join(dir, entry));
 	};
 	collect(projectDir);
 	collect(join(projectDir, "sessions"));
-	candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	return candidates.slice(0, MEASURED_TRIGGER_MAX_FILES).map((c) => c.path);
+	return paths;
 }
 /**
-* Every compact_boundary sample found in a project's most-recently-modified
-* transcripts, newest first.
+* Every DISTINCT compact_boundary sample found across ALL of a project's
+* transcripts (live + archived), newest first by the event's OWN timestamp
+* — never by which file it came from or that file's mtime. Deduplicated by
+* the event's uuid (falling back to a timestamp+preTokens key for the rare
+* line with no uuid) so an event mirrored into `sessions/` is counted once.
 */
 function readCompactBoundarySamples(cwd, projectsDir) {
-	const samples = [];
+	const byKey = /* @__PURE__ */ new Map();
 	for (const path of listProjectTranscripts(cwd, projectsDir)) {
 		let raw;
 		try {
@@ -12446,27 +12441,45 @@ function readCompactBoundarySamples(cwd, projectsDir) {
 			if (typeof preTokens !== "number" || !Number.isFinite(preTokens)) continue;
 			const timestampMs = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
 			if (!Number.isFinite(timestampMs)) continue;
-			samples.push({
+			const key = entry.uuid ?? `${timestampMs}:${preTokens}`;
+			if (!byKey.has(key)) byKey.set(key, {
 				preTokens,
-				timestampMs
+				timestampMs,
+				timestamp: entry.timestamp,
+				uuid: entry.uuid
 			});
 		}
 	}
-	samples.sort((a, b) => b.timestampMs - a.timestampMs);
-	return samples;
+	return [...byKey.values()].sort((a, b) => b.timestampMs - a.timestampMs);
+}
+/**
+* The most recent MEASURED_TRIGGER_SAMPLE_SIZE distinct compact_boundary
+* events for a project, newest first — exposed on its own (not just the
+* derived minimum) so the number `measureCompactionTrigger` returns is
+* checkable: print these and the timestamps prove which three events
+* produced it, rather than asking for trust.
+*/
+function selectedCompactionSamples(cwd, projectsDir = CLAUDE_PROJECTS_DIR) {
+	if (!cwd) return [];
+	return readCompactBoundarySamples(cwd, projectsDir).slice(0, MEASURED_TRIGGER_SAMPLE_SIZE);
 }
 /**
 * The measured compaction trigger for a project, or null when it has no
 * compaction history yet (a brand-new project, or one whose transcripts
 * this process cannot read). Minimum of the most recent
-* MEASURED_TRIGGER_SAMPLE_SIZE compact_boundary events — see the module
-* comment above for why minimum, not mean.
+* MEASURED_TRIGGER_SAMPLE_SIZE DISTINCT compact_boundary events, ordered by
+* the events' own timestamps across every transcript the project has
+* (live and archived) — see the module comment above for why minimum, not
+* mean, and readCompactBoundarySamples for why "distinct" and "own
+* timestamp" both matter (a file-mtime-ordered, non-deduplicated version of
+* this returned a stale pre-regime-change trigger on real project data).
 */
 function measureCompactionTrigger(cwd, projectsDir = CLAUDE_PROJECTS_DIR) {
-	if (!cwd) return null;
-	const samples = readCompactBoundarySamples(cwd, projectsDir).slice(0, MEASURED_TRIGGER_SAMPLE_SIZE);
+	const samples = selectedCompactionSamples(cwd, projectsDir);
 	if (samples.length === 0) return null;
-	return Math.min(...samples.map((s) => s.preTokens));
+	const trigger = Math.min(...samples.map((s) => s.preTokens));
+	console.error(`[context-fill] measured trigger for ${cwd}: ${trigger} (minimum of ` + samples.map((s) => `${s.preTokens}@${s.timestamp}`).join(", ") + ")");
+	return trigger;
 }
 /**
 * Read CLAUDE_AUTOCOMPACT_PCT_OVERRIDE from the environment. Absent →
@@ -12487,22 +12500,53 @@ function resolveAutocompactPct(env = process.env) {
 	return parsed;
 }
 /**
-* Derive warmup/refresh/immediate thresholds from a fill reading, preferring
-* this project's own measured compaction history over the configured
-* override chain — see the module comment above for why. Margins are
-* clamped at 0 (and logged) for a window small enough that a margin would
-* otherwise go negative — a pathological input should degrade to "fire
-* immediately", never to a threshold below zero.
+* Derive warmup/refresh/immediate thresholds from a fill reading.
+*
+* effectiveTrigger = min(measured, configuredChainValue) when a measured
+* value exists — NOT the measured value outright. A project whose newest
+* compaction predates a regime change measures a stale-HIGH trigger: a real
+* case on this machine measured 998,267 for a project whose ACTUAL current
+* boundary (from a different project's fresher history, cross-checked
+* independently) is ~784,000 — using 998,267 directly would compute a
+* warm-up of 898,267, above the real boundary, so the handover would never
+* fire there. The measurement is honest; it is just old.
+*
+* The minimum is correct in both directions: the measured value is the
+* better estimate when it is LOWER than configured (it reflects reality the
+* configured percentage cannot know — see the module comment above, the
+* 100%-to-78% regime change this project itself lived through); it is
+* unsafe when it is HIGHER (it reflects a regime that no longer applies).
+* Taking the minimum costs nothing in the safe direction — one wasted
+* summary if the project's regime actually did move up — and prevents the
+* unsafe direction, where a stale-high measurement suppresses the handover
+* past the real boundary. That asymmetry is the same one the 80-not-100
+* default was chosen for.
+*
+* Margins below effectiveTrigger are clamped at 0 (and logged) for a window
+* small enough that a margin would otherwise go negative — a pathological
+* input should degrade to "fire immediately", never to a threshold below
+* zero.
 */
 function contextFillThresholds(reading, env = process.env, opts = {}) {
 	const windowConfirmed = reading.source === "statusline";
 	const autocompactPct = resolveAutocompactPct(env);
 	const configuredTriggerTokens = Math.round(reading.windowSize * (autocompactPct / 100));
-	const measured = opts.measuredTrigger !== void 0 ? opts.measuredTrigger : opts.cwd ? measureCompactionTrigger(opts.cwd) : null;
-	const triggerSource = measured !== null ? "measured" : "configured";
-	const effectiveTriggerTokens = measured !== null ? measured : configuredTriggerTokens;
-	if (triggerSource === "measured") console.error(`[context-fill] trigger source: MEASURED — ${effectiveTriggerTokens} tokens (minimum of the most recent ${MEASURED_TRIGGER_SAMPLE_SIZE} compact_boundary events for this project; the configured chain would have given ${configuredTriggerTokens}).`);
-	else console.error(`[context-fill] trigger source: CONFIGURED — no compaction history for this project yet, using ${effectiveTriggerTokens} tokens (${autocompactPct}% of a ${reading.windowSize}-token window).`);
+	const measuredTriggerTokens = opts.measuredTrigger !== void 0 ? opts.measuredTrigger : opts.cwd ? measureCompactionTrigger(opts.cwd) : null;
+	let effectiveTriggerTokens;
+	let triggerSource;
+	if (measuredTriggerTokens === null) {
+		effectiveTriggerTokens = configuredTriggerTokens;
+		triggerSource = "configured";
+		console.error(`[context-fill] trigger source: CONFIGURED — no compaction history for this project yet. measured=none, configured=${configuredTriggerTokens} (${autocompactPct}% of a ${reading.windowSize}-token window) -> using ${effectiveTriggerTokens}.`);
+	} else if (measuredTriggerTokens <= configuredTriggerTokens) {
+		effectiveTriggerTokens = measuredTriggerTokens;
+		triggerSource = "measured";
+		console.error(`[context-fill] trigger source: MEASURED — measured=${measuredTriggerTokens} (minimum of the most recent ${MEASURED_TRIGGER_SAMPLE_SIZE} compact_boundary events), configured=${configuredTriggerTokens} -> using ${effectiveTriggerTokens} (measured, ≤ configured).`);
+	} else {
+		effectiveTriggerTokens = configuredTriggerTokens;
+		triggerSource = "measured-clamped";
+		console.error(`[context-fill] trigger source: MEASURED-CLAMPED — measured=${measuredTriggerTokens} is HIGHER than configured=${configuredTriggerTokens} (a stale regime this project's history predates) -> using ${effectiveTriggerTokens} (configured, the safer bound).`);
+	}
 	const clamp = (name, value) => {
 		if (value >= 0) return value;
 		console.error(`[context-fill] ${name} threshold went negative (${value}) for a ${reading.windowSize}-token window — clamping to 0.`);
@@ -12513,6 +12557,8 @@ function contextFillThresholds(reading, env = process.env, opts = {}) {
 		refreshTokens: clamp("refresh", effectiveTriggerTokens - THRESHOLD_MARGIN_TOKENS.refresh),
 		immediateTokens: clamp("immediate", effectiveTriggerTokens - THRESHOLD_MARGIN_TOKENS.immediate),
 		effectiveTriggerTokens,
+		measuredTriggerTokens,
+		configuredTriggerTokens,
 		autocompactPct,
 		triggerSource,
 		windowConfirmed
@@ -12559,6 +12605,16 @@ function isImmediate(usedTokens, thresholds) {
 * derived thresholds from hooks/ts/lib/context-fill.ts; this module only
 * adds the "have we already fired this one" bookkeeping and the enqueue.
 *
+* BUG FIXED (found in live use, session 77084e72-...): a threshold used to
+* be marked fired the moment the ENQUEUE call succeeded — recording intent,
+* not outcome. When the daemon worker then failed or was restarted mid-spawn
+* (observed: a daemon restart 90s after the enqueue), no handover cache was
+* ever written, but the marker already said "done" — so the session
+* compacted with the mechanical scrape only, and would never have retried,
+* ever, for that session. A threshold is now marked CONFIRMED only after a
+* handover cache file actually appears; an enqueue with no cache to show for
+* it within PENDING_TIMEOUT_MS is treated as failed and retried.
+*
 * Never throws. A daemon that isn't running, a stale reading, an unknown
 * fill — every one of those is a reason to do nothing this check and try
 * again next time, not a reason to interrupt the hook that called this.
@@ -12569,24 +12625,43 @@ function isImmediate(usedTokens, thresholds) {
 *  making the calling hook wait anywhere near as long as a normal IPC call
 *  is allowed to. */
 const ENQUEUE_TIMEOUT_MS = 2e3;
-/** Both thresholds fired — nothing left to check for the rest of the session. */
+/**
+* How long to wait for a handover cache to appear after an enqueue before
+* treating it as failed and retrying. Generous over the worker's own sonnet
+* timeout (120s, see session-summary-worker.ts's CLAUDE_TIMEOUT_MS) plus
+* queue latency, so a slow-but-working run isn't retried out from under
+* itself — and short enough that a genuinely dead attempt (a daemon restart
+* mid-spawn, exactly what happened in the live failure this fixes) is
+* retried well before the next compaction, not "never".
+*/
+const PENDING_TIMEOUT_MS = 300 * 1e3;
+/** Both thresholds confirmed — nothing left to check for the rest of the session. */
 const ALL_THRESHOLDS = ["warmup", "refresh"];
-function firedThresholdsPath(sessionId) {
+function triggerStatePath(sessionId) {
 	return join(tmpdir(), `pai-context-handover-fired-${sessionId}.json`);
 }
-function loadFiredThresholds(sessionId) {
-	const path = firedThresholdsPath(sessionId);
-	if (!existsSync(path)) return [];
+function loadTriggerState(sessionId) {
+	const path = triggerStatePath(sessionId);
+	if (!existsSync(path)) return {
+		confirmed: [],
+		pending: null
+	};
 	try {
 		const raw = JSON.parse(readFileSync(path, "utf-8"));
-		return Array.isArray(raw.fired) ? raw.fired : [];
+		return {
+			confirmed: Array.isArray(raw.confirmed) ? raw.confirmed : [],
+			pending: raw.pending && Array.isArray(raw.pending.thresholds) && typeof raw.pending.enqueuedAt === "string" ? raw.pending : null
+		};
 	} catch {
-		return [];
+		return {
+			confirmed: [],
+			pending: null
+		};
 	}
 }
-function saveFiredThresholds(sessionId, fired) {
+function saveTriggerState(sessionId, state) {
 	try {
-		writeFileSync(firedThresholdsPath(sessionId), JSON.stringify({ fired }), "utf-8");
+		writeFileSync(triggerStatePath(sessionId), JSON.stringify(state), "utf-8");
 	} catch {}
 }
 async function enqueueContextHandover(payload) {
@@ -12607,30 +12682,69 @@ const defaultDeps = {
 		sessionId: input.sessionId,
 		transcriptPath: input.transcriptPath
 	}),
-	loadFired: loadFiredThresholds,
-	saveFired: saveFiredThresholds,
-	enqueue: enqueueContextHandover
+	loadState: loadTriggerState,
+	saveState: saveTriggerState,
+	readCache: readContextHandoverCache,
+	enqueue: enqueueContextHandover,
+	now: () => Date.now()
+};
+const NOTHING = {
+	attempted: [],
+	confirmed: []
 };
 /**
-* Check this session's current context fill against the derived thresholds
-* and enqueue a context-handover job for any newly-crossed one. Returns the
-* threshold name(s) newly fired this call — empty when nothing crossed, the
-* reading is unknown, or every threshold has already fired.
+* Check this session's current context fill against the derived thresholds,
+* confirm or retry any in-flight attempt, and enqueue a context-handover job
+* for any newly-crossed threshold. Never marks a threshold done on the
+* strength of the enqueue call alone — only a verified cache file does that.
 *
 * A single check that crosses both warmup and refresh in one jump (a
 * session first observed already close to compaction) enqueues ONE job,
-* tagged with the more urgent of the two, and marks both fired — one
-* model-written handover already covers what either alone would have.
+* tagged with the more urgent of the two, and — once confirmed — marks both
+* done together, since one model-written handover already covers what
+* either alone would have.
 */
 async function checkAndEnqueueContextHandover(input, deps = defaultDeps) {
-	const alreadyFired = deps.loadFired(input.sessionId);
-	if (ALL_THRESHOLDS.every((t) => alreadyFired.includes(t))) return [];
+	let state = deps.loadState(input.sessionId);
+	if (ALL_THRESHOLDS.every((t) => state.confirmed.includes(t))) return NOTHING;
+	let confirmedThisCheck = [];
+	if (state.pending) {
+		const cache = deps.readCache(input.sessionId);
+		if (cache !== null && Date.parse(cache.generatedAt) > Date.parse(state.pending.enqueuedAt)) {
+			const newlyConfirmed = state.pending.thresholds.filter((t) => !state.confirmed.includes(t));
+			state = {
+				confirmed: [...state.confirmed, ...newlyConfirmed],
+				pending: null
+			};
+			deps.saveState(input.sessionId, state);
+			confirmedThisCheck = newlyConfirmed;
+			console.error(`[context-handover-trigger] session ${input.sessionId}: confirmed [${newlyConfirmed.join(", ")}] — handover cache verified (generated ${cache.generatedAt}).`);
+			if (ALL_THRESHOLDS.every((t) => state.confirmed.includes(t))) return {
+				attempted: [],
+				confirmed: confirmedThisCheck
+			};
+		} else if (deps.now() - Date.parse(state.pending.enqueuedAt) < PENDING_TIMEOUT_MS) return NOTHING;
+		else {
+			console.error(`[context-handover-trigger] session ${input.sessionId}: pending [${state.pending.thresholds.join(", ")}] timed out after ${PENDING_TIMEOUT_MS}ms with no handover cache written — treating as FAILED and retrying (daemon worker likely died or was restarted mid-run).`);
+			state = {
+				...state,
+				pending: null
+			};
+			deps.saveState(input.sessionId, state);
+		}
+	}
 	const reading = deps.getReading(input);
-	if (reading.status !== "ok" || reading.usedTokens === null) return [];
+	if (reading.status !== "ok" || reading.usedTokens === null) return {
+		attempted: [],
+		confirmed: confirmedThisCheck
+	};
 	const thresholds = contextFillThresholds(reading, process.env, { cwd: input.cwd });
 	if (!thresholds.windowConfirmed) console.error(`[context-handover-trigger] session ${input.sessionId}: window size not confirmed — using the assumed default (${reading.windowSize} tokens) rather than a reading Claude Code reported.`);
-	const newlyCrossed = crossedThresholds(reading.usedTokens, thresholds, alreadyFired);
-	if (newlyCrossed.length === 0) return [];
+	const newlyCrossed = crossedThresholds(reading.usedTokens, thresholds, state.confirmed);
+	if (newlyCrossed.length === 0) return {
+		attempted: [],
+		confirmed: confirmedThisCheck
+	};
 	const urgent = isImmediate(reading.usedTokens, thresholds);
 	const mostUrgent = newlyCrossed[newlyCrossed.length - 1];
 	try {
@@ -12642,12 +12756,25 @@ async function checkAndEnqueueContextHandover(input, deps = defaultDeps) {
 			urgent
 		});
 	} catch (err) {
-		console.error(`[context-handover-trigger] session ${input.sessionId}: enqueue failed, will retry next check: ${err}`);
-		return [];
+		console.error(`[context-handover-trigger] session ${input.sessionId}: enqueue FAILED — will retry next check: ${err}`);
+		return {
+			attempted: [],
+			confirmed: confirmedThisCheck
+		};
 	}
-	deps.saveFired(input.sessionId, [...alreadyFired, ...newlyCrossed]);
-	console.error(`[context-handover-trigger] session ${input.sessionId}: crossed [${newlyCrossed.join(", ")}] at ${reading.usedTokens} tokens (trigger=${thresholds.effectiveTriggerTokens}, triggerSource=${thresholds.triggerSource}, autocompactPct=${thresholds.autocompactPct}, urgent=${urgent}).`);
-	return newlyCrossed;
+	state = {
+		...state,
+		pending: {
+			thresholds: newlyCrossed,
+			enqueuedAt: new Date(deps.now()).toISOString()
+		}
+	};
+	deps.saveState(input.sessionId, state);
+	console.error(`[context-handover-trigger] session ${input.sessionId}: enqueued [${newlyCrossed.join(", ")}] at ${reading.usedTokens} tokens (trigger=${thresholds.effectiveTriggerTokens}, triggerSource=${thresholds.triggerSource}, autocompactPct=${thresholds.autocompactPct}, urgent=${urgent}) — awaiting outcome confirmation before marking done.`);
+	return {
+		attempted: newlyCrossed,
+		confirmed: confirmedThisCheck
+	};
 }
 
 //#endregion
@@ -15153,4 +15280,4 @@ claude() {
 
 //#endregion
 export { drainStdio as n, buildProgram as t };
-//# sourceMappingURL=program-BnMNFb4O.mjs.map
+//# sourceMappingURL=program-C-fUghPv.mjs.map