aiwcli 0.10.3 → 0.11.0

package/dist/templates/_shared/lib-ts/base/atomic-write.ts

@@ -5,10 +5,10 @@
  * See SPEC.md §4
  */
 
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import * as _os from "node:os";
 import * as path from "node:path";
-import * as os from "node:os";
-import * as crypto from "node:crypto";
 
 /**
  * Write file atomically with retry logic.
@@ -21,7 +21,7 @@ export function atomicWrite(
   content: string,
   maxAttempts = 2,
   backoffMs: number[] = [500, 1000],
-): [boolean, string | null] {
+): [boolean, null | string] {
   // Ensure parent directory exists
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
@@ -53,7 +53,7 @@ export function atomicWrite(
       fs.renameSync(tmpPath, filePath);
 
       return [true, null];
-    } catch (e: any) {
+    } catch (error: any) {
       // Clean up temp file
       try {
         fs.unlinkSync(tmpPath);
@@ -62,11 +62,11 @@ export function atomicWrite(
       }
 
       if (attempt < maxAttempts - 1) {
-        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs[backoffMs.length - 1] ?? 500;
+        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
         sleepSync(waitMs);
       } else {
-        const errType = e?.constructor?.name ?? "Error";
-        const errMsg = String(e).split("\n")[0]?.slice(0, 200) ?? "";
+        const errType = error?.constructor?.name ?? "Error";
+        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
         return [false, `${errType}: ${errMsg}`];
       }
     }
@@ -85,7 +85,7 @@ export function atomicAppend(
   content: string,
   maxAttempts = 2,
   backoffMs: number[] = [500, 1000],
-): [boolean, string | null] {
+): [boolean, null | string] {
   // Ensure parent directory exists
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
@@ -112,13 +112,13 @@ export function atomicAppend(
       }
 
       return [true, null];
-    } catch (e: any) {
+    } catch (error: any) {
       if (attempt < maxAttempts - 1) {
-        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs[backoffMs.length - 1] ?? 500;
+        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
         sleepSync(waitMs);
       } else {
-        const errType = e?.constructor?.name ?? "Error";
-        const errMsg = String(e).split("\n")[0]?.slice(0, 200) ?? "";
+        const errType = error?.constructor?.name ?? "Error";
+        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
         return [false, `${errType}: ${errMsg}`];
       }
     }

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

@@ -3,8 +3,9 @@
  * See SPEC.md §2
  */
 
-import * as path from "node:path";
 import * as fs from "node:fs";
+import * as path from "node:path";
+
 import { logWarn } from "./logger.js";
 
 // Directory names (relative to project root)
@@ -28,9 +29,9 @@ export const RETRY_BACKOFF_MS = [500, 1000];
 
 // Windows reserved filenames
 const WINDOWS_RESERVED = new Set([
-  "CON", "PRN", "AUX", "NUL",
-  "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
-  "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+  "AUX", "COM1", "COM2", "COM3",
+  "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "CON", "LPT1", "LPT2",
+  "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", "NUL", "PRN",
 ]);
 
 /**
@@ -41,9 +42,9 @@ export function sanitizeContextId(contextId: string): string {
   if (!contextId) return "context";
 
   let result = contextId.toLowerCase();
-  result = result.replace(/[^a-z0-9_-]/g, "-");
-  result = result.replace(/[-_]+/g, "-");
-  result = result.replace(/^[-_]+|[-_]+$/g, "");
+  result = result.replaceAll(/[^a-z0-9_-]/g, "-");
+  result = result.replaceAll(/[-_]+/g, "-");
+  result = result.replaceAll(/^[-_]+|[-_]+$/g, "");
 
   if (result.length > MAX_CONTEXT_ID_LENGTH) {
     result = result.slice(0, MAX_CONTEXT_ID_LENGTH).replace(/[-_]+$/, "");
@@ -101,13 +102,18 @@ export function getProjectRoot(payloadCwd?: string): string {
     } else {
       return envDir;
     }
-  }
+  }
+
   if (payloadCwd) return payloadCwd;
   return process.cwd();
 }
 
 // §2.4 — Path functions
 
+export function getAiwcliDir(projectRoot?: string): string {
+  return path.join(projectRoot ?? getProjectRoot(), ".aiwcli");
+}
+
 export function getOutputDir(projectRoot?: string): string {
   return path.join(projectRoot ?? getProjectRoot(), OUTPUT_DIR);
 }
@@ -230,7 +236,8 @@ export function getHandoffFolderPath(
   while (fs.existsSync(folder)) {
     folder = path.join(handoffsDir, `${ts}-${counter}`);
     counter++;
-  }
+  }
+
   return folder;
 }
 
@@ -268,8 +275,8 @@ export function sanitizeFilename(
   maxLen = 32,
   allowLeadingDot = false,
 ): string {
-  let result = s.replace(/[^A-Za-z0-9._-]+/g, "_");
-  result = result.replace(/^[._-]+|[._-]+$/g, "").slice(0, maxLen) || "unknown";
+  let result = s.replaceAll(/[^A-Za-z0-9._-]+/g, "_");
+  result = result.replaceAll(/^[._-]+|[._-]+$/g, "").slice(0, maxLen) || "unknown";
 
   if (!allowLeadingDot) {
     result = result.replace(/^\.+/, "");
@@ -285,10 +292,10 @@ export function sanitizeFilename(
 
 export function sanitizeTitle(s: string, maxLen = 50): string {
   let result = s.toLowerCase().trim();
-  result = result.replace(/ /g, "-");
-  result = result.replace(/[^a-z0-9._-]+/g, "_");
-  result = result.replace(/[-_]+/g, "-");
-  result = result.replace(/^[._-]+|[._-]+$/g, "").slice(0, maxLen) || "unknown";
+  result = result.replaceAll(' ', "-");
+  result = result.replaceAll(/[^a-z0-9._-]+/g, "_");
+  result = result.replaceAll(/[-_]+/g, "-");
+  result = result.replaceAll(/^[._-]+|[._-]+$/g, "").slice(0, maxLen) || "unknown";
 
   const baseName = (result.split(".")[0] ?? result).toUpperCase();
   if (WINDOWS_RESERVED.has(baseName)) {

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

@@ -5,24 +5,26 @@
  */
 
 import * as fs from "node:fs";
-import { logDebug, logInfo, logWarn, logError, logHookError, logDiagnostic, hookLog, setContextPath, getContextPath as _getContextPath } from "./logger.js";
+
 import { getProjectRoot } from "./constants.js";
+import { getContextPath as _getContextPath, hookLog, logDebug, setSessionId } from "./logger.js";
 import { getContextBySessionId } from "../context/context-store.js";
 import type { HookInput, HookOutput } from "../types.js";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
-export { logDebug, logInfo, logWarn, logError, logHookError, logDiagnostic, hookLog, setContextPath };
+
 
 // Context window baseline: tokens not visible in hook data §5.9
 export const CONTEXT_BASELINE_TOKENS = 22_600;
 export const DEFAULT_CONTEXT_WINDOW_SIZE = 200_000;
 
 // Event metadata stash — populated by loadHookInput(), read by runHook()
-let _lastHookEvent: string | null = null;
-let _lastToolName: string | null = null;
+let _lastHookEvent: null | string = null;
+let _lastToolName: null | string = null;
+let _cachedHookName: null | string = null;
 
 // Pre-fetched input stash
-let _prefetchedInput: Record<string, any> | null = null;
+let _prefetchedInput: null | Record<string, any> = null;
 
 /**
  * Load and parse JSON from stdin (or return prefetched input if set).
@@ -37,12 +39,13 @@ export function loadHookInput(): HookInput | null {
       _lastHookEvent = result.hook_event_name ?? null;
       _lastToolName = result.tool_name ?? null;
     }
+
     return result 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);
@@ -50,6 +53,7 @@ export function loadHookInput(): HookInput | null {
       _lastHookEvent = result.hook_event_name ?? null;
       _lastToolName = result.tool_name ?? null;
     }
+
     return result as HookInput;
   } catch {
     return null;
@@ -76,7 +80,7 @@ export function validateHookEvent(
  */
 export function getToolInput(
   payload: HookInput,
-): Record<string, any> | null {
+): null | Record<string, any> {
   const toolInput = payload.tool_input;
   return toolInput && typeof toolInput === "object" ? toolInput : null;
 }
@@ -92,53 +96,76 @@ 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;
   }
+
   return false;
 }
 
 /**
  * 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).
  * See SPEC.md §5.5
  */
 export function emitContext(additionalContext: string): void {
+  const eventName = _lastHookEvent ?? undefined;
   const out: HookOutput = {
     hookSpecificOutput: {
+      ...(eventName ? { hookEventName: eventName } : {}),
       additionalContext,
     },
   };
-  process.stdout.write(JSON.stringify(out) + "\n");
+  const json = JSON.stringify(out);
+  _logEmit("context", additionalContext.length, { additionalContext });
+  process.stdout.write(json + "\n");
 }
 
 /**
  * Emit hookSpecificOutput that denies the tool call with context and reason.
+ * hookEventName is required by Claude Code's Zod validator (discriminated union).
+ * Auto-detected from stdin payload (set by loadHookInput/runHook).
  * See SPEC.md §5.6
  */
 export function emitContextAndBlock(
   additionalContext: string,
   reason: string,
 ): void {
+  const eventName = _lastHookEvent ?? undefined;
   const out: HookOutput = {
     hookSpecificOutput: {
+      ...(eventName ? { hookEventName: eventName } : {}),
       additionalContext,
       permissionDecision: "deny",
       permissionDecisionReason: reason,
     },
   };
-  process.stdout.write(JSON.stringify(out) + "\n");
+  const json = JSON.stringify(out);
+  _logEmit("block", additionalContext.length, { additionalContext, blockReason: reason });
+  process.stdout.write(json + "\n");
+}
+
+/** Log hook output (context or block) to hook-log.jsonl for visibility. */
+function _logEmit(type: "block" | "context", chars: number, payload: Record<string, any>): void {
+  const hook = _cachedHookName ?? "unknown";
+  const msg = type === "block"
+    ? `HOOK_OUTPUT [${type}] ${chars} chars, reason="${(payload.blockReason ?? "").slice(0, 80)}"`
+    : `HOOK_OUTPUT [${type}] ${chars} chars`;
+  hookLog("info", hook, msg, { data: payload });
 }
 
 /**
  * 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";
   }
+
   const match = p.match(/_([a-z][a-z0-9-]*)\/hooks\//);
   if (match?.[1]) return match[1]; // e.g., "cc-native"
   return "unknown";
@@ -151,7 +178,7 @@ function detectTemplate(scriptPath = ""): string {
  */
 export function parseContextWindow(
   hookInput: HookInput,
-): [number | null, number | null] {
+): [null | number, null | number] {
   const contextWindow = hookInput.context_window;
   if (!contextWindow) return [null, null];
 
@@ -177,7 +204,7 @@ export function parseContextWindow(
  */
 export function getContextPercentRemaining(
   hookInput: HookInput,
-): [number | null, number | null, number | null] {
+): [null | number, null | number, null | number] {
   const [tokensUsed, maxTokens] = parseContextWindow(hookInput);
 
   if (tokensUsed !== null && maxTokens !== null && maxTokens > 0) {
@@ -206,6 +233,45 @@ export function getContextPercentRemaining(
   return [null, null, null];
 }
 
+/**
+ * Read stdin early and extract session_id + event metadata.
+ * Stashes parsed input for loadHookInput() to consume later.
+ */
+function _earlyReadInput(prefetchedInput?: Record<string, any>): 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);
+    }
+
+    return;
+  }
+
+  // Read stdin now so HOOK_START can include sid
+  try {
+    const inputData = fs.readFileSync(0, "utf8").trim();
+    if (inputData) {
+      const parsed = JSON.parse(inputData);
+      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);
+        }
+      }
+    }
+  } catch {
+    // Non-fatal — loadHookInput will return null
+  }
+}
+
 /**
  * Standard hook entry point with lifecycle logging.
  * See SPEC.md §5.7
@@ -215,23 +281,21 @@ export function runHook(
   hookName = "unknown",
   prefetchedInput?: Record<string, any>,
 ): never {
-  if (prefetchedInput !== undefined) {
-    _prefetchedInput = prefetchedInput;
-  }
+  _earlyReadInput(prefetchedInput);
+  _cachedHookName = hookName;
 
   const startTime = performance.now();
   const template = detectTemplate();
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  // HOOK_START
   const startData: Record<string, any> = {
     lifecycle: "start",
     template,
     event,
   };
   if (tool) startData.tool = tool;
-  logInfo(hookName, "HOOK_START", { data: startData });
+  hookLog("info", hookName, "HOOK_START", { data: startData });
 
   let exitCode = 0;
   let status = "success";
@@ -240,17 +304,17 @@ export function runHook(
   try {
     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;
+    status = exitCode === 0 ? "success" : "blocked";
+  } 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];
     }
   }
 
@@ -268,47 +332,45 @@ export function runHookAsync(
   hookName = "unknown",
   prefetchedInput?: Record<string, any>,
 ): void {
-  if (prefetchedInput !== undefined) {
-    _prefetchedInput = prefetchedInput;
-  }
+  _earlyReadInput(prefetchedInput);
+  _cachedHookName = hookName;
 
   const startTime = performance.now();
   const template = detectTemplate();
   const event = _lastHookEvent ?? "unknown";
   const tool = _lastToolName;
 
-  // HOOK_START
   const startData: Record<string, any> = {
     lifecycle: "start",
     template,
     event,
   };
   if (tool) startData.tool = tool;
-  logInfo(hookName, "HOOK_START", { data: startData });
+  hookLog("info", hookName, "HOOK_START", { data: startData });
 
   mainFunc()
     .then((result) => {
       const exitCode = typeof result === "number" ? result : 0;
-      _emitHookEnd(hookName, startTime, exitCode, exitCode !== 0 ? "blocked" : "success", null, startData, event, tool, template);
-      process.exit(exitCode);
+      _emitHookEnd(hookName, startTime, exitCode, exitCode === 0 ? "success" : "blocked", 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);
-      process.exit(exitCode);
+      _drainAndExit(exitCode);
     });
 }
 
@@ -321,17 +383,13 @@ function _emitHookEnd(
   errorInfo: [Error, string] | null,
   startData: Record<string, any>,
   event: string,
-  tool: string | null,
+  tool: null | string,
   template: string,
 ): void {
-  // Retroactive HOOK_START to per-context log
+  // Retroactive HOOK_START to per-context log (context_path resolved after main runs)
   const resolvedAfter = _getContextPath();
   if (resolvedAfter && fs.existsSync(resolvedAfter)) {
-    hookLog("info", hookName, "HOOK_START", {
-      data: startData,
-      context_path: resolvedAfter,
-      stderr: false,
-    });
+    hookLog("info", hookName, "HOOK_START", { data: startData });
   }
 
   const durationMs = Math.round((performance.now() - startTime) * 10) / 10;
@@ -350,11 +408,32 @@ function _emitHookEnd(
   if (errorInfo) {
     const [err, tb] = errorInfo;
     endData.error_type = err.constructor.name;
-    logHookError(hookName, err, endEvent, tb);
-    logError(hookName, `HOOK_END: ${err}`, { data: endData, 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") {
-    logWarn(hookName, "HOOK_END", { data: endData });
+    hookLog("warn", hookName, "HOOK_END", { data: endData });
   } else {
-    logInfo(hookName, "HOOK_END", { data: endData });
+    hookLog("info", hookName, "HOOK_END", { data: endData });
   }
 }
+
+/**
+ * Drain stdout before exiting to ensure pipe consumers receive all data.
+ * On Windows, stdout to a pipe is fully buffered — process.exit() can
+ * discard unflushed data. This waits for the write buffer to drain.
+ */
+function _drainAndExit(code: number): void {
+  // If stdout is already finished or not writable, exit immediately
+  if (!process.stdout.writable || process.stdout.writableFinished) {
+    process.exit(code);
+  }
+
+  // Attempt to end stdout and wait for drain
+  const timeout = setTimeout(() => process.exit(code), 1000); // safety fallback
+  process.stdout.end(() => {
+    clearTimeout(timeout);
+    process.exit(code);
+  });
+}
+
+export {hookLog, logBlocking, logDebug, logDiagnostic, logError, logHookError, logInfo, logWarn, setContextPath, setSessionId} from "./logger.js";

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

@@ -5,6 +5,7 @@
  */
 
 import { execFileSync } from "node:child_process";
+
 import { logDebug, logWarn } from "./logger.js";
 import { STOP_WORDS } from "./stop-words.js";
 import { cleanTextForSlug } from "./utils.js";
@@ -44,19 +45,25 @@ export function inference(
 
   try {
     const isWin = process.platform === "win32";
-    let stdout: string;
+    // On Windows with shell:true, Node.js sets windowsVerbatimArguments —
+    // args are joined with spaces, NOT individually quoted. We must manually
+    // wrap multi-word/special-char args in "..." for cmd.exe parsing.
+    // Inside double quotes: "" = literal ", and |&<> are safe.
+    const empty = isWin ? '""' : "";
+    let promptArg = fullPrompt;
+    if (isWin) {
+      promptArg = '"' + fullPrompt.replaceAll(/\r?\n/g, " ").replaceAll('"', '""') + '"';
+    }
 
-    // Use execFileSync with shell option on Windows for safe argument passing
-    // (no string interpolation — avoids command injection)
-    stdout = execFileSync(
+    const stdout = execFileSync(
       "claude",
-      ["--model", model, "--print", "--setting-sources", "", "-p", fullPrompt],
+      ["--model", model, "--print", "--setting-sources", empty, "-p", promptArg],
       {
         timeout: timeoutSec * 1000,
         env,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
-        shell: isWin, // Windows needs shell for command resolution
+        shell: isWin, // Windows needs shell for .cmd resolution
       },
     );
 
@@ -66,10 +73,10 @@ export function inference(
       output: stdout.trim(),
       latency_ms: latencyMs,
     };
-  } catch (e: any) {
+  } catch (error: any) {
     const latencyMs = Date.now() - startTime;
 
-    if (e.code === "ETIMEDOUT" || e.killed) {
+    if (error.code === "ETIMEDOUT" || error.killed) {
       return {
         success: false,
         output: "",
@@ -78,7 +85,7 @@ export function inference(
       };
     }
 
-    if (e.code === "ENOENT") {
+    if (error.code === "ENOENT") {
       return {
         success: false,
         output: "",
@@ -88,11 +95,11 @@ export function inference(
     }
 
     // Non-zero exit code
-    if (e.status !== undefined && e.status !== 0) {
+    if (error.status !== undefined && error.status !== 0) {
       return {
         success: false,
-        output: (e.stdout ?? "").toString().trim(),
-        error: (e.stderr ?? "").toString().trim() || `Exit code: ${e.status}`,
+        output: (error.stdout ?? "").toString().trim(),
+        error: (error.stderr ?? "").toString().trim() || `Exit code: ${error.status}`,
         latency_ms: latencyMs,
       };
     }
@@ -100,7 +107,7 @@ export function inference(
     return {
       success: false,
       output: "",
-      error: String(e),
+      error: String(error),
       latency_ms: latencyMs,
     };
   }
@@ -126,13 +133,13 @@ Output ONLY the keywords separated by spaces, nothing else.`;
 export function generateSemanticSummary(
   prompt: string,
   timeout = 15,
-): string | null {
+): null | string {
   const result = inference(CONTEXT_ID_SYSTEM_PROMPT, prompt, "standard", timeout);
 
   if (!result.success || !result.output) return null;
 
   let summary = result.output.trim();
-  summary = summary.replace(/^["']+|["']+$/g, "");
+  summary = summary.replaceAll(/^["']+|["']+$/g, "");
   summary = summary.replace(/[.!?]+$/, "");
 
   // Filter stop words
@@ -187,7 +194,7 @@ Respond with ONLY a JSON object: {"slug": "your 8-12 word phrase here"}`;
 export function generateContextIdSlug(
   prompt: string,
   timeout = 3,
-): string | null {
+): null | string {
   const truncated = prompt.slice(0, 500);
 
   const result = inference(CONTEXT_ID_SLUG_PROMPT, truncated, "fast", timeout);
@@ -200,7 +207,7 @@ export function generateContextIdSlug(
   const raw = result.output.trim();
 
   // Parse JSON response, fall back to raw text
-  let slug: string | null = null;
+  let slug: null | string = null;
   try {
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && "slug" in parsed) {
@@ -213,11 +220,11 @@ export function generateContextIdSlug(
   if (!slug) slug = raw;
 
   // Clean up
-  slug = slug.replace(/^["'`]+|["'`]+$/g, "");
+  slug = slug.replaceAll(/^["'`]+|["'`]+$/g, "");
   slug = slug.replace(/[.!?]+$/, "");
-  slug = slug.replace(/-/g, " ");
-  slug = slug.replace(/[^a-zA-Z0-9 ]/g, "");
-  slug = slug.replace(/\s+/g, " ").trim();
+  slug = slug.replaceAll('-', " ");
+  slug = slug.replaceAll(/[^a-zA-Z0-9 ]/g, "");
+  slug = slug.replaceAll(/\s+/g, " ").trim();
 
   const words = slug.split(" ");