aiwcli 0.12.0 → 0.12.1

package/dist/lib/template-installer.js

@@ -75,14 +75,14 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
  * Patterns to exclude when copying template directories.
  * These are development/test artifacts that shouldn't be packaged.
  */
-const EXCLUDED_PATTERNS = [
+const EXCLUDED_PATTERNS = new Set([
     '_output',
-];
+]);
 /**
  * Check if a filename should be excluded from copying
  */
 export function shouldExclude(name) {
-    return EXCLUDED_PATTERNS.includes(name);
+    return EXCLUDED_PATTERNS.has(name);
 }
 /**
  * Copy directory recursively with proper error handling.

package/dist/lib/version.js

@@ -37,7 +37,7 @@ const MIN_CLAUDE_CODE_VERSION = '0.1.0';
  * Known incompatible Claude Code versions.
  * These versions have confirmed issues with AI Workflow CLI.
  */
-const INCOMPATIBLE_VERSIONS = ['0.0.9'];
+const INCOMPATIBLE_VERSIONS = new Set(['0.0.9']);
 /**
  * Detects Claude Code version by executing `claude --version`.
  *
@@ -109,7 +109,7 @@ export function checkVersionCompatibility(version) {
         };
     }
     // Check known incompatible versions first
-    if (INCOMPATIBLE_VERSIONS.includes(version)) {
+    if (INCOMPATIBLE_VERSIONS.has(version)) {
         return {
             compatible: false,
             version,

package/dist/templates/_shared/hooks-ts/session_end.ts

@@ -5,18 +5,70 @@
  */
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import * as path from "node:path";
 
-import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { getProjectRoot, getContextDir } from "../lib-ts/base/constants.js";
 import { getGitState } from "../lib-ts/base/git-state.js";
 import {
-  loadHookInput, logDebug, logDiagnostic, logError, logInfo, logWarn as _logWarn, runHook,
+  loadHookInput, runHook, logDebug, logInfo, logWarn, logError, logDiagnostic,
 } from "../lib-ts/base/hook-utils.js";
 import { nowIso } from "../lib-ts/base/utils.js";
 import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
 import {
-  extractPlanAnchors, findLatestPlan, generatePlanId, normalizePlanContent,
+  findLatestPlan, normalizePlanContent, generatePlanId, extractPlanAnchors,
 } from "../lib-ts/context/plan-manager.js";
 
+/**
+ * Archive session transcript to context's session-transcripts/ folder.
+ * Returns archived path on success, null if skipped or failed.
+ */
+function archiveTranscript(
+  transcriptPath: string,
+  contextId: string,
+  sessionId: string,
+  projectRoot: string,
+): string | null {
+  // 1. Validate inputs
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    logDebug("session_end", `Transcript not found: ${transcriptPath}`);
+    return null;
+  }
+
+  // 2. Ensure session-transcripts directory exists
+  const contextDir = getContextDir(contextId, projectRoot);
+  const transcriptsDir = path.join(contextDir, "session-transcripts");
+  fs.mkdirSync(transcriptsDir, { recursive: true });
+
+  // 3. Generate archive filename: YYYY-MM-DD-HHMM-{session_id}.jsonl
+  const now = new Date();
+  // Format: 2026-02-14-1400 (year-month-day-hourminute)
+  // Note: Hours and minutes are concatenated without separator (HHMM)
+  const timestamp =
+    `${now.getFullYear()}-` +
+    `${String(now.getMonth() + 1).padStart(2, "0")}-` +
+    `${String(now.getDate()).padStart(2, "0")}-` +
+    `${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+
+  // 4. Handle collisions (rare, but possible with rapid session churn)
+  let archiveName = `${timestamp}-${sessionId}.jsonl`;
+  let archivePath = path.join(transcriptsDir, archiveName);
+  let counter = 2;
+  while (fs.existsSync(archivePath)) {
+    archiveName = `${timestamp}-${sessionId}-${counter}.jsonl`;
+    archivePath = path.join(transcriptsDir, archiveName);
+    counter++;
+  }
+
+  // 5. Copy transcript file
+  try {
+    fs.copyFileSync(transcriptPath, archivePath);
+    return archivePath;
+  } catch (error) {
+    logError("session_end", `Failed to copy transcript: ${error}`);
+    return null;
+  }
+}
+
 function main(): void {
   const payload = loadHookInput();
   if (!payload) return;
@@ -50,6 +102,25 @@ function main(): void {
   };
   state.last_active = nowIso();
 
+  // Archive transcript (NEW)
+  // Note: state is a ContextState object (from getContextBySessionId on line 33)
+  // state.id is the context ID used to construct paths like _output/contexts/{context_id}/
+  if (payload.transcript_path) {
+    try {
+      const archived = archiveTranscript(
+        payload.transcript_path,
+        state.id,  // Context ID, verified by existing code on line 98: saveState(state.id, ...)
+        sessionId,
+        projectRoot,
+      );
+      if (archived) {
+        logInfo("session_end", `Archived transcript: ${path.basename(archived)}`);
+      }
+    } catch (error) {
+      logError("session_end", `Transcript archival failed: ${error}`);
+    }
+  }
+
   // Plan fallback assignment (skip in plan mode — rejected plans shouldn't stage)
   if (permissionMode !== "plan") {
     // Step 1: Assign plan fields if missing
@@ -57,7 +128,7 @@ function main(): void {
       const latestPlanPath = findLatestPlan(state.id, projectRoot);
       if (latestPlanPath) {
         try {
-          const content = fs.readFileSync(latestPlanPath, "utf8");
+          const content = fs.readFileSync(latestPlanPath, "utf-8");
           const normalized = normalizePlanContent(content);
           const planHash = crypto.createHash("sha256")
             .update(normalized, "utf-8")

package/dist/templates/_shared/hooks-ts/session_start.ts

@@ -3,17 +3,17 @@
  * SessionStart hook: Restore context after /clear (plan/handoff) or compaction.
  * Routes by source field to appropriate handler.
  */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
 import {
   loadHookInput, emitContext, runHook, runHookAsync,
   logDebug, logInfo, logError, logDiagnostic,
 } from "../lib-ts/base/hook-utils.js";
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import {
-  getContextBySessionId, getAllContexts, bindSession, updateMode,
-} from "../lib-ts/context/context-store.js";
 import {
   buildRestoreSections, formatHandoffContinuation, getModeDisplay,
 } from "../lib-ts/context/context-formatter.js";
+import {
+  getContextBySessionId, getAllContexts, bindSession, updateMode,
+} from "../lib-ts/context/context-store.js";
 import type { ContextState } from "../lib-ts/types.js";
 
 /**
@@ -124,15 +124,18 @@ async function main(): Promise<void> {
   logDiagnostic("session_start", "entry", `source=${source}, session=${sessionId}`);
 
   switch (source) {
-    case "compact":
-      handleCompactRestore(sessionId, projectRoot);
-      break;
-    case "clear":
+    case "clear": {
       await handleClearRestore(sessionId, projectRoot);
-      break;
-    default:
+      break;
+    }
+    case "compact": {
+      handleCompactRestore(sessionId, projectRoot);
+      break;
+    }
+    default: {
       logDebug("session_start", `Unhandled source: ${source}`);
-      break;
+      break;
+    }
   }
 }
 

package/dist/templates/_shared/hooks-ts/user_prompt_submit.ts

@@ -6,14 +6,14 @@
  * Uses emitContext() for output — context text is passed via hookSpecificOutput JSON.
  * Catches BlockRequest and uses emitBlock() to block the prompt.
  */
+import { getProjectRoot } from "../lib-ts/base/constants.js";
 import {
   loadHookInput, runHookAsync, logDebug, logInfo, logWarn, logBlocking, logDiagnostic, hookLog, emitContext, emitBlock,
 } from "../lib-ts/base/hook-utils.js";
-import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { determineContext, BlockRequest } from "../lib-ts/context/context-selector.js";
 import {
   getContextBySessionId, bindSession, maybeActivate, saveState,
 } from "../lib-ts/context/context-store.js";
-import { determineContext, BlockRequest } from "../lib-ts/context/context-selector.js";
 
 async function asyncMain(): Promise<void> {
   const payload = loadHookInput();
@@ -38,8 +38,8 @@ async function asyncMain(): Promise<void> {
     // Returning user — context already bound (stderr: false to avoid "hook error" display)
     try {
       maybeActivate(existingCtx.id, permissionMode, projectRoot, "user_prompt_submit");
-    } catch (e) {
-      hookLog("warn", "user_prompt_submit", `maybeActivate failed (non-critical): ${e}`, { stderr: false });
+    } catch (error) {
+      hookLog("warn", "user_prompt_submit", `maybeActivate failed (non-critical): ${error}`, { stderr: false });
     }
     hookLog("debug", "user_prompt_submit", `Session bound to ${existingCtx.id}`, { stderr: false });
   } else if (prompt) {
@@ -64,12 +64,12 @@ async function asyncMain(): Promise<void> {
       if (outputText) {
         outputs.push(outputText);
       }
-    } catch (e) {
-      if (e instanceof BlockRequest) {
-        emitBlock((e as Error).message);
+    } catch (error) {
+      if (error instanceof BlockRequest) {
+        emitBlock((error as Error).message);
         return;
       }
-      throw e; // Re-throw unexpected errors
+      throw error; // Re-throw unexpected errors
     }
   }
 

package/dist/templates/_shared/lib-ts/base/hook-utils.ts

@@ -4,14 +4,15 @@
  * See SPEC.md §5
  */
 
-import * as fs from "node:fs";
-import { logDebug, logInfo, logWarn, logError, logBlocking, logHookError, logDiagnostic, hookLog, setSessionId, setContextPath, getContextPath as _getContextPath } from "./logger.js";
+import * as fs from "node:fs";
+
 import { getProjectRoot } from "./constants.js";
+import { logDebug,  logWarn,     hookLog, setSessionId,  getContextPath as _getContextPath } from "./logger.js";
 import { getContextBySessionId } from "../context/context-store.js";
 import type { HookInput, HookOutput, PermissionRequestOutput } from "../types.js";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
-export { logDebug, logInfo, logWarn, logError, logBlocking, logHookError, logDiagnostic, hookLog, setSessionId, setContextPath };
+export {          setSessionId };
 
 // Context window baseline: tokens not visible in hook data §5.9
 export const CONTEXT_BASELINE_TOKENS = 22_600;
@@ -93,7 +94,7 @@ export function checkSkipPersistence(
   const toolInput = getToolInput(payload);
   if (!toolInput) return false;
 
-  const metadata = toolInput.metadata;
+  const {metadata} = toolInput;
   if (metadata && typeof metadata === "object" && metadata.skip_persistence) {
     logDebug(hookName, "Skipping persistence (skip_persistence flag set)");
     return true;
@@ -105,11 +106,23 @@ export function checkSkipPersistence(
  * Emit hookSpecificOutput with additionalContext to stdout.
  * hookEventName is required by Claude Code's Zod validator (discriminated union).
  * Auto-detected from stdin payload (set by loadHookInput/runHook).
+ *
+ * SubagentStop and Stop events use top-level systemMessage field instead of hookSpecificOutput.
  * See SPEC.md §5.5
  */
 export function emitContext(additionalContext: string): void {
   const eventName = _lastHookEvent ?? undefined;
   const tool = _lastToolName;
+
+  // SubagentStop and Stop use top-level systemMessage field
+  if (eventName === "SubagentStop" || eventName === "Stop") {
+    const out = { systemMessage: additionalContext };
+    process.stdout.write(JSON.stringify(out) + "\n");
+    _logEmit("systemMessage", additionalContext.length, { event: eventName ?? "unknown", systemMessage: additionalContext });
+    return;
+  }
+
+  // All other events use hookSpecificOutput
   const out: HookOutput = {
     hookSpecificOutput: {
       ...(eventName ? { hookEventName: eventName } : {}),
@@ -153,8 +166,8 @@ export function emitContextAndBlock(
   process.stdout.write(json + "\n");
 }
 
-/** Log hook output (context or block) to hook-log.jsonl for visibility. */
-function _logEmit(type: "context" | "block", chars: number, payload: Record<string, any>): void {
+/** Log hook output (context, systemMessage, or block) to hook-log.jsonl for visibility. */
+function _logEmit(type: "context" | "systemMessage" | "block", chars: number, payload: Record<string, any>): void {
   const hook = _cachedHookName ?? "unknown";
   const event = payload.event ?? "unknown";
   const mechanism = payload.mechanism ? ` via ${payload.mechanism}` : "";
@@ -268,27 +281,28 @@ export function emitPermissionDecision(
 export function emitBlock(reason: string, context?: string): void {
   const event = _lastHookEvent;
   switch (event) {
-    case "PreToolUse":
-      emitContextAndBlock(context ?? reason, reason);
-      break;
-    case "UserPromptSubmit":
-      emitBlockPrompt(reason, context);
+    case "PermissionRequest":
+      emitPermissionDecision("deny", { message: reason });
       break;
     case "PostToolUse":
     case "PostToolUseFailure":
       emitBlockViaExit(reason, context);
       break;
+    case "PreToolUse":
+      emitContextAndBlock(context ?? reason, reason);
+      break;
     case "Stop":
     case "SubagentStop":
       emitBlockTopLevel(reason);
       break;
-    case "PermissionRequest":
-      emitPermissionDecision("deny", { message: reason });
+    case "UserPromptSubmit":
+      emitBlockPrompt(reason, context);
       break;
-    default:
+    default: {
       logWarn(_cachedHookName ?? "unknown",
         `emitBlock() called from ${event ?? "unknown"} — no blocking mechanism exists for this event type, ignoring`);
-      break;
+      break;
+    }
   }
 }
 
@@ -296,7 +310,7 @@ export function emitBlock(reason: string, context?: string): void {
  * Auto-detect template origin from the hook script path.
  */
 function detectTemplate(scriptPath = ""): string {
-  const p = (scriptPath || (process.argv[1] ?? "")).replace(/\\/g, "/");
+  const p = (scriptPath || (process.argv[1] ?? "")).replaceAll('\\', "/");
   if (p.includes("/_shared/hooks/") || p.startsWith("_shared/hooks/")) {
     return "shared";
   }
@@ -438,16 +452,16 @@ export function runHook(
     const result = mainFunc();
     exitCode = typeof result === "number" ? result : 0;
     status = exitCode !== 0 ? "blocked" : "success";
-  } catch (e: any) {
-    if (e instanceof Error && e.message.startsWith("SystemExit:")) {
-      const code = parseInt(e.message.slice(11), 10);
-      exitCode = isNaN(code) ? (e.message.slice(11) ? 1 : 0) : code;
+  } catch (error: any) {
+    if (error instanceof Error && error.message.startsWith("SystemExit:")) {
+      const code = parseInt(error.message.slice(11), 10);
+      exitCode = isNaN(code) ? (error.message.slice(11) ? 1 : 0) : code;
       status = exitCode !== 0 ? "blocked" : "success";
     } else {
       exitCode = 0; // Non-blocking
       status = "error";
-      const stack = e instanceof Error ? e.stack ?? "" : "";
-      errorInfo = [e instanceof Error ? e : new Error(String(e)), stack];
+      const stack = error instanceof Error ? error.stack ?? "" : "";
+      errorInfo = [error instanceof Error ? error : new Error(String(error)), stack];
     }
   }
 
@@ -487,19 +501,19 @@ export function runHookAsync(
       _emitHookEnd(hookName, startTime, exitCode, exitCode !== 0 ? "blocked" : "success", null, startData, event, tool, template);
       _drainAndExit(exitCode);
     })
-    .catch((e: any) => {
+    .catch((error: any) => {
       let exitCode = 0;
       let status = "error";
       let errorInfo: [Error, string] | null = null;
 
-      if (e instanceof Error && e.message.startsWith("SystemExit:")) {
-        const code = parseInt(e.message.slice(11), 10);
-        exitCode = isNaN(code) ? (e.message.slice(11) ? 1 : 0) : code;
+      if (error instanceof Error && error.message.startsWith("SystemExit:")) {
+        const code = parseInt(error.message.slice(11), 10);
+        exitCode = isNaN(code) ? (error.message.slice(11) ? 1 : 0) : code;
         status = exitCode !== 0 ? "blocked" : "success";
       } else {
         exitCode = 0; // Non-blocking (fail open)
-        const stack = e instanceof Error ? e.stack ?? "" : "";
-        errorInfo = [e instanceof Error ? e : new Error(String(e)), stack];
+        const stack = error instanceof Error ? error.stack ?? "" : "";
+        errorInfo = [error instanceof Error ? error : new Error(String(error)), stack];
       }
 
       _emitHookEnd(hookName, startTime, exitCode, status, errorInfo, startData, event, tool, template);
@@ -541,7 +555,7 @@ function _emitHookEnd(
   if (errorInfo) {
     const [err, tb] = errorInfo;
     endData.error_type = err.constructor.name;
-    hookLog("error", hookName, `[${endEvent}] ${err.constructor.name}: ${String(err).replace(/[\n\r]/g, " ").slice(0, 200)}`, { traceback_str: tb });
+    hookLog("error", hookName, `[${endEvent}] ${err.constructor.name}: ${String(err).replaceAll(/[\n\r]/g, " ").slice(0, 200)}`, { traceback_str: tb });
     hookLog("error", hookName, `HOOK_END: ${err}`, { data: endData, traceback_str: tb });
   } else if (status === "blocked") {
     hookLog("warn", hookName, "HOOK_END", { data: endData });
@@ -568,3 +582,5 @@ function _drainAndExit(code: number): void {
     process.exit(code);
   });
 }
+
+export {logInfo, logError, logBlocking, logHookError, logDiagnostic, setContextPath, hookLog, logDebug, logWarn} from "./logger.js";

package/dist/templates/_shared/lib-ts/base/logger.ts

@@ -235,7 +235,7 @@ export function logHookError(
   tracebackStr = "",
 ): void {
   const errStr = typeof error === "string" ? error : String(error);
-  const msg = errStr.replace(/[\n\r]/g, " ").slice(0, 200);
+  const msg = errStr.replaceAll(/[\n\r]/g, " ").slice(0, 200);
   const errType =
     typeof error === "object" && error !== null
       ? error.constructor.name

package/dist/templates/_shared/lib-ts/base/subprocess-utils.ts

@@ -92,7 +92,7 @@ export function isExecSyncError(e: unknown): e is ExecSyncError {
  */
 export function shellQuoteWin(arg: string): string {
   if (process.platform !== "win32") return arg;
-  return '"' + arg.replace(/"/g, '""') + '"';
+  return '"' + arg.replaceAll('"', '""') + '"';
 }
 
 // ---------------------------------------------------------------------------

package/dist/templates/_shared/lib-ts/context/plan-manager.ts

@@ -8,11 +8,12 @@
  * - extractPlanPathFromResult: parse plan path from ExitPlanMode output
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
 import * as crypto from "node:crypto";
-import { getContextDir, getContextPlansDir, sanitizeTitle } from "../base/constants.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
 import { atomicWrite } from "../base/atomic-write.js";
+import { getContextDir, getContextPlansDir, sanitizeTitle } from "../base/constants.js";
 import { logDebug, logInfo, logWarn, logError } from "../base/logger.js";
 import { generateSlug } from "../base/utils.js";
 import type { ContextState } from "../types.js";
@@ -43,8 +44,8 @@ export function archivePlan(
   let content: string;
   try {
     content = fs.readFileSync(planPath, "utf-8");
-  } catch (e: any) {
-    logError("plan_manager", `Failed to read plan: ${e}`);
+  } catch (error_: any) {
+    logError("plan_manager", `Failed to read plan: ${error_}`);
     return [null, null, null];
   }
 
@@ -148,8 +149,8 @@ export function findLatestPlan(
     if (state?.plan_path && fs.existsSync(state.plan_path)) {
       return state.plan_path;
     }
-  } catch (e: any) {
-    logWarn("plan_manager", `Failed to check state.json plan_path: ${e}`);
+  } catch (error: any) {
+    logWarn("plan_manager", `Failed to check state.json plan_path: ${error}`);
   }
 
   // 2. Fall back to most recent .md in plans/ dir
@@ -182,7 +183,7 @@ export function findLatestPlan(
  * See SPEC.md §9.4
  */
 export function generatePlanId(): string {
-  return crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+  return crypto.randomUUID().replaceAll('-', "").slice(0, 8);
 }
 
 /**
@@ -191,8 +192,8 @@ export function generatePlanId(): string {
  * See SPEC.md §9.5
  */
 export function normalizePlanContent(text: string): string {
-  let result = text.replace(/<[^>]+>/g, "");
-  result = result.replace(/\s+/g, " ").trim();
+  let result = text.replaceAll(/<[^>]+>/g, "");
+  result = result.replaceAll(/\s+/g, " ").trim();
   return result;
 }
 
@@ -249,8 +250,8 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
   let lines: string[];
   try {
     lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
-  } catch (e: any) {
-    logWarn("plan_manager", `Failed to read transcript: ${e}`);
+  } catch (error: any) {
+    logWarn("plan_manager", `Failed to read transcript: ${error}`);
     return null;
   }
 
@@ -282,7 +283,7 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
       if (!filePath) continue;
 
       // Check if path contains .claude/plans/ as consecutive parts
-      const parts = filePath.replace(/\\/g, "/").split("/");
+      const parts = filePath.replaceAll('\\', "/").split("/");
       for (let j = 0; j < parts.length - 1; j++) {
         if (parts[j] === ".claude" && parts[j + 1] === "plans") {
           logInfo("plan_manager", `Extracted plan path from transcript: ${filePath}`);

package/dist/templates/_shared/lib-ts/handoff/handoff-reader.ts

@@ -7,7 +7,8 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import * as path from "node:path";
+
 import { getContextHandoffsDir } from "../base/constants.js";
 import { getContext } from "../context/context-store.js";
 import type { HandoffSections } from "../types.js";
@@ -29,7 +30,7 @@ export function findLatestHandoff(contextId: string, projectRoot?: string): stri
       .sort();
 
     if (entries.length === 0) return null;
-    return path.join(handoffsDir, entries[entries.length - 1]!);
+    return path.join(handoffsDir, entries.at(-1)!);
   } catch {
     return null;
   }

package/dist/templates/_shared/scripts/resume_handoff.ts

@@ -15,16 +15,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { getGitStatusShort } from "../lib-ts/base/git-state.js";
+import { eprint } from "../lib-ts/base/utils.js";
+import { findActiveContextId } from "../lib-ts/context/context-store.js";
 import {
   findLatestHandoff,
   readHandoffSections,
   getHandoffTimestamp,
   getHandoffPlanReference,
 } from "../lib-ts/handoff/handoff-reader.js";
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import { findActiveContextId } from "../lib-ts/context/context-store.js";
-import { getGitStatusShort } from "../lib-ts/base/git-state.js";
-import { eprint } from "../lib-ts/base/utils.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/dist/templates/_shared/scripts/save_handoff.ts

@@ -22,12 +22,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-import { getContext, saveState } from "../lib-ts/context/context-store.js";
-import { getHandoffFolderPath, getProjectRoot } from "../lib-ts/base/constants.js";
 import { atomicWrite } from "../lib-ts/base/atomic-write.js";
-import { logInfo, logWarn, logError } from "../lib-ts/base/logger.js";
+import { getHandoffFolderPath, getProjectRoot } from "../lib-ts/base/constants.js";
 import { getGitStatusShort } from "../lib-ts/base/git-state.js";
+import { logInfo, logWarn, logError } from "../lib-ts/base/logger.js";
 import { eprint } from "../lib-ts/base/utils.js";
+import { getContext, saveState } from "../lib-ts/context/context-store.js";
 
 // ---------------------------------------------------------------------------
 // Parsing helpers
@@ -250,8 +250,8 @@ function main(): void {
       } else {
         logWarn("save_handoff", `Failed to copy plan: ${error}`);
       }
-    } catch (e) {
-      logWarn("save_handoff", `Failed to read plan: ${e}`);
+    } catch (error) {
+      logWarn("save_handoff", `Failed to read plan: ${error}`);
     }
   }
 
@@ -339,8 +339,8 @@ function main(): void {
     } else {
       logWarn("save_handoff", `Could not load context state for ${contextId}`);
     }
-  } catch (e) {
-    logWarn("save_handoff", `Handoff saved but auto-resume won't work (context update failed): ${e}`);
+  } catch (error) {
+    logWarn("save_handoff", `Handoff saved but auto-resume won't work (context update failed): ${error}`);
   }
 
   // Output success message