@tekmidian/pai 0.36.2 → 0.38.0

package/dist/{detector--Gg5JRN5.mjs → detector-CMap-9vw.mjs}

@@ -69,4 +69,4 @@ async function detectTopicShift(registryDb, federation, params) {
 
 //#endregion
 export { detectTopicShift as t };
-//# sourceMappingURL=detector--Gg5JRN5.mjs.map
+//# sourceMappingURL=detector-CMap-9vw.mjs.map

package/dist/{detector--Gg5JRN5.mjs.map → detector-CMap-9vw.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"detector--Gg5JRN5.mjs","names":[],"sources":["../src/topics/detector.ts"],"sourcesContent":["/**\n * Topic shift detection engine.\n *\n * Accepts a context summary (recent conversation text) and determines whether\n * the conversation has drifted away from the currently-routed project.\n *\n * Algorithm:\n *   1. Run keyword memory_search against the context text (no project filter)\n *   2. Score results by project — sum of BM25 scores per project\n *   3. Compare the top-scoring project against the current project\n *   4. If a different project dominates by more than the confidence threshold,\n *      report a topic shift.\n *\n * Design decisions:\n *   - Keyword search only (no semantic) — fast, no embedding requirement\n *   - Works with or without an active daemon (direct DB access path)\n *   - Stateless: callers supply currentProject; detector has no session memory\n *   - Minimal: returns a plain result object, not MCP content arrays\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend } from \"../storage/interface.js\";\nimport { searchMemory, populateSlugs } from \"../memory/search.js\";\nimport type { SearchResult } from \"../memory/search.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface TopicCheckParams {\n  /** Recent conversation context (a few sentences or tool call summaries) */\n  context: string;\n  /** The project slug the session is currently routed to. May be null/empty. */\n  currentProject?: string;\n  /**\n   * Minimum confidence [0,1] to declare a shift. Default: 0.6.\n   * Higher = less sensitive, fewer false positives.\n   */\n  threshold?: number;\n  /**\n   * Maximum results to draw from memory search (candidates). Default: 20.\n   * More candidates = more accurate scoring, slightly slower.\n   */\n  candidates?: number;\n}\n\nexport interface TopicCheckResult {\n  /** Whether a significant topic shift was detected. */\n  shifted: boolean;\n  /** The project slug the session is currently routed to (echoed from input). */\n  currentProject: string | null;\n  /** The project slug that best matches the context, or null if no clear match. */\n  suggestedProject: string | null;\n  /**\n   * Confidence score for the suggested project [0,1].\n   * Represents the fraction of total score mass held by the top project.\n   * 1.0 = all matching chunks belong to one project.\n   * 0.5 = two projects are equally matched.\n   */\n  confidence: number;\n  /** Number of memory chunks that contributed to scoring. */\n  chunkCount: number;\n  /** Top-3 scoring projects with their normalised scores (for debugging). */\n  topProjects: Array<{ slug: string; score: number }>;\n}\n\n// ---------------------------------------------------------------------------\n// Core algorithm\n// ---------------------------------------------------------------------------\n\n/**\n * Detect whether the provided context text best matches a different project\n * than the session's current routing.\n *\n * Works with either a raw SQLite Database or a StorageBackend.\n * For the StorageBackend path, keyword search is used.\n * For the raw Database path (legacy/direct), searchMemory() is called.\n */\nexport async function detectTopicShift(\n  registryDb: Database,\n  federation: Database | StorageBackend,\n  params: TopicCheckParams\n): Promise<TopicCheckResult> {\n  const threshold = params.threshold ?? 0.6;\n  const candidates = params.candidates ?? 20;\n  const currentProject = params.currentProject?.trim() || null;\n\n  if (!params.context || params.context.trim().length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // -------------------------------------------------------------------------\n  // Run memory search across ALL projects (no project filter)\n  // -------------------------------------------------------------------------\n\n  let results: SearchResult[];\n\n  const isBackend = (x: Database | StorageBackend): x is StorageBackend =>\n    \"backendType\" in x;\n\n  if (isBackend(federation)) {\n    results = await federation.searchKeyword(params.context, {\n      maxResults: candidates,\n    });\n  } else {\n    results = searchMemory(federation, params.context, {\n      maxResults: candidates,\n    });\n  }\n\n  if (results.length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // Populate project slugs from the registry\n  const withSlugs = populateSlugs(results, registryDb);\n\n  // -------------------------------------------------------------------------\n  // Score projects by summing BM25 scores of matching chunks\n  // -------------------------------------------------------------------------\n\n  const projectScores = new Map<string, number>();\n\n  for (const r of withSlugs) {\n    const slug = r.projectSlug;\n    if (!slug) continue;\n    projectScores.set(slug, (projectScores.get(slug) ?? 0) + r.score);\n  }\n\n  if (projectScores.size === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: withSlugs.length,\n      topProjects: [],\n    };\n  }\n\n  // Sort by total score descending\n  const ranked = Array.from(projectScores.entries())\n    .sort((a, b) => b[1] - a[1]);\n\n  const totalScore = ranked.reduce((sum, [, s]) => sum + s, 0);\n\n  // Top-3 for reporting (normalised to [0,1] fraction of total mass)\n  const topProjects = ranked.slice(0, 3).map(([slug, score]) => ({\n    slug,\n    score: totalScore > 0 ? score / totalScore : 0,\n  }));\n\n  const topSlug = ranked[0][0];\n  const topRawScore = ranked[0][1];\n  const confidence = totalScore > 0 ? topRawScore / totalScore : 0;\n\n  // -------------------------------------------------------------------------\n  // Determine if a shift occurred\n  // -------------------------------------------------------------------------\n\n  // A shift is detected when:\n  //   1. confidence >= threshold (the top project dominates)\n  //   2. The top project is different from currentProject\n  //   3. There is a currentProject to compare against\n  //      (if no current project, we still return the best match but no \"shift\")\n\n  const isDifferent =\n    currentProject !== null &&\n    topSlug !== currentProject;\n\n  const shifted = isDifferent && confidence >= threshold;\n\n  return {\n    shifted,\n    currentProject,\n    suggestedProject: topSlug,\n    confidence,\n    chunkCount: withSlugs.length,\n    topProjects,\n  };\n}\n"],"mappings":";;;;;;;;;;;AA8EA,eAAsB,iBACpB,YACA,YACA,QAC2B;CAC3B,MAAM,YAAY,OAAO,aAAa;CACtC,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,iBAAiB,OAAO,gBAAgB,MAAM,IAAI;AAExD,KAAI,CAAC,OAAO,WAAW,OAAO,QAAQ,MAAM,CAAC,WAAW,EACtD,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAOH,IAAI;CAEJ,MAAM,aAAa,MACjB,iBAAiB;AAEnB,KAAI,UAAU,WAAW,CACvB,WAAU,MAAM,WAAW,cAAc,OAAO,SAAS,EACvD,YAAY,YACb,CAAC;KAEF,WAAU,aAAa,YAAY,OAAO,SAAS,EACjD,YAAY,YACb,CAAC;AAGJ,KAAI,QAAQ,WAAW,EACrB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAIH,MAAM,YAAY,cAAc,SAAS,WAAW;CAMpD,MAAM,gCAAgB,IAAI,KAAqB;AAE/C,MAAK,MAAM,KAAK,WAAW;EACzB,MAAM,OAAO,EAAE;AACf,MAAI,CAAC,KAAM;AACX,gBAAc,IAAI,OAAO,cAAc,IAAI,KAAK,IAAI,KAAK,EAAE,MAAM;;AAGnE,KAAI,cAAc,SAAS,EACzB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY,UAAU;EACtB,aAAa,EAAE;EAChB;CAIH,MAAM,SAAS,MAAM,KAAK,cAAc,SAAS,CAAC,CAC/C,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG;CAE9B,MAAM,aAAa,OAAO,QAAQ,KAAK,GAAG,OAAO,MAAM,GAAG,EAAE;CAG5D,MAAM,cAAc,OAAO,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,YAAY;EAC7D;EACA,OAAO,aAAa,IAAI,QAAQ,aAAa;EAC9C,EAAE;CAEH,MAAM,UAAU,OAAO,GAAG;CAC1B,MAAM,cAAc,OAAO,GAAG;CAC9B,MAAM,aAAa,aAAa,IAAI,cAAc,aAAa;AAkB/D,QAAO;EACL,SANA,mBAAmB,QACnB,YAAY,kBAEiB,cAAc;EAI3C;EACA,kBAAkB;EAClB;EACA,YAAY,UAAU;EACtB;EACD"}
+{"version":3,"file":"detector-CMap-9vw.mjs","names":[],"sources":["../src/topics/detector.ts"],"sourcesContent":["/**\n * Topic shift detection engine.\n *\n * Accepts a context summary (recent conversation text) and determines whether\n * the conversation has drifted away from the currently-routed project.\n *\n * Algorithm:\n *   1. Run keyword memory_search against the context text (no project filter)\n *   2. Score results by project — sum of BM25 scores per project\n *   3. Compare the top-scoring project against the current project\n *   4. If a different project dominates by more than the confidence threshold,\n *      report a topic shift.\n *\n * Design decisions:\n *   - Keyword search only (no semantic) — fast, no embedding requirement\n *   - Works with or without an active daemon (direct DB access path)\n *   - Stateless: callers supply currentProject; detector has no session memory\n *   - Minimal: returns a plain result object, not MCP content arrays\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend } from \"../storage/interface.js\";\nimport { searchMemory, populateSlugs } from \"../memory/search.js\";\nimport type { SearchResult } from \"../memory/search.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface TopicCheckParams {\n  /** Recent conversation context (a few sentences or tool call summaries) */\n  context: string;\n  /** The project slug the session is currently routed to. May be null/empty. */\n  currentProject?: string;\n  /**\n   * Minimum confidence [0,1] to declare a shift. Default: 0.6.\n   * Higher = less sensitive, fewer false positives.\n   */\n  threshold?: number;\n  /**\n   * Maximum results to draw from memory search (candidates). Default: 20.\n   * More candidates = more accurate scoring, slightly slower.\n   */\n  candidates?: number;\n}\n\nexport interface TopicCheckResult {\n  /** Whether a significant topic shift was detected. */\n  shifted: boolean;\n  /** The project slug the session is currently routed to (echoed from input). */\n  currentProject: string | null;\n  /** The project slug that best matches the context, or null if no clear match. */\n  suggestedProject: string | null;\n  /**\n   * Confidence score for the suggested project [0,1].\n   * Represents the fraction of total score mass held by the top project.\n   * 1.0 = all matching chunks belong to one project.\n   * 0.5 = two projects are equally matched.\n   */\n  confidence: number;\n  /** Number of memory chunks that contributed to scoring. */\n  chunkCount: number;\n  /** Top-3 scoring projects with their normalised scores (for debugging). */\n  topProjects: Array<{ slug: string; score: number }>;\n}\n\n// ---------------------------------------------------------------------------\n// Core algorithm\n// ---------------------------------------------------------------------------\n\n/**\n * Detect whether the provided context text best matches a different project\n * than the session's current routing.\n *\n * Works with either a raw SQLite Database or a StorageBackend.\n * For the StorageBackend path, keyword search is used.\n * For the raw Database path (legacy/direct), searchMemory() is called.\n */\nexport async function detectTopicShift(\n  registryDb: Database,\n  federation: Database | StorageBackend,\n  params: TopicCheckParams\n): Promise<TopicCheckResult> {\n  const threshold = params.threshold ?? 0.6;\n  const candidates = params.candidates ?? 20;\n  const currentProject = params.currentProject?.trim() || null;\n\n  if (!params.context || params.context.trim().length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // -------------------------------------------------------------------------\n  // Run memory search across ALL projects (no project filter)\n  // -------------------------------------------------------------------------\n\n  let results: SearchResult[];\n\n  const isBackend = (x: Database | StorageBackend): x is StorageBackend =>\n    \"backendType\" in x;\n\n  if (isBackend(federation)) {\n    results = await federation.searchKeyword(params.context, {\n      maxResults: candidates,\n    });\n  } else {\n    results = searchMemory(federation, params.context, {\n      maxResults: candidates,\n    });\n  }\n\n  if (results.length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // Populate project slugs from the registry\n  const withSlugs = populateSlugs(results, registryDb);\n\n  // -------------------------------------------------------------------------\n  // Score projects by summing BM25 scores of matching chunks\n  // -------------------------------------------------------------------------\n\n  const projectScores = new Map<string, number>();\n\n  for (const r of withSlugs) {\n    const slug = r.projectSlug;\n    if (!slug) continue;\n    projectScores.set(slug, (projectScores.get(slug) ?? 0) + r.score);\n  }\n\n  if (projectScores.size === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: withSlugs.length,\n      topProjects: [],\n    };\n  }\n\n  // Sort by total score descending\n  const ranked = Array.from(projectScores.entries())\n    .sort((a, b) => b[1] - a[1]);\n\n  const totalScore = ranked.reduce((sum, [, s]) => sum + s, 0);\n\n  // Top-3 for reporting (normalised to [0,1] fraction of total mass)\n  const topProjects = ranked.slice(0, 3).map(([slug, score]) => ({\n    slug,\n    score: totalScore > 0 ? score / totalScore : 0,\n  }));\n\n  const topSlug = ranked[0][0];\n  const topRawScore = ranked[0][1];\n  const confidence = totalScore > 0 ? topRawScore / totalScore : 0;\n\n  // -------------------------------------------------------------------------\n  // Determine if a shift occurred\n  // -------------------------------------------------------------------------\n\n  // A shift is detected when:\n  //   1. confidence >= threshold (the top project dominates)\n  //   2. The top project is different from currentProject\n  //   3. There is a currentProject to compare against\n  //      (if no current project, we still return the best match but no \"shift\")\n\n  const isDifferent =\n    currentProject !== null &&\n    topSlug !== currentProject;\n\n  const shifted = isDifferent && confidence >= threshold;\n\n  return {\n    shifted,\n    currentProject,\n    suggestedProject: topSlug,\n    confidence,\n    chunkCount: withSlugs.length,\n    topProjects,\n  };\n}\n"],"mappings":";;;;;;;;;;;AA8EA,eAAsB,iBACpB,YACA,YACA,QAC2B;CAC3B,MAAM,YAAY,OAAO,aAAa;CACtC,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,iBAAiB,OAAO,gBAAgB,MAAM,IAAI;AAExD,KAAI,CAAC,OAAO,WAAW,OAAO,QAAQ,MAAM,CAAC,WAAW,EACtD,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAOH,IAAI;CAEJ,MAAM,aAAa,MACjB,iBAAiB;AAEnB,KAAI,UAAU,WAAW,CACvB,WAAU,MAAM,WAAW,cAAc,OAAO,SAAS,EACvD,YAAY,YACb,CAAC;KAEF,WAAU,aAAa,YAAY,OAAO,SAAS,EACjD,YAAY,YACb,CAAC;AAGJ,KAAI,QAAQ,WAAW,EACrB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAIH,MAAM,YAAY,cAAc,SAAS,WAAW;CAMpD,MAAM,gCAAgB,IAAI,KAAqB;AAE/C,MAAK,MAAM,KAAK,WAAW;EACzB,MAAM,OAAO,EAAE;AACf,MAAI,CAAC,KAAM;AACX,gBAAc,IAAI,OAAO,cAAc,IAAI,KAAK,IAAI,KAAK,EAAE,MAAM;;AAGnE,KAAI,cAAc,SAAS,EACzB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY,UAAU;EACtB,aAAa,EAAE;EAChB;CAIH,MAAM,SAAS,MAAM,KAAK,cAAc,SAAS,CAAC,CAC/C,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG;CAE9B,MAAM,aAAa,OAAO,QAAQ,KAAK,GAAG,OAAO,MAAM,GAAG,EAAE;CAG5D,MAAM,cAAc,OAAO,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,YAAY;EAC7D;EACA,OAAO,aAAa,IAAI,QAAQ,aAAa;EAC9C,EAAE;CAEH,MAAM,UAAU,OAAO,GAAG;CAC1B,MAAM,cAAc,OAAO,GAAG;CAC9B,MAAM,aAAa,aAAa,IAAI,cAAc,aAAa;AAkB/D,QAAO;EACL,SANA,mBAAmB,QACnB,YAAY,kBAEiB,cAAc;EAI3C;EACA,kBAAkB;EAClB;EACA,YAAY,UAAU;EACtB;EACD"}

package/dist/detector-DtLExmHN.mjs

@@ -0,0 +1,5 @@
+import "./embeddings-DOLZnT1X.mjs";
+import "./search-Rpk1cSBC.mjs";
+import { t as detectTopicShift } from "./detector-CMap-9vw.mjs";
+
+export { detectTopicShift };

package/dist/factory-BXzqRYVZ.mjs

@@ -0,0 +1,3 @@
+import { t as createStorageBackend } from "./factory-DD2T33C9.mjs";
+
+export { createStorageBackend };

package/dist/{factory-Bsp7xOpO.mjs → factory-DD2T33C9.mjs}

@@ -56,7 +56,7 @@ async function createStorageBackend(config, opts = {}) {
 * backend on success, or an error string describing why it failed.
 */
 async function attemptPostgres(config) {
-	const { PostgresBackend } = await import("./postgres-BVme6qX0.mjs");
+	const { PostgresBackend } = await import("./postgres--BjPtLa0.mjs");
 	const pgConfig = config.postgres ?? {};
 	let backend = null;
 	try {
@@ -85,7 +85,7 @@ const ESCALATE_AFTER_ATTEMPTS = 5;
 /** Tell the user the backend is down, through whatever channels are configured. */
 async function notifyBackendDown(attempts, lastError) {
 	try {
-		const { routeNotification } = await import("./router-BMkOb62X.mjs");
+		const { routeNotification } = await import("./router-1zi8jiNF.mjs");
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
 		await routeNotification({
 			event: "error",
@@ -97,7 +97,7 @@ async function notifyBackendDown(attempts, lastError) {
 /** And say when it comes back, so the alert is not left hanging. */
 async function notifyBackendRecovered(attempts, since) {
 	try {
-		const { routeNotification } = await import("./router-BMkOb62X.mjs");
+		const { routeNotification } = await import("./router-1zi8jiNF.mjs");
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
 		const mins = since ? Math.max(1, Math.round((Date.now() - since) / 6e4)) : null;
 		await routeNotification({
@@ -141,10 +141,10 @@ async function connectPostgres(config, waitForever) {
 }
 async function createSQLiteBackend() {
 	const { openFederation } = await import("./db-O-cyAPfS.mjs");
-	const { SQLiteBackend } = await import("./sqlite-D1IaR8Am.mjs");
+	const { SQLiteBackend } = await import("./sqlite-DtaL1glm.mjs");
 	return new SQLiteBackend(openFederation());
 }
 
 //#endregion
 export { getBackendOutage as n, humanDuration as r, createStorageBackend as t };
-//# sourceMappingURL=factory-Bsp7xOpO.mjs.map
+//# sourceMappingURL=factory-DD2T33C9.mjs.map

package/dist/{factory-Bsp7xOpO.mjs.map → factory-DD2T33C9.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"factory-Bsp7xOpO.mjs","names":[],"sources":["../src/storage/outage.ts","../src/storage/factory.ts"],"sourcesContent":["/**\n * outage.ts — is the storage backend actually reachable right now?\n *\n * The daemon retries a dead backend forever, which is correct: a Postgres\n * container that is down will usually come back, and giving up would lose the\n * work queue. What was wrong is that it did so in complete silence.\n *\n * Observed 2026-07-26: the container was down for roughly two days. The daemon\n * logged \"Postgres unavailable\" 144 times over 36 minutes, the work queue backed\n * up, session notes for the whole period were never written — and\n * `pai daemon status` reported \"Index: idle\" throughout. The one command anyone\n * would run to check said everything was fine.\n *\n * So the outage is recorded where the status command can see it, and escalated\n * once through the notification channels that were already configured and\n * already unused for this.\n */\n\nexport interface BackendOutage {\n  backend: string;\n  /** When the current run of failures began. */\n  since: number;\n  /** Consecutive failed attempts so far. */\n  attempts: number;\n  lastError: string;\n}\n\nlet current: BackendOutage | null = null;\n\n/** Record that the backend is currently unreachable. */\nexport function setBackendOutage(outage: BackendOutage): void {\n  current = outage;\n}\n\n/**\n * Record that the backend answered.\n *\n * Called on every successful connection, including the first — so a daemon that\n * never had a problem reports none, and one that recovered stops reporting an\n * outage that has ended.\n */\nexport function clearBackendOutage(): void {\n  current = null;\n}\n\n/** The current outage, or null when the backend is answering. */\nexport function getBackendOutage(): BackendOutage | null {\n  return current;\n}\n\n/**\n * Human-readable elapsed time, for a status line rather than a log.\n *\n * Exported because the status command needs the duration on its own, to colour\n * it separately from the rest of the sentence. Without this it kept a second\n * copy of the same rounding, which is how two renderings of one outage drift.\n */\nexport function humanDuration(ms: number): string {\n  const mins = Math.max(1, Math.round(ms / 60_000));\n  return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;\n}\n\n/** Human-readable duration, for a status line rather than a log. */\nexport function describeOutage(o: BackendOutage, now = Date.now()): string {\n  return `${o.backend} unreachable for ${humanDuration(now - o.since)}, ${o.attempts} attempts — ${o.lastError}`;\n}\n","/**\n * Storage backend factory.\n *\n * Reads the daemon config and returns the appropriate StorageBackend.\n *\n * When Postgres is the configured backend we NEVER silently fall back to\n * SQLite — doing so would split the corpus across two databases. Instead:\n *  - Daemon (waitForPostgres: true) retries Postgres forever with capped\n *    backoff until it comes up (handles the boot race where launchd starts\n *    the daemon before Docker Desktop / Postgres is ready).\n *  - CLI / one-shot callers (default) retry a few times, then throw a clear\n *    error rather than returning a wrong/empty SQLite database.\n */\n\nimport type { PaiDaemonConfig } from \"../daemon/config.js\";\nimport type { StorageBackend } from \"./interface.js\";\nimport { setBackendOutage, clearBackendOutage } from \"./outage.js\";\n\nexport interface StorageBackendOptions {\n  /**\n   * When true, retry Postgres indefinitely instead of giving up. Used by the\n   * long-lived daemon so a not-yet-ready Postgres at boot is tolerated.\n   * Defaults to false (one-shot CLI behaviour: bounded retries, then throw).\n   */\n  waitForPostgres?: boolean;\n}\n\n/** Backoff schedule (ms) for the bounded CLI retry path. */\nconst CLI_RETRY_DELAYS_MS = [500, 1_000, 2_000];\n\n/** Backoff cap (ms) for the daemon's infinite retry path. */\nconst DAEMON_RETRY_CAP_MS = 15_000;\n\n/**\n * Create and return the configured StorageBackend.\n *\n * Auto-behaviour:\n *  - storageBackend = \"sqlite\"   → SQLiteBackend always\n *  - storageBackend = \"postgres\" → PostgresBackend (retried; never falls back)\n */\nexport async function createStorageBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<StorageBackend> {\n  if (config.storageBackend === \"postgres\") {\n    return await connectPostgres(config, opts.waitForPostgres ?? false);\n  }\n\n  // Default: SQLite\n  return createSQLiteBackend();\n}\n\n/**\n * Attempt a single Postgres connection (ensure DB + test). Returns the live\n * backend on success, or an error string describing why it failed.\n */\nasync function attemptPostgres(\n  config: PaiDaemonConfig\n): Promise<{ backend: StorageBackend } | { error: string }> {\n  const { PostgresBackend } = await import(\"./postgres.js\");\n  const pgConfig = config.postgres ?? {};\n\n  let backend: InstanceType<typeof PostgresBackend> | null = null;\n  try {\n    // Ensure the per-user database exists and has the schema applied.\n    await PostgresBackend.ensureDatabase(pgConfig);\n\n    backend = new PostgresBackend(pgConfig);\n    const err = await backend.testConnection();\n    if (err) {\n      await backend.close().catch(() => {});\n      return { error: err };\n    }\n    return { backend };\n  } catch (e) {\n    if (backend) await backend.close().catch(() => {});\n    return { error: e instanceof Error ? e.message : String(e) };\n  }\n}\n\n/**\n * Consecutive failures before the outage is escalated to the user.\n *\n * Not the first failure: a container restarting, or the daemon starting before\n * Docker is up, recovers within a few seconds and is not worth a notification.\n * By the fifth attempt the backoff has already spent tens of seconds, which is\n * long enough that something is actually wrong.\n */\nconst ESCALATE_AFTER_ATTEMPTS = 5;\n\n/** Tell the user the backend is down, through whatever channels are configured. */\nasync function notifyBackendDown(attempts: number, lastError: string): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    await routeNotification(\n      {\n        event: \"error\",\n        title: \"PAI: storage backend unreachable\",\n        message:\n          `Postgres has not answered in ${attempts} attempts (${lastError}). ` +\n          `Indexing, session notes and the work queue are stalled until it returns. ` +\n          `Check the container, then \\`pai daemon status\\`.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    // A notification that cannot be sent must never take the daemon down with\n    // it — the daemon retrying is still the useful behaviour here.\n  }\n}\n\n/** And say when it comes back, so the alert is not left hanging. */\nasync function notifyBackendRecovered(\n  attempts: number,\n  since: number | null\n): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    const mins = since ? Math.max(1, Math.round((Date.now() - since) / 60_000)) : null;\n    await routeNotification(\n      {\n        event: \"completion\",\n        title: \"PAI: storage backend back\",\n        message:\n          `Postgres answered after ${attempts} attempts` +\n          (mins ? `, ${mins} min down` : \"\") +\n          `. The queue will drain on its own.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    /* same reasoning as above */\n  }\n}\n\nasync function connectPostgres(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  let attempt = 0;\n  let lastError = \"unknown error\";\n  let outageSince: number | null = null;\n  let escalated = false;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    attempt++;\n    const result = await attemptPostgres(config);\n    if (\"backend\" in result) {\n      if (attempt > 1) {\n        process.stderr.write(\n          `[pai-daemon] Connected to PostgreSQL backend (after ${attempt} attempts).\\n`\n        );\n      } else {\n        process.stderr.write(\"[pai-daemon] Connected to PostgreSQL backend.\\n\");\n      }\n      // An outage that ended must stop being reported, or the status command\n      // trades one wrong answer for another.\n      clearBackendOutage();\n      if (escalated) void notifyBackendRecovered(attempt, outageSince);\n      return result.backend;\n    }\n\n    lastError = result.error;\n\n    if (!waitForever && attempt > CLI_RETRY_DELAYS_MS.length) {\n      // Bounded CLI path exhausted — fail loudly, never silently use SQLite.\n      throw new Error(\n        `Postgres backend unreachable after ${attempt} attempts: ${lastError}. ` +\n          `Is Docker Desktop / Postgres running? Refusing to fall back to SQLite ` +\n          `(would split the corpus). Start Postgres and retry.`\n      );\n    }\n\n    const delayMs = waitForever\n      ? Math.min(DAEMON_RETRY_CAP_MS, 1_000 * 2 ** Math.min(attempt - 1, 4))\n      : CLI_RETRY_DELAYS_MS[attempt - 1];\n\n    process.stderr.write(\n      `[pai-daemon] Postgres unavailable (${lastError}). ` +\n        `Retry ${attempt}${waitForever ? \"\" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} ` +\n        `in ${delayMs}ms...\\n`\n    );\n\n    // Publish the outage so `pai daemon status` can report it. Without this the\n    // daemon retries silently forever and status still reads \"idle\" — which is\n    // what happened for two days in July: 144 retries over 36 minutes, session\n    // notes never written, and the one command anyone would run to check\n    // reporting that everything was fine.\n    setBackendOutage({\n      backend: \"postgres\",\n      since: outageSince ?? (outageSince = Date.now()),\n      attempts: attempt,\n      lastError: String(lastError),\n    });\n\n    // And escalate once, out loud, rather than only into a log nobody tails.\n    // Once — not per retry — because a notification that repeats every few\n    // seconds is filtered within a minute and stops being a signal at all.\n    if (waitForever && attempt === ESCALATE_AFTER_ATTEMPTS && !escalated) {\n      escalated = true;\n      void notifyBackendDown(attempt, String(lastError));\n    }\n\n    await new Promise((r) => setTimeout(r, delayMs));\n  }\n}\n\nasync function createSQLiteBackend(): Promise<StorageBackend> {\n  const { openFederation } = await import(\"../memory/db.js\");\n  const { SQLiteBackend } = await import(\"./sqlite.js\");\n  const db = openFederation();\n  return new SQLiteBackend(db);\n}\n"],"mappings":"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"}
+{"version":3,"file":"factory-DD2T33C9.mjs","names":[],"sources":["../src/storage/outage.ts","../src/storage/factory.ts"],"sourcesContent":["/**\n * outage.ts — is the storage backend actually reachable right now?\n *\n * The daemon retries a dead backend forever, which is correct: a Postgres\n * container that is down will usually come back, and giving up would lose the\n * work queue. What was wrong is that it did so in complete silence.\n *\n * Observed 2026-07-26: the container was down for roughly two days. The daemon\n * logged \"Postgres unavailable\" 144 times over 36 minutes, the work queue backed\n * up, session notes for the whole period were never written — and\n * `pai daemon status` reported \"Index: idle\" throughout. The one command anyone\n * would run to check said everything was fine.\n *\n * So the outage is recorded where the status command can see it, and escalated\n * once through the notification channels that were already configured and\n * already unused for this.\n */\n\nexport interface BackendOutage {\n  backend: string;\n  /** When the current run of failures began. */\n  since: number;\n  /** Consecutive failed attempts so far. */\n  attempts: number;\n  lastError: string;\n}\n\nlet current: BackendOutage | null = null;\n\n/** Record that the backend is currently unreachable. */\nexport function setBackendOutage(outage: BackendOutage): void {\n  current = outage;\n}\n\n/**\n * Record that the backend answered.\n *\n * Called on every successful connection, including the first — so a daemon that\n * never had a problem reports none, and one that recovered stops reporting an\n * outage that has ended.\n */\nexport function clearBackendOutage(): void {\n  current = null;\n}\n\n/** The current outage, or null when the backend is answering. */\nexport function getBackendOutage(): BackendOutage | null {\n  return current;\n}\n\n/**\n * Human-readable elapsed time, for a status line rather than a log.\n *\n * Exported because the status command needs the duration on its own, to colour\n * it separately from the rest of the sentence. Without this it kept a second\n * copy of the same rounding, which is how two renderings of one outage drift.\n */\nexport function humanDuration(ms: number): string {\n  const mins = Math.max(1, Math.round(ms / 60_000));\n  return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;\n}\n\n/** Human-readable duration, for a status line rather than a log. */\nexport function describeOutage(o: BackendOutage, now = Date.now()): string {\n  return `${o.backend} unreachable for ${humanDuration(now - o.since)}, ${o.attempts} attempts — ${o.lastError}`;\n}\n","/**\n * Storage backend factory.\n *\n * Reads the daemon config and returns the appropriate StorageBackend.\n *\n * When Postgres is the configured backend we NEVER silently fall back to\n * SQLite — doing so would split the corpus across two databases. Instead:\n *  - Daemon (waitForPostgres: true) retries Postgres forever with capped\n *    backoff until it comes up (handles the boot race where launchd starts\n *    the daemon before Docker Desktop / Postgres is ready).\n *  - CLI / one-shot callers (default) retry a few times, then throw a clear\n *    error rather than returning a wrong/empty SQLite database.\n */\n\nimport type { PaiDaemonConfig } from \"../daemon/config.js\";\nimport type { StorageBackend } from \"./interface.js\";\nimport { setBackendOutage, clearBackendOutage } from \"./outage.js\";\n\nexport interface StorageBackendOptions {\n  /**\n   * When true, retry Postgres indefinitely instead of giving up. Used by the\n   * long-lived daemon so a not-yet-ready Postgres at boot is tolerated.\n   * Defaults to false (one-shot CLI behaviour: bounded retries, then throw).\n   */\n  waitForPostgres?: boolean;\n}\n\n/** Backoff schedule (ms) for the bounded CLI retry path. */\nconst CLI_RETRY_DELAYS_MS = [500, 1_000, 2_000];\n\n/** Backoff cap (ms) for the daemon's infinite retry path. */\nconst DAEMON_RETRY_CAP_MS = 15_000;\n\n/**\n * Create and return the configured StorageBackend.\n *\n * Auto-behaviour:\n *  - storageBackend = \"sqlite\"   → SQLiteBackend always\n *  - storageBackend = \"postgres\" → PostgresBackend (retried; never falls back)\n */\nexport async function createStorageBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<StorageBackend> {\n  if (config.storageBackend === \"postgres\") {\n    return await connectPostgres(config, opts.waitForPostgres ?? false);\n  }\n\n  // Default: SQLite\n  return createSQLiteBackend();\n}\n\n/**\n * Attempt a single Postgres connection (ensure DB + test). Returns the live\n * backend on success, or an error string describing why it failed.\n */\nasync function attemptPostgres(\n  config: PaiDaemonConfig\n): Promise<{ backend: StorageBackend } | { error: string }> {\n  const { PostgresBackend } = await import(\"./postgres.js\");\n  const pgConfig = config.postgres ?? {};\n\n  let backend: InstanceType<typeof PostgresBackend> | null = null;\n  try {\n    // Ensure the per-user database exists and has the schema applied.\n    await PostgresBackend.ensureDatabase(pgConfig);\n\n    backend = new PostgresBackend(pgConfig);\n    const err = await backend.testConnection();\n    if (err) {\n      await backend.close().catch(() => {});\n      return { error: err };\n    }\n    return { backend };\n  } catch (e) {\n    if (backend) await backend.close().catch(() => {});\n    return { error: e instanceof Error ? e.message : String(e) };\n  }\n}\n\n/**\n * Consecutive failures before the outage is escalated to the user.\n *\n * Not the first failure: a container restarting, or the daemon starting before\n * Docker is up, recovers within a few seconds and is not worth a notification.\n * By the fifth attempt the backoff has already spent tens of seconds, which is\n * long enough that something is actually wrong.\n */\nconst ESCALATE_AFTER_ATTEMPTS = 5;\n\n/** Tell the user the backend is down, through whatever channels are configured. */\nasync function notifyBackendDown(attempts: number, lastError: string): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    await routeNotification(\n      {\n        event: \"error\",\n        title: \"PAI: storage backend unreachable\",\n        message:\n          `Postgres has not answered in ${attempts} attempts (${lastError}). ` +\n          `Indexing, session notes and the work queue are stalled until it returns. ` +\n          `Check the container, then \\`pai daemon status\\`.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    // A notification that cannot be sent must never take the daemon down with\n    // it — the daemon retrying is still the useful behaviour here.\n  }\n}\n\n/** And say when it comes back, so the alert is not left hanging. */\nasync function notifyBackendRecovered(\n  attempts: number,\n  since: number | null\n): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    const mins = since ? Math.max(1, Math.round((Date.now() - since) / 60_000)) : null;\n    await routeNotification(\n      {\n        event: \"completion\",\n        title: \"PAI: storage backend back\",\n        message:\n          `Postgres answered after ${attempts} attempts` +\n          (mins ? `, ${mins} min down` : \"\") +\n          `. The queue will drain on its own.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    /* same reasoning as above */\n  }\n}\n\nasync function connectPostgres(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  let attempt = 0;\n  let lastError = \"unknown error\";\n  let outageSince: number | null = null;\n  let escalated = false;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    attempt++;\n    const result = await attemptPostgres(config);\n    if (\"backend\" in result) {\n      if (attempt > 1) {\n        process.stderr.write(\n          `[pai-daemon] Connected to PostgreSQL backend (after ${attempt} attempts).\\n`\n        );\n      } else {\n        process.stderr.write(\"[pai-daemon] Connected to PostgreSQL backend.\\n\");\n      }\n      // An outage that ended must stop being reported, or the status command\n      // trades one wrong answer for another.\n      clearBackendOutage();\n      if (escalated) void notifyBackendRecovered(attempt, outageSince);\n      return result.backend;\n    }\n\n    lastError = result.error;\n\n    if (!waitForever && attempt > CLI_RETRY_DELAYS_MS.length) {\n      // Bounded CLI path exhausted — fail loudly, never silently use SQLite.\n      throw new Error(\n        `Postgres backend unreachable after ${attempt} attempts: ${lastError}. ` +\n          `Is Docker Desktop / Postgres running? Refusing to fall back to SQLite ` +\n          `(would split the corpus). Start Postgres and retry.`\n      );\n    }\n\n    const delayMs = waitForever\n      ? Math.min(DAEMON_RETRY_CAP_MS, 1_000 * 2 ** Math.min(attempt - 1, 4))\n      : CLI_RETRY_DELAYS_MS[attempt - 1];\n\n    process.stderr.write(\n      `[pai-daemon] Postgres unavailable (${lastError}). ` +\n        `Retry ${attempt}${waitForever ? \"\" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} ` +\n        `in ${delayMs}ms...\\n`\n    );\n\n    // Publish the outage so `pai daemon status` can report it. Without this the\n    // daemon retries silently forever and status still reads \"idle\" — which is\n    // what happened for two days in July: 144 retries over 36 minutes, session\n    // notes never written, and the one command anyone would run to check\n    // reporting that everything was fine.\n    setBackendOutage({\n      backend: \"postgres\",\n      since: outageSince ?? (outageSince = Date.now()),\n      attempts: attempt,\n      lastError: String(lastError),\n    });\n\n    // And escalate once, out loud, rather than only into a log nobody tails.\n    // Once — not per retry — because a notification that repeats every few\n    // seconds is filtered within a minute and stops being a signal at all.\n    if (waitForever && attempt === ESCALATE_AFTER_ATTEMPTS && !escalated) {\n      escalated = true;\n      void notifyBackendDown(attempt, String(lastError));\n    }\n\n    await new Promise((r) => setTimeout(r, delayMs));\n  }\n}\n\nasync function createSQLiteBackend(): Promise<StorageBackend> {\n  const { openFederation } = await import(\"../memory/db.js\");\n  const { SQLiteBackend } = await import(\"./sqlite.js\");\n  const db = openFederation();\n  return new SQLiteBackend(db);\n}\n"],"mappings":"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"}

package/dist/hooks/context-compression-hook.mjs

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
 
+// src/hooks/ts/lib/worker-session.ts
+function isWorkerSession(env = process.env) {
+  return env.PAI_WORKER === "1";
+}
+
 // src/hooks/ts/pre-compact/context-compression-hook.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
 import { basename as basename4, dirname, join as join9 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { connect } from "net";
@@ -164,7 +169,7 @@ async function sendNtfyNotification(message, retries = 2) {
       console.error(`ntfy.sh attempt ${attempt + 1} error: ${error}`);
     }
     if (attempt < retries) {
-      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     }
   }
   console.error("ntfy.sh notification failed after all retries");
@@ -960,12 +965,145 @@ function readContextHandoverCache(sessionId) {
   }
 }
 
+// src/hooks/ts/lib/handover-evidence.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+var MIN_TOKEN_LENGTH = 4;
+var FOOTER_NAMED_MISSING = 5;
+var ECHO_HEAD_LENGTH = 80;
+var INJECTED_MARKERS = [
+  "HANDOVER FROM THE PREVIOUS SESSION",
+  "MODEL-WRITTEN HANDOVER",
+  "SESSION STATE RECOVERED AFTER COMPACTION"
+];
+var HANDOVER_WRITERS = /* @__PURE__ */ new Set(["Write", "Edit", "NotebookEdit"]);
+var TOKEN_PATTERNS = [
+  // git hashes: 7-40 hex chars with at least one letter (a plain number is not a hash)
+  /\b(?=[0-9a-f]*[a-f])[0-9a-f]{7,40}\b/g,
+  // package@version
+  /(?:@[\w.-]+\/)?[\w.-]+@\d+\.\d+\.\d+(?:-[\w.]+)?/g,
+  // semver
+  /\bv?\d+\.\d+\.\d+(?:-[\w.]+)?\b/g,
+  // absolute paths (two or more segments)
+  /(?:^|[\s(`'"])(\/[\w.-]+(?:\/[\w.-]+)+)/gm,
+  // relative paths with a slash and an extension
+  /(?:^|[\s(`'"])((?:~\/|\.\.?\/)?[\w.-]+(?:\/[\w.-]+)+\.[a-z0-9]{1,5})\b/gm,
+  // process ids
+  /\bpid\s*[:=#]?\s*(\d{3,7})\b/gi,
+  // ISO dates and timestamps
+  /\b\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?Z?)?\b/g,
+  // numbers with units — digits only are kept
+  /\b(\d[\d,]*)\s*(?:tokens?|ms|MB|GB)\b/g
+];
+function normalise(text) {
+  return text.replace(/(\d),(?=\d{3}\b)/g, "$1");
+}
+function stripSystemReminders(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "");
+}
+function extractCheckableTokens(markdown) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const pattern of TOKEN_PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of markdown.matchAll(pattern)) {
+      const raw = (match[1] ?? match[0]).trim();
+      const token = normalise(raw);
+      if (token.length < MIN_TOKEN_LENGTH || seen.has(token)) continue;
+      seen.add(token);
+      out.push(token);
+    }
+  }
+  return out;
+}
+function buildHaystack(transcriptPaths, handoverPath, handoverHead) {
+  const parts = [];
+  const resolvedHandover = handoverPath ? resolve2(handoverPath) : null;
+  const pushUserText = (text) => {
+    if (INJECTED_MARKERS.some((m) => text.includes(m))) return;
+    parts.push(stripSystemReminders(text));
+  };
+  for (const path of transcriptPaths) {
+    let raw;
+    try {
+      raw = readFileSync8(path, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const content = entry.message?.content;
+      if (content === void 0) continue;
+      if (entry.type === "user") {
+        if (typeof content === "string") {
+          pushUserText(content);
+          continue;
+        }
+        if (!Array.isArray(content)) continue;
+        for (const part of content) {
+          if (part?.type === "text" && typeof part.text === "string") pushUserText(part.text);
+          else if (part?.type === "tool_result") {
+            const text = contentToText(part.content);
+            if (handoverHead && text.startsWith(handoverHead)) continue;
+            parts.push(text);
+          }
+        }
+      } else if (entry.type === "assistant" && Array.isArray(content)) {
+        for (const part of content) {
+          if (part?.type === "text" && typeof part.text === "string") parts.push(part.text);
+          else if (part?.type === "tool_use") {
+            const target = part.input?.file_path;
+            if (resolvedHandover && HANDOVER_WRITERS.has(part.name ?? "") && typeof target === "string" && resolve2(target) === resolvedHandover) {
+              continue;
+            }
+            parts.push(JSON.stringify(part.input ?? {}));
+          }
+        }
+      }
+    }
+  }
+  return normalise(parts.join("\n"));
+}
+function footerFor(found, missing) {
+  const total = found.length + missing.length;
+  if (total === 0) return "Evidence: no checkable identifiers";
+  let footer = `Evidence: ${found.length}/${total} identifiers found in the transcript`;
+  if (missing.length > 0) {
+    const named = missing.slice(0, FOOTER_NAMED_MISSING).join(", ");
+    const more = missing.length - FOOTER_NAMED_MISSING;
+    footer += `; unverified: ${named}${more > 0 ? ` +${more} more` : ""}`;
+  }
+  return footer;
+}
+function bindHandoverEvidence(handoverMarkdown, handoverPath, transcriptPaths) {
+  try {
+    const tokens = extractCheckableTokens(handoverMarkdown);
+    if (tokens.length === 0) {
+      return { total: 0, found: [], missing: [], footer: footerFor([], []) };
+    }
+    const head = handoverMarkdown.trim().slice(0, ECHO_HEAD_LENGTH);
+    const haystack = buildHaystack(transcriptPaths, handoverPath, head);
+    const found = [];
+    const missing = [];
+    for (const token of tokens) (haystack.includes(token) ? found : missing).push(token);
+    return { total: tokens.length, found, missing, footer: footerFor(found, missing) };
+  } catch {
+    return { total: 0, found: [], missing: [], footer: "Evidence: check unavailable" };
+  }
+}
+
 // src/hooks/ts/pre-compact/context-compression-hook.ts
 var DAEMON_SOCKET = process.env.PAI_SOCKET ?? "/tmp/pai.sock";
 var DAEMON_TIMEOUT_MS = 3e3;
 function getTranscriptStats(transcriptPath) {
   try {
-    const content = readFileSync8(transcriptPath, "utf-8");
+    const content = readFileSync9(transcriptPath, "utf-8");
     const lines = content.trim().split("\n");
     let userMessages = 0;
     let assistantMessages = 0;
@@ -995,7 +1133,7 @@ function parseTranscript(transcriptPath, scratchpadDir) {
     workItems: []
   };
   try {
-    const raw = readFileSync8(transcriptPath, "utf-8");
+    const raw = readFileSync9(transcriptPath, "utf-8");
     const lines = raw.trim().split("\n");
     const seenSummaries = /* @__PURE__ */ new Set();
     for (const line of lines) {
@@ -1141,7 +1279,7 @@ function loadCumulativeState(notesDir) {
   try {
     const filePath = join9(notesDir, CUMULATIVE_STATE_FILE);
     if (!existsSync9(filePath)) return null;
-    const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync9(filePath, "utf-8"));
     return {
       userMessages: raw.userMessages || [],
       summaries: raw.summaries || [],
@@ -1159,7 +1297,7 @@ function readPreviousCompactionTimestamp(notesDir) {
   try {
     const filePath = join9(notesDir, CUMULATIVE_STATE_FILE);
     if (!existsSync9(filePath)) return null;
-    const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync9(filePath, "utf-8"));
     return typeof raw.lastUpdated === "string" ? raw.lastUpdated : null;
   } catch {
     return null;
@@ -1197,7 +1335,7 @@ function saveCumulativeState(notesDir, data, notePath) {
   }
 }
 function enqueueRegistryScan() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let done = false;
     let timer = null;
     function finish() {
@@ -1211,7 +1349,7 @@ function enqueueRegistryScan() {
         client.destroy();
       } catch {
       }
-      resolve2();
+      resolve3();
     }
     const client = connect(DAEMON_SOCKET, () => {
       const msg = JSON.stringify({
@@ -1232,7 +1370,7 @@ function enqueueRegistryScan() {
   });
 }
 function enqueueSessionSummary(payload) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let done = false;
     let buffer = "";
     let timer = null;
@@ -1247,7 +1385,7 @@ function enqueueSessionSummary(payload) {
         client.destroy();
       } catch {
       }
-      resolve2(ok);
+      resolve3(ok);
     }
     const client = connect(DAEMON_SOCKET, () => {
       const msg = JSON.stringify({
@@ -1299,6 +1437,7 @@ function enqueueSessionSummary(payload) {
   });
 }
 async function main() {
+  if (isWorkerSession()) return;
   if (isProbeSession()) {
     process.exit(0);
   }
@@ -1306,8 +1445,8 @@ async function main() {
   try {
     const decoder = new TextDecoder();
     let input = "";
-    const timeoutPromise = new Promise((resolve2) => {
-      setTimeout(resolve2, 500);
+    const timeoutPromise = new Promise((resolve3) => {
+      setTimeout(resolve3, 500);
     });
     const readPromise = (async () => {
       for await (const chunk of process.stdin) {
@@ -1352,7 +1491,7 @@ async function main() {
         notePath = createSessionNote(notesInfo.path, "Untitled Session");
       } else {
         try {
-          let noteContent = readFileSync8(notePath, "utf-8");
+          let noteContent = readFileSync9(notePath, "utf-8");
           if (noteContent.includes("**Status:** Completed")) {
             noteContent = noteContent.replace("**Status:** Completed", "**Status:** In Progress");
             writeFileSync5(notePath, noteContent);
@@ -1374,7 +1513,7 @@ ${state}` : `Context compression triggered at ~${tokenDisplay} tokens with ${sta
         const newPath = renameSessionNote(notePath, title);
         if (newPath !== notePath) {
           try {
-            let noteContent = readFileSync8(newPath, "utf-8");
+            let noteContent = readFileSync9(newPath, "utf-8");
             noteContent = noteContent.replace(
               /^(# Session \d+:)\s*.*$/m,
               `$1 ${title}`
@@ -1408,9 +1547,11 @@ If this note still has a generic title (e.g. "New Session", "Context Compression
 rename it based on actual work done and add a rich summary.` : "";
       let sourceLabel;
       let handoverBlock;
+      let handoverSummary = null;
       try {
         const cachedHandover = readContextHandoverCache(hookInput.session_id);
         const handoverIsFresh = cachedHandover !== null && (!previousCompactionAt || new Date(cachedHandover.generatedAt) > new Date(previousCompactionAt));
+        handoverSummary = handoverIsFresh ? cachedHandover.summary : null;
         sourceLabel = handoverIsFresh ? `model-written handover (${cachedHandover.model}, generated ${cachedHandover.generatedAt}, threshold=${cachedHandover.threshold}) + mechanical scrape` : "mechanical scrape only (no fresh model-written handover was available)";
         handoverBlock = handoverIsFresh ? [
           "",
@@ -1423,6 +1564,15 @@ rename it based on actual work done and add a rich summary.` : "";
         sourceLabel = `mechanical scrape only (error resolving handover cache: ${err})`;
         handoverBlock = "";
       }
+      if (handoverSummary !== null && typeof hookInput.transcript_path === "string") {
+        try {
+          const evidence = bindHandoverEvidence(handoverSummary, null, [hookInput.transcript_path]);
+          handoverBlock += `
+${evidence.footer}`;
+        } catch (err) {
+          console.error(`Evidence check skipped: ${err}`);
+        }
+      }
       const injection = [
         "<system-reminder>",
         `SESSION STATE RECOVERED AFTER COMPACTION (${compactType}, ~${tokenDisplay} tokens)`,