@tekmidian/pai 0.35.2 → 0.36.1

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/hooks/ts/pre-compact/context-compression-hook.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename4, dirname, join as join7 } from "path";
-import { tmpdir } from "os";
+import { existsSync as existsSync9, readFileSync as readFileSync8, 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";
 import { randomUUID } from "crypto";
 
@@ -391,42 +391,14 @@ function renameSessionNote(notePath, meaningfulName) {
   }
 }
 
-// src/hooks/ts/lib/project-utils/tokens.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-function calculateSessionTokens(jsonlPath) {
-  if (!existsSync5(jsonlPath)) return 0;
-  try {
-    const content = readFileSync4(jsonlPath, "utf-8");
-    const lines = content.trim().split("\n");
-    let totalTokens = 0;
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.message?.usage) {
-          const usage = entry.message.usage;
-          totalTokens += usage.input_tokens || 0;
-          totalTokens += usage.output_tokens || 0;
-          totalTokens += usage.cache_creation_input_tokens || 0;
-          totalTokens += usage.cache_read_input_tokens || 0;
-        }
-      } catch {
-      }
-    }
-    return totalTokens;
-  } catch (error) {
-    console.error(`Error calculating tokens: ${error}`);
-    return 0;
-  }
-}
-
 // src/hooks/ts/lib/project-utils/todo.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { join as join6, basename as basename3 } from "path";
 
 // src/session/checkpoint-block.ts
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync5,
+  existsSync as existsSync5,
+  readFileSync as readFileSync4,
   writeFileSync as writeFileSync2,
   readdirSync as readdirSync3,
   renameSync as renameSync2,
@@ -450,9 +422,9 @@ var CONTINUE_HEADING = "## Continue";
 function findProjectTodo(rootPath) {
   for (const rel of TODO_LOCATIONS) {
     const full = join5(rootPath, rel);
-    if (existsSync6(full)) {
+    if (existsSync5(full)) {
       try {
-        return { path: full, content: readFileSync5(full, "utf8") };
+        return { path: full, content: readFileSync4(full, "utf8") };
       } catch {
       }
     }
@@ -465,7 +437,7 @@ function resolveTodoTarget(rootPath, opts = {}) {
   const notesDir = join5(rootPath, "Notes");
   if (opts.create !== false) {
     try {
-      if (!existsSync6(notesDir)) mkdirSync3(notesDir, { recursive: true });
+      if (!existsSync5(notesDir)) mkdirSync3(notesDir, { recursive: true });
     } catch {
       return null;
     }
@@ -762,7 +734,7 @@ function applyContinue(opts) {
     renameSync2(tmpPath, target.path);
   } catch (err) {
     try {
-      if (existsSync6(tmpPath)) renameSync2(tmpPath, `${tmpPath}.dead`);
+      if (existsSync5(tmpPath)) renameSync2(tmpPath, `${tmpPath}.dead`);
     } catch {
     }
     return {
@@ -778,9 +750,9 @@ function applyContinue(opts) {
 // src/hooks/ts/lib/project-utils/todo.ts
 function ensureTodoMd(cwd) {
   const todoPath = findTodoPath(cwd);
-  if (!existsSync7(todoPath)) {
+  if (!existsSync6(todoPath)) {
     const parentDir = join6(todoPath, "..");
-    if (!existsSync7(parentDir)) mkdirSync4(parentDir, { recursive: true });
+    if (!existsSync6(parentDir)) mkdirSync4(parentDir, { recursive: true });
     const content = `# TODO
 
 ## Current Session
@@ -830,7 +802,7 @@ function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
   try {
     const todoPath = result.path;
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    let content = readFileSync6(todoPath, "utf-8");
+    let content = readFileSync5(todoPath, "utf-8");
     content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
     content = content.trimEnd() + `
 
@@ -846,24 +818,154 @@ function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
   );
 }
 
-// src/hooks/ts/pre-compact/context-compression-hook.ts
-var DAEMON_SOCKET = process.env.PAI_SOCKET ?? "/tmp/pai.sock";
-var DAEMON_TIMEOUT_MS = 3e3;
+// src/hooks/ts/lib/context-fill.ts
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir3, tmpdir } from "node:os";
+import { join as join7 } from "node:path";
+var DEFAULT_CONTEXT_WINDOW = 2e5;
+var TRANSCRIPT_TAIL_LINES = 40;
+var STATUSLINE_STALE_MS = 5 * 60 * 1e3;
+function unknownReading(windowSize) {
+  return { status: "unknown", usedTokens: null, windowSize, fraction: null, source: "unknown" };
+}
+function statuslineStateFilePath(sessionId) {
+  return join7(tmpdir(), `pai-context-${sessionId}.json`);
+}
+function readStatuslineFill(sessionId, now = Date.now()) {
+  if (!sessionId) return null;
+  const path = statuslineStateFilePath(sessionId);
+  if (!existsSync7(path)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync6(path, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw.timestamp !== "number" || now - raw.timestamp > STATUSLINE_STALE_MS) {
+    return null;
+  }
+  if (typeof raw.used_percentage !== "number" || typeof raw.context_window_size !== "number") {
+    return null;
+  }
+  const windowSize = raw.context_window_size;
+  const usedTokens = Math.round(raw.used_percentage / 100 * windowSize);
+  return {
+    status: "ok",
+    usedTokens,
+    windowSize,
+    fraction: raw.used_percentage / 100,
+    source: "statusline"
+  };
+}
+function usageTotal(usage) {
+  return (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0) + (usage.cache_creation_input_tokens || 0);
+}
+function contextFillFromTranscript(transcriptPath, windowSize = DEFAULT_CONTEXT_WINDOW) {
+  if (!transcriptPath || !existsSync7(transcriptPath)) return unknownReading(windowSize);
+  let raw;
+  try {
+    raw = readFileSync6(transcriptPath, "utf-8");
+  } catch {
+    return unknownReading(windowSize);
+  }
+  const lines = raw.trim().split("\n").filter((l) => l.trim());
+  const tail = lines.slice(-TRANSCRIPT_TAIL_LINES);
+  for (let i = tail.length - 1; i >= 0; i--) {
+    let entry;
+    try {
+      entry = JSON.parse(tail[i]);
+    } catch {
+      continue;
+    }
+    const usage = entry?.message?.usage;
+    if (usage && typeof usage === "object") {
+      const usedTokens = usageTotal(usage);
+      return {
+        status: "ok",
+        usedTokens,
+        windowSize,
+        fraction: usedTokens / windowSize,
+        source: "transcript"
+      };
+    }
+  }
+  return unknownReading(windowSize);
+}
+function getContextFill(input, now = Date.now()) {
+  const windowSize = input.windowSize ?? DEFAULT_CONTEXT_WINDOW;
+  if (input.sessionId) {
+    const fromStatusline = readStatuslineFill(input.sessionId, now);
+    if (fromStatusline) return fromStatusline;
+  }
+  if (input.transcriptPath) {
+    return contextFillFromTranscript(input.transcriptPath, windowSize);
+  }
+  return unknownReading(windowSize);
+}
+function formatContextFill(reading) {
+  if (reading.status !== "ok" || reading.usedTokens === null) {
+    return { text: "unknown", flagged: false };
+  }
+  let used = reading.usedTokens;
+  let flagged = false;
+  if (used > reading.windowSize) {
+    flagged = true;
+    used = reading.windowSize;
+  }
+  const text = used > 1e3 ? `${Math.round(used / 1e3)}k` : String(used);
+  return { text: flagged ? `${text}+ (clamped \u2014 reading exceeded window)` : text, flagged };
+}
+var CLAUDE_PROJECTS_DIR = join7(homedir3(), ".claude", "projects");
+
+// src/hooks/ts/lib/transcript-text.ts
 function contentToText(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content.map((c) => {
       if (typeof c === "string") return c;
-      if (c?.text) return c.text;
-      if (c?.content) return String(c.content);
+      if (c && typeof c === "object" && c.type === "text" && typeof c.text === "string") {
+        return c.text;
+      }
       return "";
     }).join(" ").trim();
   }
   return "";
 }
+function isNoiseFilePath(filePath, scratchpadDir) {
+  if (scratchpadDir && filePath.startsWith(scratchpadDir)) return true;
+  const segments = filePath.split("/");
+  return segments.includes("tmp") || segments.includes("jobs") || segments.includes("scratchpad");
+}
+function preferCwdFiles(files, cwd) {
+  if (!cwd) return files;
+  const inCwd = files.filter((f) => f.startsWith(cwd));
+  const outCwd = files.filter((f) => !f.startsWith(cwd));
+  return [...inCwd, ...outCwd];
+}
+
+// src/hooks/ts/lib/context-handover-cache.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join8 } from "node:path";
+function contextHandoverCachePath(sessionId) {
+  return join8(tmpdir2(), `pai-context-handover-${sessionId}.json`);
+}
+function readContextHandoverCache(sessionId) {
+  const path = contextHandoverCachePath(sessionId);
+  if (!existsSync8(path)) return null;
+  try {
+    return JSON.parse(readFileSync7(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// 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 = readFileSync7(transcriptPath, "utf-8");
+    const content = readFileSync8(transcriptPath, "utf-8");
     const lines = content.trim().split("\n");
     let userMessages = 0;
     let assistantMessages = 0;
@@ -882,17 +984,18 @@ function getTranscriptStats(transcriptPath) {
     return { messageCount: 0, isLarge: false };
   }
 }
-function parseTranscript(transcriptPath) {
+function parseTranscript(transcriptPath, scratchpadDir) {
   const data = {
     userMessages: [],
     summaries: [],
     captures: [],
     lastCompleted: "",
     filesModified: [],
+    filesExcluded: 0,
     workItems: []
   };
   try {
-    const raw = readFileSync7(transcriptPath, "utf-8");
+    const raw = readFileSync8(transcriptPath, "utf-8");
     const lines = raw.trim().split("\n");
     const seenSummaries = /* @__PURE__ */ new Set();
     for (const line of lines) {
@@ -944,8 +1047,11 @@ function parseTranscript(transcriptPath) {
             if (block.type === "tool_use") {
               const tool = block.name;
               if ((tool === "Edit" || tool === "Write") && block.input?.file_path) {
-                if (!data.filesModified.includes(block.input.file_path)) {
-                  data.filesModified.push(block.input.file_path);
+                const fp = block.input.file_path;
+                if (isNoiseFilePath(fp, scratchpadDir)) {
+                  data.filesExcluded++;
+                } else if (!data.filesModified.includes(fp)) {
+                  data.filesModified.push(fp);
                 }
               }
             }
@@ -978,10 +1084,15 @@ function formatSessionState(data, cwd) {
     parts.push("\nCaptured context:");
     for (const c of recentCaptures) parts.push(`- ${c.slice(0, 150)}`);
   }
-  const files = data.filesModified.slice(-10);
+  const files = preferCwdFiles(data.filesModified, cwd).slice(-10);
   if (files.length > 0) {
     parts.push("\nFiles modified this session:");
     for (const f of files) parts.push(`- ${f}`);
+  } else if (data.filesExcluded > 0) {
+    parts.push(
+      `
+Files modified this session: none in the working directory (excluded ${data.filesExcluded} noise path(s) under tmp/jobs/scratchpad)`
+    );
   }
   if (data.lastCompleted) {
     parts.push(`
@@ -1028,21 +1139,32 @@ function deriveTitle(data) {
 var CUMULATIVE_STATE_FILE = ".compact-state.json";
 function loadCumulativeState(notesDir) {
   try {
-    const filePath = join7(notesDir, CUMULATIVE_STATE_FILE);
-    if (!existsSync8(filePath)) return null;
-    const raw = JSON.parse(readFileSync7(filePath, "utf-8"));
+    const filePath = join9(notesDir, CUMULATIVE_STATE_FILE);
+    if (!existsSync9(filePath)) return null;
+    const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
     return {
       userMessages: raw.userMessages || [],
       summaries: raw.summaries || [],
       captures: raw.captures || [],
       lastCompleted: raw.lastCompleted || "",
       filesModified: raw.filesModified || [],
+      filesExcluded: raw.filesExcluded || 0,
       workItems: raw.workItems || []
     };
   } catch {
     return null;
   }
 }
+function readPreviousCompactionTimestamp(notesDir) {
+  try {
+    const filePath = join9(notesDir, CUMULATIVE_STATE_FILE);
+    if (!existsSync9(filePath)) return null;
+    const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
+    return typeof raw.lastUpdated === "string" ? raw.lastUpdated : null;
+  } catch {
+    return null;
+  }
+}
 function mergeTranscriptData(accumulated, current) {
   if (!accumulated) return current;
   const mergeArrays = (a, b) => {
@@ -1057,13 +1179,14 @@ function mergeTranscriptData(accumulated, current) {
     captures: mergeArrays(accumulated.captures, current.captures),
     lastCompleted: current.lastCompleted || accumulated.lastCompleted,
     filesModified: mergeArrays(accumulated.filesModified, current.filesModified),
+    filesExcluded: accumulated.filesExcluded + current.filesExcluded,
     workItems: [...accumulated.workItems, ...newWorkItems]
   };
 }
 function saveCumulativeState(notesDir, data, notePath) {
   try {
-    const filePath = join7(notesDir, CUMULATIVE_STATE_FILE);
-    writeFileSync4(filePath, JSON.stringify({
+    const filePath = join9(notesDir, CUMULATIVE_STATE_FILE);
+    writeFileSync5(filePath, JSON.stringify({
       ...data,
       notePath,
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
@@ -1198,19 +1321,24 @@ async function main() {
   } catch {
   }
   const compactType = hookInput?.compact_type || hookInput?.trigger || "auto";
-  let tokenCount = 0;
+  let ntfyTokenDisplay = null;
   if (hookInput?.transcript_path) {
     const stats = getTranscriptStats(hookInput.transcript_path);
-    tokenCount = calculateSessionTokens(hookInput.transcript_path);
-    const tokenDisplay = tokenCount > 1e3 ? `${Math.round(tokenCount / 1e3)}k` : String(tokenCount);
-    const data = parseTranscript(hookInput.transcript_path);
+    const fill = getContextFill({
+      sessionId: hookInput.session_id,
+      transcriptPath: hookInput.transcript_path
+    });
+    const tokenDisplay = formatContextFill(fill).text;
+    ntfyTokenDisplay = tokenDisplay;
+    const data = parseTranscript(hookInput.transcript_path, hookInput.scratchpad_dir);
     let notesInfo;
     try {
-      notesInfo = hookInput.cwd ? findNotesDir(hookInput.cwd) : { path: join7(dirname(hookInput.transcript_path), "Notes"), isLocal: false };
+      notesInfo = hookInput.cwd ? findNotesDir(hookInput.cwd) : { path: join9(dirname(hookInput.transcript_path), "Notes"), isLocal: false };
     } catch {
-      notesInfo = { path: join7(dirname(hookInput.transcript_path), "Notes"), isLocal: false };
+      notesInfo = { path: join9(dirname(hookInput.transcript_path), "Notes"), isLocal: false };
     }
     const accumulated = loadCumulativeState(notesInfo.path);
+    const previousCompactionAt = readPreviousCompactionTimestamp(notesInfo.path);
     const merged = mergeTranscriptData(accumulated, data);
     const state = formatSessionState(merged, hookInput.cwd);
     if (accumulated) {
@@ -1224,10 +1352,10 @@ async function main() {
         notePath = createSessionNote(notesInfo.path, "Untitled Session");
       } else {
         try {
-          let noteContent = readFileSync7(notePath, "utf-8");
+          let noteContent = readFileSync8(notePath, "utf-8");
           if (noteContent.includes("**Status:** Completed")) {
             noteContent = noteContent.replace("**Status:** Completed", "**Status:** In Progress");
-            writeFileSync4(notePath, noteContent);
+            writeFileSync5(notePath, noteContent);
             console.error(`Reopened completed note for continued session: ${basename4(notePath)}`);
           }
         } catch {
@@ -1246,12 +1374,12 @@ ${state}` : `Context compression triggered at ~${tokenDisplay} tokens with ${sta
         const newPath = renameSessionNote(notePath, title);
         if (newPath !== notePath) {
           try {
-            let noteContent = readFileSync7(newPath, "utf-8");
+            let noteContent = readFileSync8(newPath, "utf-8");
             noteContent = noteContent.replace(
               /^(# Session \d+:)\s*.*$/m,
               `$1 ${title}`
             );
-            writeFileSync4(newPath, noteContent);
+            writeFileSync5(newPath, noteContent);
             console.error(`Updated note H1 to match rename`);
           } catch {
           }
@@ -1278,12 +1406,31 @@ ${state}` : `Context compression triggered at ~${tokenDisplay} tokens with ${sta
 SESSION NOTE: ${notePath}
 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;
+      try {
+        const cachedHandover = readContextHandoverCache(hookInput.session_id);
+        const handoverIsFresh = cachedHandover !== null && (!previousCompactionAt || new Date(cachedHandover.generatedAt) > new Date(previousCompactionAt));
+        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 ? [
+          "",
+          "--- MODEL-WRITTEN HANDOVER (decisions, reasoning, open threads \u2014 not in the scrape above) ---",
+          cachedHandover.summary,
+          "--- end model-written handover ---"
+        ].join("\n") : "";
+      } catch (err) {
+        console.error(`Failed to resolve handover cache \u2014 falling back to scrape-only: ${err}`);
+        sourceLabel = `mechanical scrape only (error resolving handover cache: ${err})`;
+        handoverBlock = "";
+      }
       const injection = [
         "<system-reminder>",
         `SESSION STATE RECOVERED AFTER COMPACTION (${compactType}, ~${tokenDisplay} tokens)`,
+        `HANDOVER SOURCE: ${sourceLabel}`,
         "",
         stateText,
         noteInfo,
+        handoverBlock,
         "",
         "IMPORTANT: This session state was captured before context compaction.",
         "Use it to maintain continuity. Continue the conversation from where",
@@ -1292,8 +1439,8 @@ rename it based on actual work done and add a rich summary.` : "";
         "</system-reminder>"
       ].join("\n");
       try {
-        const stateFile = join7(tmpdir(), `pai-compact-state-${hookInput.session_id}.txt`);
-        writeFileSync4(stateFile, injection, "utf-8");
+        const stateFile = join9(tmpdir3(), `pai-compact-state-${hookInput.session_id}.txt`);
+        writeFileSync5(stateFile, injection, "utf-8");
         console.error(`Session state saved to ${stateFile} (${injection.length} chars)`);
       } catch (err) {
         console.error(`Failed to save state file: ${err}`);
@@ -1315,7 +1462,7 @@ rename it based on actual work done and add a rich summary.` : "";
     await enqueueRegistryScan();
   } catch {
   }
-  const ntfyMessage = tokenCount > 0 ? `Auto-pause: ~${Math.round(tokenCount / 1e3)}k tokens` : "Context compressing";
+  const ntfyMessage = ntfyTokenDisplay && ntfyTokenDisplay !== "unknown" ? `Auto-pause: ~${ntfyTokenDisplay} tokens` : "Context compressing";
   await sendNtfyNotification(ntfyMessage);
   process.exit(0);
 }