@tekmidian/pai 0.42.5 → 0.42.6

package/dist/hooks/stop-hook.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,28 +9,58 @@ function isWorkerSession(env = process.env) {
 }
 
 // src/hooks/ts/stop/stop-hook.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync7, unlinkSync } from "fs";
-import { join as join7, basename as basename4, dirname } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync8, unlinkSync } from "fs";
+import { join as join9, basename as basename4, dirname as dirname2 } from "path";
 import { connect } from "net";
 import { randomUUID } from "crypto";
 
 // src/hooks/ts/lib/project-utils/paths.ts
-import { existsSync as existsSync2, mkdirSync, readdirSync, linkSync, copyFileSync } from "fs";
-import { join as join2, basename } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, linkSync, copyFileSync as copyFileSync2 } from "fs";
+import { join as join3, basename } 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";
+
+// src/config/pai-home.ts
+import { existsSync, mkdirSync, readFileSync, copyFileSync, renameSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+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/hooks/ts/lib/pai-paths.ts
-import { homedir } from "os";
-import { resolve, join } from "path";
-import { existsSync, readFileSync } from "fs";
 function loadEnvFile() {
   const possiblePaths = [
-    resolve(process.env.PAI_DIR || "", ".env"),
-    resolve(homedir(), ".claude", ".env")
+    resolve(process.env.ADAPTER_DIR || process.env.PAI_DIR || "", ".env"),
+    resolve(homedir2(), ".claude", ".env")
   ];
   for (const envPath of possiblePaths) {
-    if (existsSync(envPath)) {
+    if (existsSync2(envPath)) {
       try {
-        const content = readFileSync(envPath, "utf-8");
+        const content = readFileSync2(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -38,8 +71,8 @@ function loadEnvFile() {
             if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
               value = value.slice(1, -1);
             }
-            value = value.replace(/\$HOME/g, homedir());
-            value = value.replace(/^~(?=\/|$)/, homedir());
+            value = value.replace(/\$HOME/g, homedir2());
+            value = value.replace(/^~(?=\/|$)/, homedir2());
             if (process.env[key] === void 0) {
               process.env[key] = value;
             }
@@ -52,29 +85,67 @@ function loadEnvFile() {
   }
 }
 loadEnvFile();
-var PAI_DIR = process.env.PAI_DIR ? resolve(process.env.PAI_DIR) : resolve(homedir(), ".claude");
-var HOOKS_DIR = join(PAI_DIR, "Hooks");
-var SKILLS_DIR = join(PAI_DIR, "Skills");
-var AGENTS_DIR = join(PAI_DIR, "Agents");
-var HISTORY_DIR = join(PAI_DIR, "History");
-var COMMANDS_DIR = join(PAI_DIR, "Commands");
+function defaultAdapterDir() {
+  return resolve(homedir2(), ".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 = join2(ADAPTER_DIR, "Hooks");
+var SKILLS_DIR = join2(ADAPTER_DIR, "Skills");
+var AGENTS_DIR = join2(ADAPTER_DIR, "Agents");
+var COMMANDS_DIR = join2(ADAPTER_DIR, "Commands");
 function validatePAIStructure() {
-  if (!existsSync(PAI_DIR)) {
-    console.error(`PAI_DIR does not exist: ${PAI_DIR}`);
-    console.error(`   Expected ~/.claude or set PAI_DIR environment variable`);
+  if (!existsSync2(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 (!existsSync(HOOKS_DIR)) {
+  if (!existsSync2(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();
 
 // src/hooks/ts/lib/project-utils/paths.ts
-var PROJECTS_DIR = join2(PAI_DIR, "projects");
+var PROJECTS_DIR = join3(ADAPTER_DIR, "projects");
 var PROBE_CWD_PATTERNS = [
   "/CodexBar/ClaudeProbe",
   "/ClaudeProbe"
@@ -88,56 +159,56 @@ function encodePath(path) {
 }
 function getProjectDir(cwd) {
   const encoded = encodePath(cwd);
-  return join2(PROJECTS_DIR, encoded);
+  return join3(PROJECTS_DIR, encoded);
 }
 function getNotesDir(cwd) {
-  return join2(getProjectDir(cwd), "Notes");
+  return join3(getProjectDir(cwd), "Notes");
 }
 function findNotesDir(cwd) {
   const cwdBasename = basename(cwd).toLowerCase();
-  if (cwdBasename === "notes" && existsSync2(cwd)) {
+  if (cwdBasename === "notes" && existsSync3(cwd)) {
     return { path: cwd, isLocal: true };
   }
   const localPaths = [
-    join2(cwd, "Notes"),
-    join2(cwd, "notes"),
-    join2(cwd, ".claude", "Notes")
+    join3(cwd, "Notes"),
+    join3(cwd, "notes"),
+    join3(cwd, ".claude", "Notes")
   ];
   for (const path of localPaths) {
-    if (existsSync2(path)) {
+    if (existsSync3(path)) {
       return { path, isLocal: true };
     }
   }
   return { path: getNotesDir(cwd), isLocal: false };
 }
 function getSessionsDirFromProjectDir(projectDir) {
-  return join2(projectDir, "sessions");
+  return join3(projectDir, "sessions");
 }
 function ensureSessionsDirFromProjectDir(projectDir) {
   const sessionsDir = getSessionsDirFromProjectDir(projectDir);
-  if (!existsSync2(sessionsDir)) {
-    mkdirSync(sessionsDir, { recursive: true });
+  if (!existsSync3(sessionsDir)) {
+    mkdirSync2(sessionsDir, { recursive: true });
     console.error(`Created sessions directory: ${sessionsDir}`);
   }
   return sessionsDir;
 }
 function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
   const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
-  if (!existsSync2(projectDir)) return 0;
-  const files = readdirSync(projectDir);
+  if (!existsSync3(projectDir)) return 0;
+  const files = readdirSync2(projectDir);
   let archivedCount = 0;
   for (const file of files) {
     if (!file.endsWith(".jsonl") || file === excludeFile) continue;
-    const sourcePath = join2(projectDir, file);
-    const destPath = join2(sessionsDir, file);
-    if (existsSync2(destPath)) continue;
+    const sourcePath = join3(projectDir, file);
+    const destPath = join3(sessionsDir, file);
+    if (existsSync3(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 {
@@ -149,26 +220,26 @@ function archiveSessionFilesToSessionsDir(projectDir, excludeFile, silent = fals
 }
 function findTodoPath(cwd) {
   const localPaths = [
-    join2(cwd, "TODO.md"),
-    join2(cwd, "notes", "TODO.md"),
-    join2(cwd, "Notes", "TODO.md"),
-    join2(cwd, ".claude", "TODO.md")
+    join3(cwd, "TODO.md"),
+    join3(cwd, "notes", "TODO.md"),
+    join3(cwd, "Notes", "TODO.md"),
+    join3(cwd, ".claude", "TODO.md")
   ];
   for (const path of localPaths) {
-    if (existsSync2(path)) return path;
+    if (existsSync3(path)) return path;
   }
-  return join2(getNotesDir(cwd), "TODO.md");
+  return join3(getNotesDir(cwd), "TODO.md");
 }
 
 // src/hooks/ts/lib/project-utils/notify.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 function isWhatsAppEnabled() {
   try {
-    const settingsPath = join3(homedir2(), ".claude", "settings.json");
-    if (!existsSync3(settingsPath)) return false;
-    const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    const settingsPath = join4(homedir3(), ".claude", "settings.json");
+    if (!existsSync4(settingsPath)) return false;
+    const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
     const enabled = settings.enabledMcpjsonServers || [];
     return enabled.includes("aibroker") || enabled.includes("whazaa") || enabled.includes("telex");
   } catch {
@@ -213,40 +284,40 @@ async function sendNtfyNotification(message, retries = 2) {
 }
 
 // src/hooks/ts/lib/project-utils/session-notes.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync, renameSync } from "fs";
-import { join as join4, basename as basename2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync, renameSync as renameSync2 } from "fs";
+import { join as join5, basename as basename2 } from "path";
 function getCurrentNotePath(notesDir) {
-  if (!existsSync4(notesDir)) return null;
+  if (!existsSync5(notesDir)) return null;
   const findLatestIn = (dir) => {
-    if (!existsSync4(dir)) return null;
-    const files = readdirSync2(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+    if (!existsSync5(dir)) return null;
+    const files = readdirSync3(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 join4(dir, files[files.length - 1]);
+    return join5(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 = join4(notesDir, year, month);
+  const currentMonthDir = join5(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 = join4(notesDir, prevYear, prevMonth);
+  const prevMonthDir = join5(notesDir, prevYear, prevMonth);
   const prevFound = findLatestIn(prevMonthDir);
   if (prevFound) return prevFound;
   return findLatestIn(notesDir);
 }
 function addWorkToSessionNote(notePath, workItems, sectionTitle) {
-  if (!existsSync4(notePath)) {
+  if (!existsSync5(notePath)) {
     console.error(`Note file not found: ${notePath}`);
     return;
   }
-  let content = readFileSync3(notePath, "utf-8");
+  let content = readFileSync4(notePath, "utf-8");
   let workText = "";
   if (sectionTitle) workText += `
 ### ${sectionTitle}
@@ -335,8 +406,8 @@ function extractMeaningfulName(noteContent, summary) {
   return "";
 }
 function renameSessionNote(notePath, meaningfulName) {
-  if (!meaningfulName || !existsSync4(notePath)) return notePath;
-  const dir = join4(notePath, "..");
+  if (!meaningfulName || !existsSync5(notePath)) return notePath;
+  const dir = join5(notePath, "..");
   const oldFilename = basename2(notePath);
   const correctMatch = oldFilename.match(/^(\d{3,4}) - (\d{4}-\d{2}-\d{2}) - .*\.md$/);
   const legacyMatch = oldFilename.match(/^(\d{3,4})_(\d{4}-\d{2}-\d{2})_.*\.md$/);
@@ -346,10 +417,10 @@ function renameSessionNote(notePath, meaningfulName) {
   const titleCaseName = meaningfulName.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
   const paddedNumber = noteNumber.padStart(4, "0");
   const newFilename = `${paddedNumber} - ${date} - ${titleCaseName}.md`;
-  const newPath = join4(dir, newFilename);
+  const newPath = join5(dir, newFilename);
   if (newFilename === oldFilename) return notePath;
   try {
-    renameSync(notePath, newPath);
+    renameSync2(notePath, newPath);
     console.error(`Renamed note: ${oldFilename} \u2192 ${newFilename}`);
     return newPath;
   } catch (error) {
@@ -358,11 +429,11 @@ function renameSessionNote(notePath, meaningfulName) {
   }
 }
 function finalizeSessionNote(notePath, summary) {
-  if (!existsSync4(notePath)) {
+  if (!existsSync5(notePath)) {
     console.error(`Note file not found: ${notePath}`);
     return notePath;
   }
-  let content = readFileSync3(notePath, "utf-8");
+  let content = readFileSync4(notePath, "utf-8");
   if (content.includes("**Status:** Completed")) {
     console.error(`Note already finalized: ${basename2(notePath)}`);
     return notePath;
@@ -398,20 +469,20 @@ ${summary || "Session completed."}`
 }
 
 // src/hooks/ts/lib/project-utils/todo.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6, basename as basename3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, basename as basename3 } from "path";
 
 // src/session/checkpoint-block.ts
 import {
-  existsSync as existsSync5,
-  readFileSync as readFileSync4,
+  existsSync as existsSync6,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync2,
-  readdirSync as readdirSync3,
-  renameSync as renameSync2,
-  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync4,
+  renameSync as renameSync3,
+  mkdirSync as mkdirSync4,
   realpathSync
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var TODO_LOCATIONS = [
   "Notes/TODO.md",
   ".claude/Notes/TODO.md",
@@ -427,10 +498,10 @@ var ARCHIVE_LIMIT = 5;
 var CONTINUE_HEADING = "## Continue";
 function findProjectTodo(rootPath) {
   for (const rel of TODO_LOCATIONS) {
-    const full = join5(rootPath, rel);
-    if (existsSync5(full)) {
+    const full = join6(rootPath, rel);
+    if (existsSync6(full)) {
       try {
-        return { path: full, content: readFileSync4(full, "utf8") };
+        return { path: full, content: readFileSync5(full, "utf8") };
       } catch {
       }
     }
@@ -440,15 +511,15 @@ function findProjectTodo(rootPath) {
 function resolveTodoTarget(rootPath, opts = {}) {
   const found = findProjectTodo(rootPath);
   if (found) return found;
-  const notesDir = join5(rootPath, "Notes");
+  const notesDir = join6(rootPath, "Notes");
   if (opts.create !== false) {
     try {
-      if (!existsSync5(notesDir)) mkdirSync3(notesDir, { recursive: true });
+      if (!existsSync6(notesDir)) mkdirSync4(notesDir, { recursive: true });
     } catch {
       return null;
     }
   }
-  return { path: join5(notesDir, "TODO.md"), content: "" };
+  return { path: join6(notesDir, "TODO.md"), content: "" };
 }
 function parseMarker(line) {
   const trimmed = line.trim();
@@ -737,10 +808,10 @@ function applyContinue(opts) {
   const tmpPath = `${target.path}.continue.tmp`;
   try {
     writeFileSync2(tmpPath, newContent, "utf8");
-    renameSync2(tmpPath, target.path);
+    renameSync3(tmpPath, target.path);
   } catch (err) {
     try {
-      if (existsSync5(tmpPath)) renameSync2(tmpPath, `${tmpPath}.dead`);
+      if (existsSync6(tmpPath)) renameSync3(tmpPath, `${tmpPath}.dead`);
     } catch {
     }
     return {
@@ -756,9 +827,9 @@ function applyContinue(opts) {
 // src/hooks/ts/lib/project-utils/todo.ts
 function ensureTodoMd(cwd) {
   const todoPath = findTodoPath(cwd);
-  if (!existsSync6(todoPath)) {
-    const parentDir = join6(todoPath, "..");
-    if (!existsSync6(parentDir)) mkdirSync4(parentDir, { recursive: true });
+  if (!existsSync7(todoPath)) {
+    const parentDir = join7(todoPath, "..");
+    if (!existsSync7(parentDir)) mkdirSync5(parentDir, { recursive: true });
     const content = `# TODO
 
 ## Current Session
@@ -813,7 +884,7 @@ function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
   try {
     const todoPath = result.path;
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    let content = readFileSync5(todoPath, "utf-8");
+    let content = readFileSync6(todoPath, "utf-8");
     content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
     content = content.trimEnd() + `
 
@@ -829,6 +900,17 @@ function updateTodoContinue(cwd, noteFilename, state, tokenDisplay, sessionId) {
   );
 }
 
+// src/config/pai-files.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join8 } from "node:path";
+function oldSessionStateDir() {
+  return join8(homedir4(), ".config", "pai", "session-state");
+}
+function sessionStateDir() {
+  return resolvePaiFile(paiHomePath("session-state"), [oldSessionStateDir()], "pai config migrate");
+}
+var SESSION_STOP_LOCK_ABANDONED_AFTER_MS = 60 * 60 * 1e3;
+
 // src/hooks/ts/stop/stop-hook.ts
 var DAEMON_SOCKET = process.env.PAI_SOCKET ?? "/tmp/pai.sock";
 var DAEMON_TIMEOUT_MS = 800;
@@ -840,17 +922,11 @@ var AUTO_SAVE_INTERVAL = (() => {
   }
   return 15;
 })();
-var SESSION_STATE_DIR = join7(
-  process.env.HOME ?? "/tmp",
-  ".config",
-  "pai",
-  "session-state"
-);
 function readSessionState(sessionId) {
   try {
-    const stateFile = join7(SESSION_STATE_DIR, `${sessionId}.json`);
-    if (!existsSync7(stateFile)) return { humanMessageCount: 0 };
-    const raw = readFileSync6(stateFile, "utf-8");
+    const stateFile = join9(sessionStateDir(), `${sessionId}.json`);
+    if (!existsSync8(stateFile)) return { humanMessageCount: 0 };
+    const raw = readFileSync7(stateFile, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       humanMessageCount: typeof parsed.humanMessageCount === "number" ? parsed.humanMessageCount : 0
@@ -861,8 +937,9 @@ function readSessionState(sessionId) {
 }
 function writeSessionState(sessionId, state) {
   try {
-    mkdirSync5(SESSION_STATE_DIR, { recursive: true });
-    const stateFile = join7(SESSION_STATE_DIR, `${sessionId}.json`);
+    const dir = paiHomePath("session-state");
+    mkdirSync6(dir, { recursive: true });
+    const stateFile = join9(dir, `${sessionId}.json`);
     writeFileSync4(stateFile, JSON.stringify(state, null, 2), "utf-8");
   } catch (e) {
     console.error(`STOP-HOOK: Could not write session state: ${e}`);
@@ -870,8 +947,8 @@ function writeSessionState(sessionId, state) {
 }
 function deleteSessionState(sessionId) {
   try {
-    const stateFile = join7(SESSION_STATE_DIR, `${sessionId}.json`);
-    if (existsSync7(stateFile)) {
+    const stateFile = join9(sessionStateDir(), `${sessionId}.json`);
+    if (existsSync8(stateFile)) {
       unlinkSync(stateFile);
     }
   } catch {
@@ -1333,7 +1410,7 @@ async function executeDirectly(lines, transcriptPath, cwd, message, lastUserQuer
     console.error(`Could not finalize session note: ${noteError}`);
   }
   try {
-    const transcriptDir = dirname(transcriptPath);
+    const transcriptDir = dirname2(transcriptPath);
     const archivedCount = archiveSessionFilesToSessionsDir(transcriptDir);
     if (archivedCount > 0) {
       console.error(`Archived ${archivedCount} session file(s) to sessions/`);
@@ -1392,7 +1469,7 @@ STOP-HOOK TRIGGERED AT ${timestamp}`);
   }
   let transcript;
   try {
-    transcript = readFileSync6(transcriptPath, "utf-8");
+    transcript = readFileSync7(transcriptPath, "utf-8");
     debug(`Transcript loaded: ${transcript.split("\n").length} lines`);
   } catch (e) {
     console.error(`Error reading transcript: ${e}`);