aiwcli 0.15.4 → 0.15.7

package/dist/templates/{_shared → core}/lib-ts/context/context-store.ts

@@ -8,9 +8,9 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { atomicWrite } from "../base/atomic-write.js";
+import { atomicWrite } from "../runtime/atomic-write.js";
 import {
   getContextDir,
   getContextsDir,
@@ -19,14 +19,17 @@ import {
   getArchiveContextDir,
   getArchiveIndexPath,
   validateContextId,
-} from "../base/constants.js";
-import { logInfo, logWarn, logError, setContextPath } from "../base/logger.js";
-import { readStateJson, writeStateJson } from "../base/state-io.js";
-import { nowIso, generateContextId } from "../base/utils.js";
+} from "../runtime/constants.js";
+import { logInfo, logWarn, logError, setContextPath } from "../runtime/logger.js";
+import { readStateJson, writeStateJson } from "../runtime/state-io.js";
+import { nowIso, generateContextId } from "../runtime/utils.js";
 import type { ContextState, IndexFile, IndexEntry, Mode } from "../types.js";
 
 const INDEX_VERSION = "3.0";
 
+// Module-level index cache — safe because each hook is a separate bun process
+let _indexCache: IndexFile | null = null;
+
 // ---------------------------------------------------------------------------
 // Public utilities
 // ---------------------------------------------------------------------------
@@ -73,25 +76,31 @@ export function determineArtifactType(
 // ---------------------------------------------------------------------------
 
 function loadIndex(projectRoot?: string): IndexFile {
+  if (_indexCache) return _indexCache;
   const indexPath = getIndexPath(projectRoot);
   if (fs.existsSync(indexPath)) {
     try {
-      const raw = fs.readFileSync(indexPath, "utf-8");
-      return JSON.parse(raw) as IndexFile;
-    } catch (error: any) {
+      const raw = fs.readFileSync(indexPath, "utf8");
+      _indexCache = JSON.parse(raw) as IndexFile;
+      return _indexCache;
+    } catch (error: unknown) {
       logWarn("context_store", `Failed to read index, recreating: ${error}`);
     }
   }
-  return { version: INDEX_VERSION, updated_at: nowIso(), sessions: {}, contexts: {} };
+  const fresh: IndexFile = { version: INDEX_VERSION, updated_at: nowIso(), sessions: {}, contexts: {} };
+  _indexCache = fresh;
+  return fresh;
 }
 
 function saveIndex(index: IndexFile, projectRoot?: string): boolean {
   index.updated_at = nowIso();
   const content = JSON.stringify(index, null, 2);
-  const [success, error] = atomicWrite(getIndexPath(projectRoot), content);
+  // fsync: false — index.json is reconstructable by scanning _output/contexts/
+  const [success, error] = atomicWrite(getIndexPath(projectRoot), content, 2, [500, 1000], false);
   if (!success) {
     logWarn("context_store", `Failed to write index: ${error}`);
   }
+  _indexCache = index;
   return success;
 }
 
@@ -111,7 +120,7 @@ function migrateContextJson(contextId: string, projectRoot?: string): ContextSta
   if (!fs.existsSync(legacyPath)) return null;
 
   try {
-    const data = JSON.parse(fs.readFileSync(legacyPath, "utf-8"));
+    const data = JSON.parse(fs.readFileSync(legacyPath, "utf8"));
     const inFlight = data.in_flight ?? {};
     const oldMode = inFlight.mode ?? "none";
     const MODE_MIGRATION: Record<string, string> = {
@@ -149,7 +158,7 @@ function migrateContextJson(contextId: string, projectRoot?: string): ContextSta
       last_session: null,
       tasks: [],
     };
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("context_store", `Failed to migrate context.json for '${contextId}': ${error}`);
     return null;
   }
@@ -493,7 +502,7 @@ export function maybeActivate(
 
   if (state.mode === "idle" || state.mode === "has_staged_work") {
     const oldMode = state.mode;
-    const opts: Record<string, any> = {};
+    const opts: Record<string, unknown> = {};
     if (oldMode === "has_staged_work") opts.work_consumed = true; // CHANGED: unified flag
     updateMode(contextId, "active", projectRoot, opts);
     logInfo(
@@ -560,7 +569,7 @@ export function archiveContext(contextId: string, projectRoot?: string): Context
 
   try {
     fs.renameSync(sourceDir, archiveDest);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError("context_store", `Failed to move context to archive: ${error}`);
     return null;
   }
@@ -650,8 +659,8 @@ function updateArchiveIndex(state: ContextState, projectRoot?: string): boolean
 
   if (fs.existsSync(archiveIndexPath)) {
     try {
-      archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf-8"));
-    } catch (error_: any) {
+      archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf8"));
+    } catch (error_: unknown) {
       logWarn("context_store", `Failed to read archive index, recreating: ${error_}`);
     }
   }
@@ -679,7 +688,7 @@ function restoreFromArchive(contextId: string, projectRoot?: string): ContextSta
 
   try {
     fs.renameSync(archiveDir, activeDir);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError("context_store", `Failed to restore context from archive: ${error}`);
     return null;
   }
@@ -697,7 +706,7 @@ function removeFromArchiveIndex(contextId: string, projectRoot?: string): boolea
   if (!fs.existsSync(archiveIndexPath)) return true;
 
   try {
-    const archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf-8")) as IndexFile;
+    const archiveIndex = JSON.parse(fs.readFileSync(archiveIndexPath, "utf8")) as IndexFile;
     if (archiveIndex.contexts[contextId]) {
       delete archiveIndex.contexts[contextId];
       archiveIndex.updated_at = nowIso();
@@ -709,8 +718,11 @@ function removeFromArchiveIndex(contextId: string, projectRoot?: string): boolea
       }
     }
     return true;
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("context_store", `Failed to read archive index: ${error}`);
     return false;
   }
 }
+
+
+

package/dist/templates/{_shared → core}/lib-ts/context/plan-manager.ts

@@ -10,12 +10,12 @@
 
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { atomicWrite } from "../base/atomic-write.js";
-import { getContextPlansDir, sanitizeTitle } from "../base/constants.js";
-import { logDebug, logInfo, logWarn, logError } from "../base/logger.js";
-import { generateSlug } from "../base/utils.js";
+import { atomicWrite } from "../runtime/atomic-write.js";
+import { getContextPlansDir, sanitizeTitle } from "../runtime/constants.js";
+import { logDebug, logInfo, logWarn, logError } from "../runtime/logger.js";
+import { generateSlug } from "../runtime/utils.js";
 
 // ---------------------------------------------------------------------------
 // Plan archival
@@ -42,14 +42,14 @@ export function archivePlan(
 
   let content: string;
   try {
-    content = fs.readFileSync(planPath, "utf-8");
-  } catch (error_: any) {
+    content = fs.readFileSync(planPath, "utf8");
+  } catch (error_: unknown) {
     logError("plan_manager", `Failed to read plan: ${error_}`);
     return [null, null, null];
   }
 
   // Compute hash and signature
-  const planHash = crypto.createHash("sha256").update(content, "utf-8").digest("hex").slice(0, 12);
+  const planHash = crypto.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 12);
   const planSignature = content.slice(0, 200);
 
   // Ensure plans directory exists
@@ -144,12 +144,12 @@ export function findLatestPlan(
   try {
     // Dynamic import to avoid circular dependency at module level
     // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic require to avoid circular dependency
-    const stateIo = require("../base/state-io.js");
+    const stateIo = require("../runtime/state-io.js");
     const state = stateIo.readStateJson(contextId, projectRoot);
     if (state?.plan_path && fs.existsSync(state.plan_path)) {
       return state.plan_path;
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("plan_manager", `Failed to check state.json plan_path: ${error}`);
   }
 
@@ -249,8 +249,8 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
 
   let lines: string[];
   try {
-    lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
-  } catch (error: any) {
+    lines = fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/);
+  } catch (error: unknown) {
     logWarn("plan_manager", `Failed to read transcript: ${error}`);
     return null;
   }
@@ -259,16 +259,17 @@ export function findPlanPathInTranscript(transcriptPath: string): string | null
     const line = lines[i]!.trim();
     if (!line) continue;
 
-    let data: any;
+    let data: unknown;
     try {
       data = JSON.parse(line);
     } catch {
       continue;
     }
 
-    let contentArr: any;
+    let contentArr: unknown;
     try {
-      contentArr = data.message?.content;
+      const message = (data as { message?: { content?: unknown } }).message;
+      contentArr = message?.content;
     } catch {
       continue;
     }
@@ -311,3 +312,6 @@ export function extractPlanPathFromResult(toolResult: string): string | null {
   const match = toolResult.match(/Your plan has been saved to:\s*(.+\.md)/);
   return match ? match[1]!.trim() : null;
 }
+
+
+

package/dist/templates/{_shared → core}/lib-ts/context/task-tracker.ts

@@ -6,9 +6,9 @@
  * Uses state-io for I/O to avoid circular imports with context-store.
  */
 
-import { logWarn } from "../base/logger.js";
-import { readStateJson, toDict as _toDict, writeStateJson } from "../base/state-io.js";
-import { nowIso } from "../base/utils.js";
+import { logWarn } from "../runtime/logger.js";
+import { readStateJson, toDict as _toDict, writeStateJson } from "../runtime/state-io.js";
+import { nowIso } from "../runtime/utils.js";
 import type { ContextState as _ContextState, Task } from "../types.js";
 
 // ---------------------------------------------------------------------------

package/dist/templates/core/lib-ts/hooks/context-monitor-logic.ts

@@ -0,0 +1,32 @@
+export const CONTEXT_WARNING_30 = "## Context Window: ~30% Remaining\n\n" +
+  "This session is approaching its context limit. Consider:\n\n" +
+  "- Completing your current task, then pausing for the user to decide next steps\n" +
+  "- If significant work remains, mention that `/aiwcli-shared:handoff` can capture progress " +
+  "for a fresh session\n\n" +
+  "Do not rush or cut corners — finish the current task properly. " +
+  "Just be aware that starting large new tasks may not complete before context runs out.";
+
+export const CONTEXT_WARNING_15 = "## Context Window: ~15% Remaining — Wrap Up Now\n\n" +
+  "Context is critically low. After completing your current step:\n\n" +
+  "1. **Stop taking on new work**\n" +
+  "2. Summarize what was accomplished and what remains\n" +
+  "3. Offer to run `/aiwcli-shared:handoff` so progress transfers to a fresh session\n\n" +
+  "Do not start new multi-step tasks. Focus on clean closure.";
+
+const WARNING_THRESHOLDS = [
+  { pct: 15, msg: CONTEXT_WARNING_15 },
+  { pct: 30, msg: CONTEXT_WARNING_30 },
+];
+
+export function selectWarningMessage(
+  pctRemaining: number,
+  alreadyFired: number[],
+): { pct: number; msg: string } | null {
+  for (const warning of WARNING_THRESHOLDS) {
+    if (pctRemaining <= warning.pct && !alreadyFired.includes(warning.pct)) {
+      return warning;
+    }
+  }
+
+  return null;
+}

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/hooks}/hook-utils.ts

@@ -6,10 +6,10 @@
 
 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";
+import { getContextBySessionId, maybeActivate } from "../context/context-store.js";
+import { getProjectRoot } from "../runtime/constants.js";
+import { logDebug,  logWarn,     hookLog, setSessionId,  getContextPath as _getContextPath } from "../runtime/logger.js";
+import type { ContextState, HookInput, HookOutput, PermissionRequestOutput } from "../types.js";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
 
@@ -24,7 +24,120 @@ let _lastToolName: string | null = null;
 let _cachedHookName: string | null = null;
 
 // Pre-fetched input stash
-let _prefetchedInput: Record<string, any> | null = null;
+let _prefetchedInput: Record<string, unknown> | null = null;
+
+function readStringField(value: Record<string, unknown>, key: string): null | string {
+  const field = value[key];
+  return typeof field === "string" ? field : null;
+}
+
+export interface BoundSessionContext {
+  payload: HookInput;
+  projectRoot: string;
+  sessionId: string;
+  state: ContextState;
+}
+
+export interface PersistenceContext extends BoundSessionContext {
+  toolInput: Record<string, unknown>;
+}
+
+export interface ToolInputContext {
+  payload: HookInput;
+  toolInput: Record<string, unknown>;
+}
+
+/**
+ * Load the current payload, resolve its project root, and require an already-bound session.
+ * Returns null when the hook should quietly no-op.
+ */
+export function requireBoundSession(
+  hookName: string,
+  prefetchedPayload?: HookInput | null,
+): BoundSessionContext | null {
+  const payload = prefetchedPayload ?? loadHookInput();
+  if (!payload) return null;
+
+  const sessionId = payload.session_id;
+  if (!sessionId) {
+    logDebug(hookName, "No session_id available");
+    return null;
+  }
+
+  const projectRoot = getProjectRoot(payload.cwd);
+  const state = getContextBySessionId(sessionId, projectRoot);
+  if (!state) {
+    logDebug(hookName, `No bound context for session ${sessionId.slice(0, 8)}`);
+    return null;
+  }
+
+  return { payload, projectRoot, sessionId, state };
+}
+
+/**
+ * Require a bound session plus tool_input for PostToolUse task persistence hooks.
+ */
+export function requirePersistenceContext(
+  expectedTool: string,
+  hookName: string,
+): PersistenceContext | null {
+  const bound = requireBoundSession(hookName);
+  if (!bound) return null;
+
+  const { payload } = bound;
+  if (payload.hook_event_name !== "PostToolUse") {
+    return null;
+  }
+  if (payload.tool_name !== expectedTool) {
+    return null;
+  }
+  if (checkSkipPersistence(payload, hookName)) {
+    return null;
+  }
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) {
+    logWarn(hookName, `${expectedTool} missing tool_input payload`);
+    return null;
+  }
+
+  return { ...bound, toolInput };
+}
+
+/**
+ * Require a tool_input payload for tool-oriented hooks without needing a bound session.
+ */
+export function requireToolInput(
+  hookName: string,
+): ToolInputContext | null {
+  const payload = loadHookInput();
+  if (!payload) return null;
+
+  const toolInput = getToolInput(payload);
+  if (!toolInput) {
+    logDebug(hookName, "No tool_input payload");
+    return null;
+  }
+
+  return { payload, toolInput };
+}
+
+/**
+ * Best-effort wrapper around maybeActivate. Hooks should never fail closed on activation.
+ */
+export function safeMaybeActivate(
+  contextId: string,
+  permissionMode: string,
+  projectRoot?: string,
+  hookName = "hook",
+): boolean {
+  try {
+    return maybeActivate(contextId, permissionMode, projectRoot, hookName);
+  } catch (error) {
+    logWarn(hookName, `maybeActivate failed for ${contextId}: ${error}`);
+    return false;
+  }
+}
 
 /**
  * Load and parse JSON from stdin (or return prefetched input if set).
@@ -36,23 +149,23 @@ export function loadHookInput(): HookInput | null {
     const result = _prefetchedInput;
     _prefetchedInput = null; // consume once
     if (result && typeof result === "object") {
-      _lastHookEvent = result.hook_event_name ?? null;
-      _lastToolName = result.tool_name ?? null;
+      _lastHookEvent = readStringField(result, "hook_event_name");
+      _lastToolName = readStringField(result, "tool_name");
     }
-    return result as HookInput;
+    return result as unknown as HookInput;
   }
 
   try {
     // Read entire stdin using fd 0 (cross-platform, works on Windows)
-    const inputData = fs.readFileSync(0, "utf-8").trim();
+    const inputData = fs.readFileSync(0, "utf8").trim();
     if (!inputData) return null;
 
-    const result = JSON.parse(inputData);
+    const result = JSON.parse(inputData) as Record<string, unknown>;
     if (result && typeof result === "object") {
-      _lastHookEvent = result.hook_event_name ?? null;
-      _lastToolName = result.tool_name ?? null;
+      _lastHookEvent = readStringField(result, "hook_event_name");
+      _lastToolName = readStringField(result, "tool_name");
     }
-    return result as HookInput;
+    return result as unknown as HookInput;
   } catch {
     return null;
   }
@@ -78,7 +191,7 @@ export function validateHookEvent(
  */
 export function getToolInput(
   payload: HookInput,
-): Record<string, any> | null {
+): Record<string, unknown> | null {
   const toolInput = payload.tool_input;
   return toolInput && typeof toolInput === "object" ? toolInput : null;
 }
@@ -95,7 +208,11 @@ export function checkSkipPersistence(
   if (!toolInput) return false;
 
   const {metadata} = toolInput;
-  if (metadata && typeof metadata === "object" && metadata.skip_persistence) {
+  if (
+    metadata &&
+    typeof metadata === "object" &&
+    Boolean((metadata as Record<string, unknown>).skip_persistence)
+  ) {
     logDebug(hookName, "Skipping persistence (skip_persistence flag set)");
     return true;
   }
@@ -167,12 +284,12 @@ export function emitContextAndBlock(
 }
 
 /** 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 {
+function _logEmit(type: "context" | "systemMessage" | "block", chars: number, payload: Record<string, unknown>): void {
   const hook = _cachedHookName ?? "unknown";
   const event = payload.event ?? "unknown";
   const mechanism = payload.mechanism ? ` via ${payload.mechanism}` : "";
   const msg = type === "block"
-    ? `HOOK_OUTPUT [${type}] ${event} ${chars} chars${mechanism}, reason="${(payload.blockReason ?? "").slice(0, 80)}"`
+    ? `HOOK_OUTPUT [${type}] ${event} ${chars} chars${mechanism}, reason="${String(payload.blockReason ?? "").slice(0, 80)}"`
     : `HOOK_OUTPUT [${type}] ${event} ${chars} chars`;
   hookLog("info", hook, msg, { data: payload });
 }
@@ -316,8 +433,13 @@ export function emitBlock(reason: string, context?: string): void {
  */
 function detectTemplate(scriptPath = ""): string {
   const p = (scriptPath || (process.argv[1] ?? "")).replaceAll('\\', "/");
-  if (p.includes("/_shared/hooks/") || p.startsWith("_shared/hooks/")) {
-    return "shared";
+  if (
+    p.includes("/_core/hooks-ts/") ||
+    p.startsWith("_core/hooks-ts/") ||
+    p.includes("/core/hooks-ts/") ||
+    p.startsWith("core/hooks-ts/")
+  ) {
+    return "core";
   }
   const match = p.match(/_([a-z][a-z0-9-]*)\/hooks\//);
   if (match?.[1]) return match[1]; // e.g., "cc-native"
@@ -390,32 +512,34 @@ export function getContextPercentRemaining(
  * Read stdin early and extract session_id + event metadata.
  * Stashes parsed input for loadHookInput() to consume later.
  */
-function _earlyReadInput(prefetchedInput?: Record<string, any>): void {
+function _earlyReadInput(prefetchedInput?: Record<string, unknown>): void {
   if (prefetchedInput !== undefined) {
     _prefetchedInput = prefetchedInput;
   }
 
   // If we already have prefetched input, extract metadata from it
   if (_prefetchedInput && typeof _prefetchedInput === "object") {
-    _lastHookEvent = _prefetchedInput.hook_event_name ?? null;
-    _lastToolName = _prefetchedInput.tool_name ?? null;
-    if (_prefetchedInput.session_id) {
-      setSessionId(_prefetchedInput.session_id);
+    _lastHookEvent = readStringField(_prefetchedInput, "hook_event_name");
+    _lastToolName = readStringField(_prefetchedInput, "tool_name");
+    const sessionId = readStringField(_prefetchedInput, "session_id");
+    if (sessionId) {
+      setSessionId(sessionId);
     }
     return;
   }
 
   // Read stdin now so HOOK_START can include sid
   try {
-    const inputData = fs.readFileSync(0, "utf-8").trim();
+    const inputData = fs.readFileSync(0, "utf8").trim();
     if (inputData) {
-      const parsed = JSON.parse(inputData);
+      const parsed = JSON.parse(inputData) as Record<string, unknown>;
       if (parsed && typeof parsed === "object") {
         _prefetchedInput = parsed;
-        _lastHookEvent = parsed.hook_event_name ?? null;
-        _lastToolName = parsed.tool_name ?? null;
-        if (parsed.session_id) {
-          setSessionId(parsed.session_id);
+        _lastHookEvent = readStringField(parsed, "hook_event_name");
+        _lastToolName = readStringField(parsed, "tool_name");
+        const sessionId = readStringField(parsed, "session_id");
+        if (sessionId) {
+          setSessionId(sessionId);
         }
       }
     }
@@ -431,7 +555,7 @@ function _earlyReadInput(prefetchedInput?: Record<string, any>): void {
 export function runHook(
   mainFunc: () => number | void,
   hookName = "unknown",
-  prefetchedInput?: Record<string, any>,
+  prefetchedInput?: Record<string, unknown>,
 ): never {
   _earlyReadInput(prefetchedInput);
   _cachedHookName = hookName;
@@ -439,7 +563,8 @@ export function runHook(
   // Ensure cwd is project root so relative paths in hooks resolve correctly,
   // even when cwd has drifted via `cd` in a Bash tool call.
   try {
-    const projectRoot = getProjectRoot(_prefetchedInput?.cwd);
+    const cwd = _prefetchedInput ? readStringField(_prefetchedInput, "cwd") ?? undefined : undefined;
+    const projectRoot = getProjectRoot(cwd);
     if (process.cwd() !== projectRoot) process.chdir(projectRoot);
   } catch { /* non-fatal — proceed with current cwd */ }
 
@@ -448,7 +573,7 @@ export function runHook(
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  const startData: Record<string, any> = {
+  const startData: Record<string, unknown> = {
     lifecycle: "start",
     template,
     event,
@@ -464,7 +589,7 @@ export function runHook(
     const result = mainFunc();
     exitCode = typeof result === "number" ? result : 0;
     status = exitCode !== 0 ? "blocked" : "success";
-  } catch (error: any) {
+  } catch (error: unknown) {
     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;
@@ -489,7 +614,7 @@ export function runHook(
 export function runHookAsync(
   mainFunc: () => Promise<number | void>,
   hookName = "unknown",
-  prefetchedInput?: Record<string, any>,
+  prefetchedInput?: Record<string, unknown>,
 ): void {
   _earlyReadInput(prefetchedInput);
   _cachedHookName = hookName;
@@ -497,7 +622,8 @@ export function runHookAsync(
   // Ensure cwd is project root so relative paths in hooks resolve correctly,
   // even when cwd has drifted via `cd` in a Bash tool call.
   try {
-    const projectRoot = getProjectRoot(_prefetchedInput?.cwd);
+    const cwd = _prefetchedInput ? readStringField(_prefetchedInput, "cwd") ?? undefined : undefined;
+    const projectRoot = getProjectRoot(cwd);
     if (process.cwd() !== projectRoot) process.chdir(projectRoot);
   } catch { /* non-fatal — proceed with current cwd */ }
 
@@ -506,7 +632,7 @@ export function runHookAsync(
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  const startData: Record<string, any> = {
+  const startData: Record<string, unknown> = {
     lifecycle: "start",
     template,
     event,
@@ -520,7 +646,7 @@ export function runHookAsync(
       _emitHookEnd(hookName, startTime, exitCode, exitCode !== 0 ? "blocked" : "success", null, startData, event, tool, template);
       _drainAndExit(exitCode);
     })
-    .catch((error: any) => {
+    .catch((error: unknown) => {
       let exitCode = 0;
       let status = "error";
       let errorInfo: [Error, string] | null = null;
@@ -547,7 +673,7 @@ function _emitHookEnd(
   exitCode: number,
   status: string,
   errorInfo: [Error, string] | null,
-  startData: Record<string, any>,
+  startData: Record<string, unknown>,
   event: string,
   tool: string | null,
   template: string,
@@ -561,7 +687,7 @@ function _emitHookEnd(
   const durationMs = Math.round((performance.now() - startTime) * 10) / 10;
   const endEvent = _lastHookEvent ?? event;
   const endTool = _lastToolName ?? tool;
-  const endData: Record<string, any> = {
+  const endData: Record<string, unknown> = {
     lifecycle: "end",
     status,
     duration_ms: durationMs,
@@ -602,4 +728,5 @@ function _drainAndExit(code: number): void {
   });
 }
 
-export {hookLog, logBlocking, logDebug, logDiagnostic, logError, logHookError, logInfo, logWarn, setContextPath, setSessionId} from "./logger.js";
+export {hookLog, logBlocking, logDebug, logDiagnostic, logError, logHookError, logInfo, logWarn, setContextPath, setSessionId} from "../runtime/logger.js";
+