@tekmidian/pai 0.42.5 → 0.43.0

package/dist/hooks/load-project-context.mjs

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { createRequire as __paiCreateRequire } from 'node:module';
+const require = __paiCreateRequire(import.meta.url);
+if (!process.env.PAI_QUIET_NOTICES) process.env.PAI_QUIET_NOTICES = '1';
 
 // src/hooks/ts/lib/worker-session.ts
 function isWorkerSession(env = process.env) {
@@ -6,65 +9,98 @@ function isWorkerSession(env = process.env) {
 }
 
 // src/hooks/ts/session-start/load-project-context.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { join as join6, basename as basename4, dirname, resolve as resolve2 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join7, basename as basename4, dirname as dirname2, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
 import { execSync } from "child_process";
 
 // src/memory/wakeup.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, basename } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { join as join2, basename } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/config/pai-home.ts
+import { existsSync, mkdirSync, readFileSync, copyFileSync, renameSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-var L1_TOKEN_BUDGET = 800;
+import { join, dirname } from "node:path";
+function paiHomeDir() {
+  return process.env.PAI_HOME || join(homedir(), ".claude", "pai");
+}
+function paiHomePath(...segments) {
+  return join(paiHomeDir(), ...segments);
+}
+var noticesPrinted = /* @__PURE__ */ new Set();
+function resolvePaiFile(newPath, oldCandidates, migrateHint) {
+  if (existsSync(newPath)) return newPath;
+  for (const old of oldCandidates) {
+    if (existsSync(old)) {
+      if (!noticesPrinted.has(newPath)) {
+        noticesPrinted.add(newPath);
+        process.stderr.write(
+          `pai: ${old} is at an old location \u2014 run \`${migrateHint}\` to move it to ${newPath}
+`
+        );
+      }
+      return old;
+    }
+  }
+  return newPath;
+}
+
+// src/memory/wakeup.ts
+var L1_TOKEN_BUDGET = 300;
 var L1_CHAR_BUDGET = L1_TOKEN_BUDGET * 4;
-var L1_MAX_NOTES = 10;
+var L1_MAX_NOTES = 3;
 var EXTRACT_SECTIONS = [
   "Work Done",
   "Key Decisions",
   "Next Steps",
   "Checkpoint"
 ];
-var IDENTITY_FILE = join(homedir(), ".pai", "identity.txt");
-function loadL0Identity() {
-  if (!existsSync(IDENTITY_FILE)) return "";
+var IDENTITY_FILE = join2(homedir2(), ".pai", "identity.txt");
+function loadL0Identity(opts = {}) {
+  const newPath = opts.newPath ?? paiHomePath("identity.txt");
+  const legacyPath = opts.legacyPath ?? IDENTITY_FILE;
+  const path = existsSync2(newPath) ? newPath : legacyPath;
+  if (!existsSync2(path)) return "";
   try {
-    return readFileSync(IDENTITY_FILE, "utf-8").trim();
+    return readFileSync2(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function findNotesDirForProject(rootPath) {
   const localCandidates = [
-    join(rootPath, "Notes"),
-    join(rootPath, "notes"),
-    join(rootPath, ".claude", "Notes")
+    join2(rootPath, "Notes"),
+    join2(rootPath, "notes"),
+    join2(rootPath, ".claude", "Notes")
   ];
   for (const p of localCandidates) {
-    if (existsSync(p)) return p;
+    if (existsSync2(p)) return p;
   }
   const encoded = rootPath.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
-  const centralNotes = join(
-    homedir(),
+  const centralNotes = join2(
+    homedir2(),
     ".claude",
     "projects",
     encoded,
     "Notes"
   );
-  if (existsSync(centralNotes)) return centralNotes;
+  if (existsSync2(centralNotes)) return centralNotes;
   return null;
 }
 function findSessionNotes(notesDir) {
   const result = [];
   const scanDir = (dir) => {
-    if (!existsSync(dir)) return;
+    if (!existsSync2(dir)) return;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true }).map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+      entries = readdirSync2(dir, { withFileTypes: true }).map((e) => ({ name: e.name, isDir: e.isDirectory() }));
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
+      const fullPath = join2(dir, entry.name);
       if (entry.isDir) {
         scanDir(fullPath);
       } else if (entry.name.match(/^\d{3,4}[\s_-].*\.md$/)) {
@@ -77,7 +113,7 @@ function findSessionNotes(notesDir) {
   const numberOf = (p) => parseInt(basename(p).match(/^(\d+)/)?.[1] ?? "0", 10);
   const mtimeOf = (p) => {
     try {
-      return statSync(p).mtimeMs;
+      return statSync2(p).mtimeMs;
     } catch {
       return 0;
     }
@@ -96,7 +132,10 @@ function findSessionNotes(notesDir) {
   });
   return result;
 }
-function extractKeyLines(content, maxChars) {
+function normalizeLine(line) {
+  return line.replace(/^(- \[[ x]\] |- |\* |\d+\.\s)/, "").trim().replace(/\s+/g, " ");
+}
+function extractKeyLines(content, maxChars, seen = /* @__PURE__ */ new Set()) {
   const lines = content.split("\n");
   const selected = [];
   let inTargetSection = false;
@@ -126,7 +165,10 @@ function extractKeyLines(content, maxChars) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("<!--") || trimmed === "---") continue;
     if (trimmed.startsWith("- ") || trimmed.startsWith("* ") || trimmed.match(/^\d+\./) || trimmed.startsWith("**")) {
+      const normalized = normalizeLine(trimmed);
+      if (seen.has(normalized)) continue;
       if (charCount + trimmed.length + 1 > maxChars) break;
+      seen.add(normalized);
       selected.push(trimmed);
       charCount += trimmed.length + 1;
     }
@@ -140,12 +182,13 @@ function buildL1EssentialStory(rootPath, tokenBudget = L1_TOKEN_BUDGET) {
   const noteFiles = findSessionNotes(notesDir).slice(0, L1_MAX_NOTES);
   if (noteFiles.length === 0) return "";
   const sections = [];
+  const seen = /* @__PURE__ */ new Set();
   let remaining = charBudget;
   for (const noteFile of noteFiles) {
     if (remaining <= 50) break;
     let content;
     try {
-      content = readFileSync(noteFile, "utf-8");
+      content = readFileSync2(noteFile, "utf-8");
     } catch {
       continue;
     }
@@ -154,7 +197,7 @@ function buildL1EssentialStory(rootPath, tokenBudget = L1_TOKEN_BUDGET) {
     const dateLabel = titleMatch ? titleMatch[1] : "";
     const titleLabel = titleMatch ? titleMatch[2] : name.replace(/^\d+ - /, "").replace(/\.md$/, "");
     const perNoteChars = Math.min(remaining, Math.floor(charBudget / noteFiles.length) + 200);
-    const extracted = extractKeyLines(content, perNoteChars);
+    const extracted = extractKeyLines(content, perNoteChars, seen);
     if (!extracted) continue;
     const noteBlock = `[${dateLabel} - ${titleLabel}]
 ${extracted}`;
@@ -318,23 +361,19 @@ function extractMarkedBody(lines) {
 }
 var AUTHORED_GRACE_MS = 60 * 60 * 1e3;
 
-// src/hooks/ts/lib/project-utils/paths.ts
-import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, linkSync, copyFileSync } from "fs";
-import { join as join3, basename as basename2 } from "path";
-
 // src/hooks/ts/lib/pai-paths.ts
-import { homedir as homedir2 } from "os";
-import { resolve, join as join2 } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { resolve, join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 function loadEnvFile() {
   const possiblePaths = [
-    resolve(process.env.PAI_DIR || "", ".env"),
-    resolve(homedir2(), ".claude", ".env")
+    resolve(process.env.ADAPTER_DIR || process.env.PAI_DIR || "", ".env"),
+    resolve(homedir3(), ".claude", ".env")
   ];
   for (const envPath of possiblePaths) {
-    if (existsSync2(envPath)) {
+    if (existsSync3(envPath)) {
       try {
-        const content = readFileSync2(envPath, "utf-8");
+        const content = readFileSync3(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -345,8 +384,8 @@ function loadEnvFile() {
             if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
               value = value.slice(1, -1);
             }
-            value = value.replace(/\$HOME/g, homedir2());
-            value = value.replace(/^~(?=\/|$)/, homedir2());
+            value = value.replace(/\$HOME/g, homedir3());
+            value = value.replace(/^~(?=\/|$)/, homedir3());
             if (process.env[key] === void 0) {
               process.env[key] = value;
             }
@@ -359,29 +398,75 @@ function loadEnvFile() {
   }
 }
 loadEnvFile();
-var PAI_DIR = process.env.PAI_DIR ? resolve(process.env.PAI_DIR) : resolve(homedir2(), ".claude");
-var HOOKS_DIR = join2(PAI_DIR, "Hooks");
-var SKILLS_DIR = join2(PAI_DIR, "Skills");
-var AGENTS_DIR = join2(PAI_DIR, "Agents");
-var HISTORY_DIR = join2(PAI_DIR, "History");
-var COMMANDS_DIR = join2(PAI_DIR, "Commands");
+function defaultAdapterDir() {
+  return resolve(homedir3(), ".claude");
+}
+function suppressDeprecationNotices() {
+  if (process.env.PAI_QUIET_NOTICES === "1") return true;
+  const idx = process.argv.indexOf("--output-format");
+  return idx !== -1 && process.argv[idx + 1] === "json";
+}
+function warnPaiDirDeprecatedOnce(message) {
+  const g = globalThis;
+  if (g.__paiDirNoticePrinted || suppressDeprecationNotices()) return;
+  g.__paiDirNoticePrinted = true;
+  process.stderr.write(`pai: ${message}
+`);
+}
+function resolveAdapterDir() {
+  if (process.env.ADAPTER_DIR) {
+    const adapterDir = resolve(process.env.ADAPTER_DIR);
+    if (process.env.PAI_DIR) {
+      const paiDir = resolve(process.env.PAI_DIR);
+      if (paiDir !== adapterDir) {
+        warnPaiDirDeprecatedOnce(
+          `ADAPTER_DIR (${adapterDir}) and PAI_DIR (${paiDir}) are both set and differ \u2014 ADAPTER_DIR wins. PAI_DIR still works for one release.`
+        );
+      }
+    }
+    return adapterDir;
+  }
+  if (process.env.PAI_DIR) {
+    const paiDir = resolve(process.env.PAI_DIR);
+    if (paiDir !== defaultAdapterDir()) {
+      warnPaiDirDeprecatedOnce(
+        "PAI_DIR is deprecated \u2014 use ADAPTER_DIR for the harness adapter root (~/.claude). PAI_DIR still works for one release."
+      );
+    }
+    return paiDir;
+  }
+  return defaultAdapterDir();
+}
+var ADAPTER_DIR = resolveAdapterDir();
+var HOOKS_DIR = join3(ADAPTER_DIR, "Hooks");
+var SKILLS_DIR = join3(ADAPTER_DIR, "Skills");
+var AGENTS_DIR = join3(ADAPTER_DIR, "Agents");
+var COMMANDS_DIR = join3(ADAPTER_DIR, "Commands");
 function validatePAIStructure() {
-  if (!existsSync2(PAI_DIR)) {
-    console.error(`PAI_DIR does not exist: ${PAI_DIR}`);
-    console.error(`   Expected ~/.claude or set PAI_DIR environment variable`);
+  if (!existsSync3(ADAPTER_DIR)) {
+    console.error(`ADAPTER_DIR does not exist: ${ADAPTER_DIR}`);
+    console.error(`   Expected ~/.claude or set ADAPTER_DIR environment variable`);
     process.exit(1);
   }
-  if (!existsSync2(HOOKS_DIR)) {
+  if (!existsSync3(HOOKS_DIR)) {
     console.error(`PAI hooks directory not found: ${HOOKS_DIR}`);
-    console.error(`   Your PAI_DIR may be misconfigured`);
-    console.error(`   Current PAI_DIR: ${PAI_DIR}`);
+    console.error(`   Your ADAPTER_DIR may be misconfigured`);
+    console.error(`   Current ADAPTER_DIR: ${ADAPTER_DIR}`);
     process.exit(1);
   }
 }
 validatePAIStructure();
+function oldSessionRoutingPath() {
+  return join3(ADAPTER_DIR, "session-routing.json");
+}
+function sessionRoutingPath() {
+  return resolvePaiFile(paiHomePath("session-routing.json"), [oldSessionRoutingPath()], "pai config migrate --history");
+}
 
 // src/hooks/ts/lib/project-utils/paths.ts
-var PROJECTS_DIR = join3(PAI_DIR, "projects");
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync3, linkSync, copyFileSync as copyFileSync2 } from "fs";
+import { join as join4, basename as basename2 } from "path";
+var PROJECTS_DIR = join4(ADAPTER_DIR, "projects");
 var PROBE_CWD_PATTERNS = [
   "/CodexBar/ClaudeProbe",
   "/ClaudeProbe"
@@ -395,56 +480,56 @@ function encodePath(path) {
 }
 function getProjectDir(cwd) {
   const encoded = encodePath(cwd);
-  return join3(PROJECTS_DIR, encoded);
+  return join4(PROJECTS_DIR, encoded);
 }
 function getNotesDir(cwd) {
-  return join3(getProjectDir(cwd), "Notes");
+  return join4(getProjectDir(cwd), "Notes");
 }
 function findNotesDir(cwd) {
   const cwdBasename = basename2(cwd).toLowerCase();
-  if (cwdBasename === "notes" && existsSync3(cwd)) {
+  if (cwdBasename === "notes" && existsSync4(cwd)) {
     return { path: cwd, isLocal: true };
   }
   const localPaths = [
-    join3(cwd, "Notes"),
-    join3(cwd, "notes"),
-    join3(cwd, ".claude", "Notes")
+    join4(cwd, "Notes"),
+    join4(cwd, "notes"),
+    join4(cwd, ".claude", "Notes")
   ];
   for (const path of localPaths) {
-    if (existsSync3(path)) {
+    if (existsSync4(path)) {
       return { path, isLocal: true };
     }
   }
   return { path: getNotesDir(cwd), isLocal: false };
 }
 function getSessionsDirFromProjectDir(projectDir) {
-  return join3(projectDir, "sessions");
+  return join4(projectDir, "sessions");
 }
 function ensureSessionsDirFromProjectDir(projectDir) {
   const sessionsDir = getSessionsDirFromProjectDir(projectDir);
-  if (!existsSync3(sessionsDir)) {
-    mkdirSync(sessionsDir, { recursive: true });
+  if (!existsSync4(sessionsDir)) {
+    mkdirSync2(sessionsDir, { recursive: true });
     console.error(`Created sessions directory: ${sessionsDir}`);
   }
   return sessionsDir;
 }
 function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
   const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
-  if (!existsSync3(projectDir)) return 0;
-  const files = readdirSync2(projectDir);
+  if (!existsSync4(projectDir)) return 0;
+  const files = readdirSync3(projectDir);
   let archivedCount = 0;
   for (const file of files) {
     if (!file.endsWith(".jsonl") || file === excludeFile) continue;
-    const sourcePath = join3(projectDir, file);
-    const destPath = join3(sessionsDir, file);
-    if (existsSync3(destPath)) continue;
+    const sourcePath = join4(projectDir, file);
+    const destPath = join4(sessionsDir, file);
+    if (existsSync4(destPath)) continue;
     try {
       linkSync(sourcePath, destPath);
       if (!silent) console.error(`Archived ${file} \u2192 sessions/ (still resumable)`);
       archivedCount++;
     } catch (error) {
       try {
-        copyFileSync(sourcePath, destPath);
+        copyFileSync2(sourcePath, destPath);
         if (!silent) console.error(`Copied ${file} \u2192 sessions/ (hardlink unavailable)`);
         archivedCount++;
       } catch {
@@ -456,41 +541,41 @@ function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = fals
 }
 function findTodoPath(cwd) {
   const localPaths = [
-    join3(cwd, "TODO.md"),
-    join3(cwd, "notes", "TODO.md"),
-    join3(cwd, "Notes", "TODO.md"),
-    join3(cwd, ".claude", "TODO.md")
+    join4(cwd, "TODO.md"),
+    join4(cwd, "notes", "TODO.md"),
+    join4(cwd, "Notes", "TODO.md"),
+    join4(cwd, ".claude", "TODO.md")
   ];
   for (const path of localPaths) {
-    if (existsSync3(path)) return path;
+    if (existsSync4(path)) return path;
   }
-  return join3(getNotesDir(cwd), "TODO.md");
+  return join4(getNotesDir(cwd), "TODO.md");
 }
 function findAllClaudeMdPaths(cwd) {
   const foundPaths = [];
   const localPaths = [
-    join3(cwd, ".claude", "CLAUDE.md"),
-    join3(cwd, "CLAUDE.md"),
-    join3(cwd, "Notes", "CLAUDE.md"),
-    join3(cwd, "notes", "CLAUDE.md"),
-    join3(cwd, "Prompts", "CLAUDE.md"),
-    join3(cwd, "prompts", "CLAUDE.md")
+    join4(cwd, ".claude", "CLAUDE.md"),
+    join4(cwd, "CLAUDE.md"),
+    join4(cwd, "Notes", "CLAUDE.md"),
+    join4(cwd, "notes", "CLAUDE.md"),
+    join4(cwd, "Prompts", "CLAUDE.md"),
+    join4(cwd, "prompts", "CLAUDE.md")
   ];
   for (const path of localPaths) {
-    if (existsSync3(path)) foundPaths.push(path);
+    if (existsSync4(path)) foundPaths.push(path);
   }
   return foundPaths;
 }
 
 // src/hooks/ts/lib/project-utils/notify.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 function isWhatsAppEnabled() {
   try {
-    const settingsPath = join4(homedir3(), ".claude", "settings.json");
-    if (!existsSync4(settingsPath)) return false;
-    const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+    const settingsPath = join5(homedir4(), ".claude", "settings.json");
+    if (!existsSync5(settingsPath)) return false;
+    const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
     const enabled = settings.enabledMcpjsonServers || [];
     return enabled.includes("aibroker") || enabled.includes("whazaa") || enabled.includes("telex");
   } catch {
@@ -535,21 +620,21 @@ async function sendNtfyNotification(message, retries = 2) {
 }
 
 // src/hooks/ts/lib/project-utils/session-notes.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync, renameSync } from "fs";
-import { join as join5, basename as basename3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, writeFileSync, renameSync as renameSync2 } from "fs";
+import { join as join6, basename as basename3 } from "path";
 function getMonthDir(notesDir) {
   const now = /* @__PURE__ */ new Date();
   const year = String(now.getFullYear());
   const month = String(now.getMonth() + 1).padStart(2, "0");
-  const monthDir = join5(notesDir, year, month);
-  if (!existsSync5(monthDir)) {
-    mkdirSync2(monthDir, { recursive: true });
+  const monthDir = join6(notesDir, year, month);
+  if (!existsSync6(monthDir)) {
+    mkdirSync3(monthDir, { recursive: true });
   }
   return monthDir;
 }
 function getNextNoteNumber(notesDir) {
   const monthDir = getMonthDir(notesDir);
-  const files = readdirSync3(monthDir).filter((f) => f.match(/^\d{3,4}[\s_-]/)).sort();
+  const files = readdirSync4(monthDir).filter((f) => f.match(/^\d{3,4}[\s_-]/)).sort();
   if (files.length === 0) return "0001";
   let maxNumber = 0;
   for (const file of files) {
@@ -562,27 +647,27 @@ function getNextNoteNumber(notesDir) {
   return String(maxNumber + 1).padStart(4, "0");
 }
 function getCurrentNotePath(notesDir) {
-  if (!existsSync5(notesDir)) return null;
+  if (!existsSync6(notesDir)) return null;
   const findLatestIn = (dir) => {
-    if (!existsSync5(dir)) return null;
-    const files = readdirSync3(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+    if (!existsSync6(dir)) return null;
+    const files = readdirSync4(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
       const numA = parseInt(a.match(/^(\d+)/)?.[1] || "0", 10);
       const numB = parseInt(b.match(/^(\d+)/)?.[1] || "0", 10);
       return numA - numB;
     });
     if (files.length === 0) return null;
-    return join5(dir, files[files.length - 1]);
+    return join6(dir, files[files.length - 1]);
   };
   const now = /* @__PURE__ */ new Date();
   const year = String(now.getFullYear());
   const month = String(now.getMonth() + 1).padStart(2, "0");
-  const currentMonthDir = join5(notesDir, year, month);
+  const currentMonthDir = join6(notesDir, year, month);
   const found = findLatestIn(currentMonthDir);
   if (found) return found;
   const prevDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
   const prevYear = String(prevDate.getFullYear());
   const prevMonth = String(prevDate.getMonth() + 1).padStart(2, "0");
-  const prevMonthDir = join5(notesDir, prevYear, prevMonth);
+  const prevMonthDir = join6(notesDir, prevYear, prevMonth);
   const prevFound = findLatestIn(prevMonthDir);
   if (prevFound) return prevFound;
   return findLatestIn(notesDir);
@@ -592,7 +677,7 @@ function createSessionNote(notesDir, description) {
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const monthDir = getMonthDir(notesDir);
   const filename = `${noteNumber} - ${date} - New Session.md`;
-  const filepath = join5(monthDir, filename);
+  const filepath = join6(monthDir, filename);
   const content = `# Session ${noteNumber}: ${description}
 
 **Date:** ${date}
@@ -630,16 +715,16 @@ function findPaiBinary() {
       `${process.env.HOME}/.local/bin/pai`
     ];
     for (const p of fallbacks) {
-      if (existsSync6(p)) return p;
+      if (existsSync7(p)) return p;
     }
   }
   return "pai";
 }
 function getRoutedNotesPath() {
-  const routingFile = join6(PAI_DIR, "session-routing.json");
-  if (!existsSync6(routingFile)) return null;
+  const routingFile = sessionRoutingPath();
+  if (!existsSync7(routingFile)) return null;
   try {
-    const routing = JSON.parse(readFileSync5(routingFile, "utf-8"));
+    const routing = JSON.parse(readFileSync6(routingFile, "utf-8"));
     const active = routing?.active_session;
     if (active?.notes_path) {
       return active.notes_path;
@@ -664,16 +749,16 @@ var PROJECT_SIGNALS = [
   "CMakeLists.txt",
   "tsconfig.json",
   "CLAUDE.md",
-  join6("Notes", "PAI.md")
+  join7("Notes", "PAI.md")
 ];
 function hasProjectSignals(dir) {
   for (const signal of PROJECT_SIGNALS) {
-    if (existsSync6(join6(dir, signal))) return true;
+    if (existsSync7(join7(dir, signal))) return true;
   }
   return false;
 }
 function isGuardedPath(dir) {
-  const home = homedir4();
+  const home = homedir5();
   const resolved = resolve2(dir);
   if (resolved === home) return true;
   const parts = resolved.split("/").filter(Boolean);
@@ -707,7 +792,7 @@ async function main() {
   const cwd = hookInput?.cwd || process.cwd();
   let projectName = basename4(cwd);
   if (projectName.toLowerCase() === "notes") {
-    projectName = basename4(dirname(cwd));
+    projectName = basename4(dirname2(cwd));
   }
   console.error(`Working directory: ${cwd}`);
   console.error(`Project: ${projectName}`);
@@ -723,7 +808,7 @@ async function main() {
     for (const path of claudeMdPaths) {
       console.error(`   - ${path}`);
       try {
-        const content = readFileSync5(path, "utf-8");
+        const content = readFileSync6(path, "utf-8");
         claudeMdContents.push({ path, content });
         console.error(`     Read ${content.length} chars`);
       } catch (error) {
@@ -737,9 +822,9 @@ async function main() {
   const routedPath = getRoutedNotesPath();
   let notesDir;
   if (routedPath) {
-    const { mkdirSync: mkdirSync3 } = await import("fs");
-    if (!existsSync6(routedPath)) {
-      mkdirSync3(routedPath, { recursive: true });
+    const { mkdirSync: mkdirSync4 } = await import("fs");
+    if (!existsSync7(routedPath)) {
+      mkdirSync4(routedPath, { recursive: true });
       console.error(`Created routed Notes: ${routedPath}`);
     } else {
       console.error(`Notes directory: ${routedPath} (routed via pai route)`);
@@ -751,9 +836,9 @@ async function main() {
       notesDir = notesInfo.path;
       console.error(`Notes directory: ${notesDir} (local)`);
     } else {
-      if (!existsSync6(notesInfo.path)) {
-        const { mkdirSync: mkdirSync3 } = await import("fs");
-        mkdirSync3(notesInfo.path, { recursive: true });
+      if (!existsSync7(notesInfo.path)) {
+        const { mkdirSync: mkdirSync4 } = await import("fs");
+        mkdirSync4(notesInfo.path, { recursive: true });
         console.error(`Created central Notes: ${notesInfo.path}`);
       } else {
         console.error(`Notes directory: ${notesInfo.path} (central)`);
@@ -762,7 +847,7 @@ async function main() {
     }
   }
   const projectDir = getProjectDir(cwd);
-  if (existsSync6(projectDir)) {
+  if (existsSync7(projectDir)) {
     try {
       const own = hookInput?.session_id ? `${hookInput.session_id}.jsonl` : void 0;
       archiveSessionFilesToSessionsDir(projectDir, own, true);
@@ -771,11 +856,11 @@ async function main() {
     }
   }
   const todoPath = findTodoPath(cwd);
-  const hasTodo = existsSync6(todoPath);
+  const hasTodo = existsSync7(todoPath);
   if (hasTodo) {
     console.error(`TODO.md: ${todoPath}`);
   } else {
-    const newTodoPath = join6(notesDir, "TODO.md");
+    const newTodoPath = join7(notesDir, "TODO.md");
     const { writeFileSync: writeFileSync2 } = await import("fs");
     writeFileSync2(newTodoPath, `# TODO
 
@@ -802,7 +887,7 @@ async function main() {
       console.error(`
 Using existing session note: ${basename4(activeNotePath)}`);
       try {
-        const content = readFileSync5(activeNotePath, "utf-8");
+        const content = readFileSync6(activeNotePath, "utf-8");
         const lines = content.split("\n").slice(0, 12);
         console.error("--- Current Note Preview ---");
         for (const line of lines) {
@@ -813,9 +898,9 @@ Using existing session note: ${basename4(activeNotePath)}`);
       }
     }
   }
-  if (existsSync6(todoPath)) {
+  if (existsSync7(todoPath)) {
     try {
-      const todoContent = readFileSync5(todoPath, "utf-8");
+      const todoContent = readFileSync6(todoPath, "utf-8");
       const todoLines = todoContent.split("\n").filter((l) => l.includes("[ ]")).slice(0, 5);
       if (todoLines.length > 0) {
         console.error("\nOpen TODOs:");
@@ -926,9 +1011,9 @@ Session Commands:
 </system-reminder>
 `;
   console.log(reminder);
-  if (existsSync6(todoPath)) {
+  if (existsSync7(todoPath)) {
     try {
-      const checkpoint = readContinueCheckpoint(readFileSync5(todoPath, "utf-8"));
+      const checkpoint = readContinueCheckpoint(readFileSync6(todoPath, "utf-8"));
       if (checkpoint) {
         const from = checkpoint.meta?.session ? `
 From session: ${checkpoint.meta.session}` : "";