aiwcli 0.12.8 → 0.13.1

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/retrieval-pipeline.ts

@@ -13,6 +13,11 @@
  */
 
 import { z } from "zod";
+
+import { hydeQueryEmbedding } from "./hyde.js";
+import { logInfo, logWarn, logError } from "./logger.js";
+import { checkOllamaHealth, embedOne } from "./ollama-client.js";
+import { loadTranscript } from "./transcript-loader.js";
 import {
   VECTOR_TOP_K,
   MAX_PARALLEL_SUMMARIZERS,
@@ -26,11 +31,7 @@ import {
   type RankedSession,
   type RetrievalResult,
 } from "./types.js";
-import { logInfo, logWarn, logError, logDebug } from "./logger.js";
-import { checkOllamaHealth, embedOne } from "./ollama-client.js";
 import { openVectorDb, searchKnn } from "./vector-store.js";
-import { loadTranscript } from "./transcript-loader.js";
-import { hydeQueryEmbedding } from "./hyde.js";
 
 const HOOK_NAME = "rlm_retrieve";
 
@@ -78,10 +79,12 @@ if (!query) {
   );
   process.exitCode = 1;
 } else {
-  runPipeline(query, topK, projectFilter).catch((e) => {
-    logError(HOOK_NAME, `Fatal: ${e}`, { stderr: true });
+  try {
+    await runPipeline(query, topK, projectFilter);
+  } catch (error) {
+    logError(HOOK_NAME, `Fatal: ${error}`, { stderr: true });
     process.exitCode = 1;
-  });
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -127,8 +130,8 @@ async function runPipeline(
       });
       hydeTiming = Date.now() - hydeStart;
       logInfo(HOOK_NAME, `HyDE query embedding completed in ${hydeTiming}ms`);
-    } catch (e) {
-      logWarn(HOOK_NAME, `HyDE failed: ${e}, falling back to direct query embedding`);
+    } catch (error) {
+      logWarn(HOOK_NAME, `HyDE failed: ${error}, falling back to direct query embedding`);
       queryEmbedding = await embedOne(query);
     }
   } else {
@@ -182,7 +185,7 @@ async function runPipeline(
       }
     }
   }
-  const sessions = Array.from(sessionMap.values());
+  const sessions = [...sessionMap.values()];
   logInfo(
     HOOK_NAME,
     `Stage 2: ${results.length} chunks → ${sessions.length} sessions`,
@@ -254,10 +257,10 @@ async function summarizeSessions(
     const promises = batch.map(async (session) => {
       try {
         return await summarizeOneSession(query, session);
-      } catch (e) {
+      } catch (error) {
         logWarn(
           HOOK_NAME,
-          `Summarize failed for ${session.result.session_id}: ${e}`,
+          `Summarize failed for ${session.result.session_id}: ${error}`,
         );
         return null;
       }
@@ -397,8 +400,8 @@ async function rankSessions(
         key_findings: r.key_findings,
       };
     }).filter((r): r is RankedSession => r !== null);
-  } catch (e) {
-    logWarn(HOOK_NAME, `Rank parse failed: ${e}, marking all as relevant`);
+  } catch (error) {
+    logWarn(HOOK_NAME, `Rank parse failed: ${error}, marking all as relevant`);
     return summaries.map((s) => ({
       session_id: s.session_id,
       project: s.project,

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-indexer.ts

@@ -12,18 +12,18 @@
  *   bun transcript-indexer.ts --batch --project=aiwcli   # Index matching project only
  */
 
-import { readdir, stat, mkdir, readFile, writeFile } from "fs/promises";
-import { createReadStream, existsSync, readFileSync } from "fs";
-import { join, basename } from "path";
-import { createInterface } from "readline";
+import { createReadStream, existsSync } from "node:fs";
+import { readdir, stat, mkdir, writeFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { createInterface } from "node:readline";
+
+import { logInfo, logWarn, logError } from "./logger.js";
 import {
   CURRENT_SCHEMA_VERSION,
   CLAUDE_PROJECTS_DIR,
   RLM_INDEX_DIR,
   type SessionIndex,
-  type IndexSegment,
 } from "./types.js";
-import { logInfo, logWarn, logError, logDebug } from "./logger.js";
 
 const HOOK_NAME = "rlm_indexer";
 
@@ -39,10 +39,12 @@ const projectArg = args.find((a) => a.startsWith("--project="));
 const projectFilter = projectArg ? projectArg.split("=")[1] : null;
 
 if (isBatch) {
-  runBatch().catch((e) => {
-    logError(HOOK_NAME, `Fatal: ${e}`, { stderr: true });
+  try {
+    await runBatch();
+  } catch (error) {
+    logError(HOOK_NAME, `Fatal: ${error}`, { stderr: true });
     process.exitCode = 1;
-  });
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -89,22 +91,24 @@ async function discoverSessions(): Promise<SessionFile[]> {
   return sessions;
 }
 
-function needsIndexing(session: SessionFile, sourceMtime: number): boolean {
+function needsIndexing(session: SessionFile, _sourceMtime: number): boolean {
   const indexPath = join(RLM_INDEX_DIR, session.project, `${session.sessionId}.index.json`);
   if (!existsSync(indexPath)) return true;
   try {
     // Fast path: Read only first 100 bytes to check schema_version
     // If version matches, skip without checking mtime (schema bumps trigger full reindex anyway)
-    const fd = require("fs").openSync(indexPath, "r");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic fs for perf
+    const nodeFs = require("node:fs");
+    const fd = nodeFs.openSync(indexPath, "r");
     const buffer = Buffer.alloc(100);
-    const bytesRead = require("fs").readSync(fd, buffer, 0, 100, 0);
-    require("fs").closeSync(fd);
+    const bytesRead = nodeFs.readSync(fd, buffer, 0, 100, 0);
+    nodeFs.closeSync(fd);
 
     const partial = buffer.toString("utf-8", 0, bytesRead);
     const versionMatch = partial.match(/"schema_version"\s*:\s*(\d+)/);
 
     // If version matches, skip (no mtime check needed - schema version bump handles major changes)
-    if (versionMatch && parseInt(versionMatch[1]) === CURRENT_SCHEMA_VERSION) {
+    if (versionMatch && parseInt(versionMatch[1], 10) === CURRENT_SCHEMA_VERSION) {
       return false; // Skip - index is current
     }
 
@@ -152,9 +156,9 @@ async function runBatch(): Promise<void> {
       if (indexed % 10 === 0 || indexed === 1) {
         logInfo(HOOK_NAME, `Indexing: ${indexed} indexed, ${skipped} skipped, ${errors} errors (of ${allSessions.length} total)`, { stderr: true });
       }
-    } catch (e) {
+    } catch (error) {
       errors++;
-      logError(HOOK_NAME, `Error indexing ${session.sessionId}: ${e}`);
+      logError(HOOK_NAME, `Error indexing ${session.sessionId}: ${error}`);
     }
   }
 
@@ -234,7 +238,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
         index.user_message_count++;
         const msg = obj.message as Record<string, unknown> | undefined;
         if (msg) {
-          const content = msg.content;
+          const {content} = msg;
           if (typeof content === "string") {
             const snippet = content.slice(0, 200);
             userSnippets.push(snippet);
@@ -244,7 +248,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
           } else if (Array.isArray(content)) {
             for (const block of content) {
               if (typeof block === "object" && block !== null && "text" in block) {
-                const text = (block as Record<string, unknown>).text;
+                const {text} = (block as Record<string, unknown>);
                 if (typeof text === "string") {
                   extractKeywords(text, keywordBag);
                   extractKeywords(text, segmentKeywordBag);
@@ -255,8 +259,8 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
           // Extract cwd for context
           const cwd = obj.cwd as string | undefined;
           if (cwd) {
-            const parts = cwd.replace(/\\/g, "/").split("/");
-            const last = parts[parts.length - 1];
+            const parts = cwd.replaceAll('\\', "/").split("/");
+            const last = parts.at(-1);
             if (last) addKeyword(keywordBag, last);
           }
           // Git branch
@@ -269,7 +273,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
         index.assistant_message_count++;
         const msg = obj.message as Record<string, unknown> | undefined;
         if (msg) {
-          const content = msg.content;
+          const {content} = msg;
           if (Array.isArray(content)) {
             for (const block of content) {
               if (typeof block !== "object" || block === null) continue;
@@ -340,19 +344,19 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
 // ---------------------------------------------------------------------------
 
 const STOP_WORDS = new Set([
-  "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
-  "have", "has", "had", "do", "does", "did", "will", "would", "shall",
-  "should", "may", "might", "must", "can", "could", "of", "in", "to",
-  "for", "with", "on", "at", "from", "by", "about", "as", "into",
-  "through", "during", "before", "after", "above", "below", "between",
-  "and", "but", "or", "nor", "not", "no", "so", "yet", "both", "either",
-  "neither", "each", "every", "all", "any", "few", "more", "most", "other",
-  "some", "such", "than", "too", "very", "just", "also", "now", "then",
-  "here", "there", "when", "where", "why", "how", "what", "which", "who",
-  "this", "that", "these", "those", "it", "its", "i", "me", "my", "we",
-  "our", "you", "your", "he", "she", "they", "them", "their", "if",
-  "true", "false", "null", "undefined", "function", "return", "const",
-  "let", "var", "import", "export", "default", "class", "new", "type",
+  "a", "about", "above", "after", "all", "also", "an", "and", "any", "are",
+  "as", "at", "be", "been", "before", "being", "below", "between", "both",
+  "but", "by", "can", "class", "const", "could", "default", "did", "do",
+  "does", "during", "each", "either", "every", "export", "false", "few", "for",
+  "from", "function", "had", "has", "have", "he", "here",
+  "how", "i", "if", "import", "in", "into", "is", "it", "its", "just",
+  "let", "may", "me", "might", "more", "most", "must", "my", "neither",
+  "new", "no", "nor", "not", "now", "null", "of", "on", "or",
+  "other", "our", "return", "shall", "she", "should", "so", "some", "such",
+  "than", "that", "the", "their", "them", "then", "there", "these", "they", "this",
+  "those", "through", "to", "too", "true", "type", "undefined", "var", "very",
+  "was", "we", "were", "what", "when", "where", "which",
+  "who", "why", "will", "with", "would", "yet", "you", "your",
 ]);
 
 function extractKeywords(text: string, bag: Map<string, number>): void {
@@ -391,9 +395,9 @@ function extractToolMetadata(
   // File paths from Read, Edit, Write, Glob
   const filePath = input.file_path as string | undefined;
   if (filePath) {
-    const normalized = filePath.replace(/\\/g, "/");
+    const normalized = filePath.replaceAll('\\', "/");
     const parts = normalized.split("/");
-    const fileName = parts[parts.length - 1];
+    const fileName = parts.at(-1);
     if (fileName) {
       files.add(fileName);
       addKeyword(keywords, fileName.replace(/\.[^.]+$/, "")); // stem
@@ -443,4 +447,4 @@ async function writeIndex(project: string, sessionId: string, index: SessionInde
 // Exports for programmatic use
 // ---------------------------------------------------------------------------
 
-export { discoverSessions, indexSession, writeIndex, needsIndexing, runBatch };
+export { discoverSessions, indexSession, needsIndexing, runBatch, writeIndex };

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-loader.ts

@@ -11,11 +11,12 @@
  *   bun transcript-loader.ts <jsonl-path> --lines=46-120
  */
 
-import { createReadStream } from "fs";
-import { createInterface } from "readline";
-import { basename } from "path";
+import { createReadStream } from "node:fs";
+import { basename } from "node:path";
+import { createInterface } from "node:readline";
+
+import { logInfo, logError } from "./logger.js";
 import { MAX_LOADER_CHARS, type LoadedSegment } from "./types.js";
-import { logInfo, logWarn, logError } from "./logger.js";
 
 const HOOK_NAME = "rlm_loader";
 
@@ -35,17 +36,16 @@ if (linesArg) {
 }
 
 if (jsonlPath && !process.env.RLM_LIB_MODE) {
-  loadTranscript(jsonlPath, lineRange)
-    .then((seg) => {
-      process.stdout.write(seg.content);
-      if (seg.truncated) {
-        logInfo(HOOK_NAME, "Output truncated at 50K chars", { stderr: true });
-      }
-    })
-    .catch((e) => {
-      logError(HOOK_NAME, `Load failed: ${e}`, { stderr: true });
-      process.exitCode = 1;
-    });
+  try {
+    const seg = await loadTranscript(jsonlPath, lineRange);
+    process.stdout.write(seg.content);
+    if (seg.truncated) {
+      logInfo(HOOK_NAME, "Output truncated at 50K chars", { stderr: true });
+    }
+  } catch (error) {
+    logError(HOOK_NAME, `Load failed: ${error}`, { stderr: true });
+    process.exitCode = 1;
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -135,9 +135,9 @@ async function loadTranscript(
   }
 
   // Derive project from path
-  const pathParts = filePath.replace(/\\/g, "/").split("/");
+  const pathParts = filePath.replaceAll('\\', "/").split("/");
   const projectsIdx = pathParts.indexOf("projects");
-  if (projectsIdx >= 0 && projectsIdx + 1 < pathParts.length) {
+  if (projectsIdx !== -1 && projectsIdx + 1 < pathParts.length) {
     project = pathParts[projectsIdx + 1];
   }
 
@@ -155,7 +155,7 @@ async function loadTranscript(
 // ---------------------------------------------------------------------------
 
 function extractContent(msg: Record<string, unknown>): string | null {
-  const content = msg.content;
+  const {content} = msg;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     const texts: string[] = [];
@@ -187,7 +187,7 @@ function extractAssistantContent(msg: Record<string, unknown>): {
   text: string;
   toolUses: ToolUse[];
 } {
-  const content = msg.content;
+  const {content} = msg;
   let text = "";
   const toolUses: ToolUse[] = [];
 
@@ -219,26 +219,36 @@ function extractAssistantContent(msg: Record<string, unknown>): {
 function summarizeToolInput(toolName: string, input?: Record<string, unknown>): string {
   if (!input) return "";
   switch (toolName) {
-    case "Read":
-      return input.file_path ? `${input.file_path}` : "";
-    case "Write":
-      return input.file_path ? `${input.file_path}` : "";
-    case "Edit":
-      return input.file_path ? `${input.file_path}` : "";
-    case "Bash":
+    case "Bash": {
       return input.command ? `${(input.command as string).slice(0, 80)}` : "";
-    case "Glob":
+    }
+    case "Edit": {
+      return input.file_path ? `${input.file_path}` : "";
+    }
+    case "Glob": {
       return input.pattern ? `${input.pattern}` : "";
-    case "Grep":
+    }
+    case "Grep": {
       return input.pattern ? `/${input.pattern}/` : "";
-    case "Task":
+    }
+    case "Read": {
+      return input.file_path ? `${input.file_path}` : "";
+    }
+    case "Task": {
       return input.description ? `${input.description}` : "";
-    case "WebSearch":
-      return input.query ? `"${input.query}"` : "";
-    case "WebFetch":
+    }
+    case "WebFetch": {
       return input.url ? `${input.url}` : "";
-    default:
+    }
+    case "WebSearch": {
+      return input.query ? `"${input.query}"` : "";
+    }
+    case "Write": {
+      return input.file_path ? `${input.file_path}` : "";
+    }
+    default: {
       return Object.keys(input).slice(0, 3).join(", ");
+    }
   }
 }
 

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-searcher.ts

@@ -11,12 +11,11 @@
  *   bun transcript-searcher.ts "plan review" --project=aiwcli
  */
 
-import { readdir, readFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-import { logInfo, logWarn, logError, logDebug } from "./logger.js";
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
 
-const HOOK_NAME = "rlm_searcher";
+import { logInfo, logWarn, logError } from "./logger.js";
 import {
   CURRENT_SCHEMA_VERSION,
   CLAUDE_PROJECTS_DIR,
@@ -28,6 +27,8 @@ import {
   type IndexSegment,
 } from "./types.js";
 
+const HOOK_NAME = "rlm_searcher";
+
 // ---------------------------------------------------------------------------
 // CLI entry
 // ---------------------------------------------------------------------------
@@ -40,20 +41,19 @@ const projectArg = args.find((a) => a.startsWith("--project="));
 const projectFilter = projectArg ? projectArg.split("=")[1] : null;
 
 if (query && !process.env.RLM_LIB_MODE) {
-  search(query, { topN, projectFilter })
-    .then((results) => {
-      if (typeof results === "string") {
-        logWarn(HOOK_NAME, results, { stderr: true });
-        process.exitCode = 1;
-      } else {
-        logInfo(HOOK_NAME, `Search returned ${results.length} results`);
-        process.stdout.write(JSON.stringify(results, null, 2) + "\n");
-      }
-    })
-    .catch((e) => {
-      logError(HOOK_NAME, `Search failed: ${e}`, { stderr: true });
+  try {
+    const results = await search(query, { topN, projectFilter });
+    if (typeof results === "string") {
+      logWarn(HOOK_NAME, results, { stderr: true });
       process.exitCode = 1;
-    });
+    } else {
+      logInfo(HOOK_NAME, `Search returned ${results.length} results`);
+      process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+    }
+  } catch (error) {
+    logError(HOOK_NAME, `Search failed: ${error}`, { stderr: true });
+    process.exitCode = 1;
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -251,7 +251,7 @@ function tokenize(query: string): string[] {
   return query
     .toLowerCase()
     .split(/\s+/)
-    .map((t) => t.replace(/[^a-z0-9_-]/g, ""))
+    .map((t) => t.replaceAll(/[^a-z0-9_-]/g, ""))
     .filter((t) => t.length >= 2);
 }
 
@@ -271,4 +271,4 @@ function insertSorted(arr: SearchResult[], item: SearchResult, maxSize: number):
 // Exports
 // ---------------------------------------------------------------------------
 
-export { search, scoreIndex, tokenize, type SearchOptions };
+export { scoreIndex, search, type SearchOptions, tokenize };

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/types.ts

@@ -5,8 +5,9 @@
  * Claude Code session transcripts across all projects.
  */
 
-import { homedir } from "os";
-import { join } from "path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
 import { getProjectRoot } from "../../../_shared/lib-ts/base/constants.js";
 import { loadConfig } from "../config.js";
 
@@ -34,12 +35,12 @@ export const TOP_N_HEAP = 50;
 // ---------------------------------------------------------------------------
 
 export const WEIGHT = {
-  summary: 3.0,
-  segmentTopic: 3.0,
-  keywords: 2.0,
-  filesTouched: 2.0,
+  summary: 3,
+  segmentTopic: 3,
+  keywords: 2,
+  filesTouched: 2,
   commandsRun: 1.5,
-  toolCalls: 1.0,
+  toolCalls: 1,
 } as const;
 
 // ---------------------------------------------------------------------------
@@ -141,7 +142,7 @@ export const HYDE_NUM_RESPONSES = _ccNativeConfig.numResponses ?? 5;
 export const HYDE_MAX_TOKENS = _ccNativeConfig.maxTokens ?? 200;
 
 /** Per-response generation timeout in milliseconds. Local models usually respond in 500-1500ms. */
-export const HYDE_TIMEOUT_MS = _ccNativeConfig.timeoutMs ?? 10000;
+export const HYDE_TIMEOUT_MS = _ccNativeConfig.timeoutMs ?? 10_000;
 
 /** Fallback to direct query embedding if HyDE fails? true = graceful degradation (recommended). */
 export const HYDE_FALLBACK_TO_QUERY = _ccNativeConfig.fallbackToQuery ?? true;

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/vector-store.ts

@@ -7,8 +7,9 @@
 
 import { Database } from "bun:sqlite";
 import * as sqliteVec from "sqlite-vec";
+
+import { logDebug } from "./logger.js";
 import { RLM_VECTOR_DB_PATH, EMBED_DIMENSIONS, type VectorSearchResult } from "./types.js";
-import { logDebug, logInfo } from "./logger.js";
 
 const HOOK_NAME = "rlm_vector";
 
@@ -154,7 +155,7 @@ export function deleteSessionChunks(
     `SELECT rowid FROM chunks WHERE session_id = ? AND project = ?`,
   ).all(sessionId, project);
 
-  const rows = (Array.isArray(rawRows) ? rawRows : []).filter(isRowidResult);
+  const rows = (Array.isArray(rawRows) ? rawRows : []).filter((row) => isRowidResult(row));
 
   if (rows.length > 0) {
     const tx = db.transaction(() => {
@@ -237,7 +238,7 @@ export function searchKnn(
   }
 
   const rawRows = db.query(sql).all(...params);
-  const rows = (Array.isArray(rawRows) ? rawRows : []).filter(isSearchResultRow);
+  const rows = (Array.isArray(rawRows) ? rawRows : []).filter((row) => isSearchResultRow(row));
 
   return rows.map((r) => ({
     chunk_id: r.rowid,

package/dist/templates/cc-native/_cc-native/lib-ts/settings.ts

@@ -5,18 +5,17 @@
 
 import * as path from "node:path";
 
-import { logInfo } from "../../_shared/lib-ts/base/logger.js";
 
+import { aggregateAgents } from "./aggregate-agents.js";
+import { loadConfig, getDisplaySettings } from "./config.js";
+import { DEFAULT_REVIEW_ITERATIONS } from "./state.js";
 import type {
   AgentConfig,
-  OrchestratorConfig,
   ProviderConfig,
   ModelsConfig,
 } from "./types.js";
 import { DEFAULT_DISPLAY, DEFAULT_SANITIZATION } from "./types.js";
-import { loadConfig, getDisplaySettings } from "./config.js";
-import { aggregateAgents } from "./aggregate-agents.js";
-import { DEFAULT_REVIEW_ITERATIONS } from "./state.js";
+import { logInfo } from "../../_shared/lib-ts/base/logger.js";
 
 const HOOK = "settings";
 
@@ -125,11 +124,11 @@ export function loadSettings(projDir: string): Record<string, unknown> {
   }
   mergedAgent.display = getDisplaySettings(config, "agentReview");
   const configRecord = config as Record<string, unknown>;
-  mergedAgent.agentSelection = { ...DEFAULT_AGENT_SELECTION, ...((configRecord.agentSelection as Record<string, unknown>) ?? {}) };
-  mergedAgent.agentDefaults = { model: DEFAULT_AGENT_MODEL, ...((configRecord.agentDefaults as Record<string, unknown>) ?? {}) };
+  mergedAgent.agentSelection = { ...DEFAULT_AGENT_SELECTION, ...(configRecord.agentSelection as Record<string, unknown>) };
+  mergedAgent.agentDefaults = { model: DEFAULT_AGENT_MODEL, ...(configRecord.agentDefaults as Record<string, unknown>) };
   mergedAgent.complexityCategories = (configRecord.complexityCategories as string[]) ?? [...DEFAULT_COMPLEXITY_CATEGORIES];
-  mergedAgent.sanitization = { ...DEFAULT_SANITIZATION, ...((configRecord.sanitization as Record<string, unknown>) ?? {}) };
-  mergedAgent.reviewIterations = { ...DEFAULT_REVIEW_ITERATIONS, ...agentReview.reviewIterations ?? {} };
+  mergedAgent.sanitization = { ...DEFAULT_SANITIZATION, ...(configRecord.sanitization as Record<string, unknown>) };
+  mergedAgent.reviewIterations = { ...DEFAULT_REVIEW_ITERATIONS, ...agentReview.reviewIterations };
 
   const modelsRaw = (config as Record<string, unknown>).models ?? {};
   return { planReview: mergedPlan, agentReview: mergedAgent, models: modelsRaw };

package/dist/templates/cc-native/_cc-native/lib-ts/state.ts

@@ -6,11 +6,12 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+
+import { validatePlanPath } from "./constants.js";
+import type { IterationState, IterationEntry } from "./types.js";
 import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
 import { logInfo, logWarn, logError } from "../../_shared/lib-ts/base/logger.js";
 import { nowIso } from "../../_shared/lib-ts/base/utils.js";
-import { validatePlanPath } from "./constants.js";
-import type { IterationState, IterationEntry } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -72,11 +73,11 @@ export function loadState(planPath: string): Record<string, unknown> | null {
     }
 
     return state;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
     } else {
-      logError("state", `Failed to load state: ${e}`);
+      logError("state", `Failed to load state: ${error}`);
     }
     return null;
   }
@@ -109,11 +110,11 @@ export function saveStateToPlan(
     }
 
     return true;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
     } else {
-      logError("state", String(e));
+      logError("state", String(error));
     }
     return false;
   }
@@ -131,12 +132,12 @@ export function deleteState(planPath: string): boolean {
       logInfo("state", `Deleted state file: ${stateFile}`);
     }
     return true;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path in delete: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path in delete: ${error}`);
       return false;
     }
-    logWarn("state", `Failed to delete state file: ${e}`);
+    logWarn("state", `Failed to delete state file: ${error}`);
     return false;
   }
 }
@@ -208,7 +209,7 @@ export function shouldContinueIterating(
   verdict: string,
   config?: Record<string, unknown>,
 ): boolean {
-  const current = iteration.current;
+  const {current} = iteration;
   const maxIter = iteration.max;
 
   // At or past max iterations
@@ -252,8 +253,8 @@ export function loadIterationState(reviewsDir: string): IterationState | null {
   if (!fs.existsSync(iterationFile)) return null;
   try {
     return JSON.parse(fs.readFileSync(iterationFile, "utf-8")) as IterationState;
-  } catch (e) {
-    logError("state", `Failed to load iteration state: ${e}`);
+  } catch (error) {
+    logError("state", `Failed to load iteration state: ${error}`);
     return null;
   }
 }
@@ -268,8 +269,8 @@ export function saveIterationState(reviewsDir: string, state: IterationState): b
     const toWrite = { ...state, schema_version: "1.0.0" };
     fs.writeFileSync(iterationFile, JSON.stringify(toWrite, null, 2), "utf-8");
     return true;
-  } catch (e) {
-    logError("state", `Failed to save iteration state: ${e}`);
+  } catch (error) {
+    logError("state", `Failed to save iteration state: ${error}`);
     return false;
   }
 }