composto-ai 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,25 +1,1308 @@
 #!/usr/bin/env node
-import {
-  benchmarkFile,
-  computeHealthFromTrends,
-  detectDecay,
-  detectHotspots,
-  detectInconsistencies,
-  estimateTokens,
-  generateLayer,
-  getGitLog,
-  loadConfig,
-  packContext,
-  runDetector,
-  summarize
-} from "./chunk-AARGW2GV.js";
 
 // src/cli/commands.ts
-import { readFileSync, readdirSync } from "fs";
-import { join, relative } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { relative as relative2, join as join6 } from "path";
 
-// src/router/router.ts
+// src/config/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse } from "yaml";
+var DEFAULT_CONFIG = {
+  watchers: {
+    security: {
+      enabled: true,
+      severity: { "src/**": "warning", "tests/**": "info" }
+    },
+    deadCode: { enabled: true, trigger: "on-commit" },
+    consoleLog: { enabled: true, severity: { "src/**": "warning", "tests/**": "info" } }
+  },
+  agents: {
+    fixer: { enabled: true, model: "haiku" },
+    reviewer: { enabled: false, model: "sonnet" }
+  },
+  ir: {
+    deltaContextLines: 3,
+    confidenceThreshold: 0.6,
+    genericPatterns: "default"
+  },
+  trends: {
+    enabled: true,
+    hotspotThreshold: 10,
+    bugFixRatioThreshold: 0.5,
+    decayCheckTrigger: "on-commit",
+    fullReportSchedule: "weekly"
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] ?? {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+function parseConfig(yamlContent) {
+  if (!yamlContent.trim()) return { ...DEFAULT_CONFIG };
+  const parsed = parse(yamlContent) ?? {};
+  return deepMerge(DEFAULT_CONFIG, parsed);
+}
+function loadConfig(projectPath) {
+  const configPath = join(projectPath, ".composto", "config.yaml");
+  if (!existsSync(configPath)) return { ...DEFAULT_CONFIG };
+  const content = readFileSync(configPath, "utf-8");
+  return parseConfig(content);
+}
+
+// src/watcher/detector.ts
 import picomatch from "picomatch";
+function getSeverity(filePath, severityMap) {
+  for (const [glob, severity] of Object.entries(severityMap)) {
+    if (picomatch.isMatch(filePath, glob)) return severity;
+  }
+  return "info";
+}
+var SECRET_PATTERNS = [
+  /["'](sk-[a-zA-Z0-9-]{20,})["']/,
+  /["'](AKIA[0-9A-Z]{16})["']/,
+  /["'](ghp_[a-zA-Z0-9]{36})["']/,
+  /(?:password|secret|token|api_?key)\s*[:=]\s*["']([^"']{8,})["']/i
+];
+function securityRule(code, filePath, severityMap) {
+  const findings = [];
+  const severity = getSeverity(filePath, severityMap);
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("//") || line.trim().startsWith("/*")) continue;
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(line)) {
+        findings.push({
+          watcherId: "security",
+          severity,
+          file: filePath,
+          line: i + 1,
+          message: "Potential hardcoded secret detected",
+          action: {
+            type: "agent-required",
+            agentHint: { role: "fixer", model: "haiku", contextFiles: [filePath] }
+          }
+        });
+        break;
+      }
+    }
+  }
+  return findings;
+}
+function consoleLogRule(code, filePath, severityMap) {
+  const findings = [];
+  const severity = getSeverity(filePath, severityMap);
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/\bconsole\.(log|debug|info|warn)\b/.test(lines[i])) {
+      findings.push({
+        watcherId: "consoleLog",
+        severity,
+        file: filePath,
+        line: i + 1,
+        message: "console.log detected \u2014 likely debug artifact",
+        action: { type: "auto-fix", autoFix: "remove-line" }
+      });
+    }
+  }
+  return findings;
+}
+var RULES = {
+  security: securityRule,
+  consoleLog: consoleLogRule
+};
+function runDetector(code, filePath, watcherConfigs) {
+  const findings = [];
+  for (const [name, config] of Object.entries(watcherConfigs)) {
+    if (!config.enabled) continue;
+    const rule = RULES[name];
+    if (rule && config.severity) {
+      findings.push(...rule(code, filePath, config.severity));
+    }
+  }
+  return findings;
+}
+
+// src/ir/structure.ts
+var CLASSIFIERS = [
+  [/^(function|def|fn|func)\b/, "function-start"],
+  [/^(class|struct|interface)\b/, "type-start"],
+  [/^(if|else|elif|switch|match|case)\b/, "branch"],
+  [/^(for|while|loop|do)\b/, "loop"],
+  [/^(return|yield)\b/, "exit"],
+  [/^(import|require|use|from)\b/, "import"],
+  [/^(export|pub|public)\b/, "export"],
+  [/^(const|let|var|val|mut)\b/, "assignment"],
+  [/^(try|catch|except|finally)\b/, "error-handling"],
+  [/^(async|await)\b/, "async"],
+  [/^(\/\/|\/\*|#)/, "comment"]
+];
+function classifyLine(firstToken) {
+  if (firstToken === "") return "blank";
+  for (const [pattern, type] of CLASSIFIERS) {
+    if (pattern.test(firstToken)) return type;
+  }
+  return "unknown";
+}
+function extractStructure(code) {
+  const lines = code.split("\n");
+  return lines.map((raw, i) => {
+    const indent = raw.search(/\S/);
+    const trimmed = raw.trim();
+    const firstToken = trimmed.split(/[\s({<]/)[0];
+    const type = classifyLine(firstToken);
+    return {
+      line: i + 1,
+      indent: indent === -1 ? -1 : indent,
+      type,
+      raw
+    };
+  });
+}
+
+// src/ir/fingerprint.ts
+var PATTERNS = [
+  // import type { x, y } from "module"
+  {
+    match: /^import\s+type\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
+    confidence: 0.95
+  },
+  // import { x, y } from "module"
+  {
+    match: /^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
+    confidence: 0.95
+  },
+  // import type x from "module"
+  {
+    match: /^import\s+type\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1]}}`,
+    confidence: 0.95
+  },
+  // import x from "module"
+  {
+    match: /^import\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1]}}`,
+    confidence: 0.95
+  },
+  // const x = require("module")
+  {
+    match: /^(?:const|let|var)\s+(\w+)\s*=\s*require\(["']([^"']+)["']\);?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1]}}`,
+    confidence: 0.95
+  },
+  // export function name(params) {
+  {
+    match: /^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{?\s*$/,
+    transform: (m) => `OUT FN:${m[1]}(${m[2].replace(/\s/g, "")})`,
+    confidence: 0.95
+  },
+  // function name(params) {
+  {
+    match: /^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{?\s*$/,
+    transform: (m) => `FN:${m[1]}(${m[2].replace(/\s/g, "")})`,
+    confidence: 0.95
+  },
+  // export class Name extends Base {
+  {
+    match: /^export\s+class\s+(\w+)(?:\s+extends\s+(\w+))?\s*(?:implements\s+\S+\s*)?\{?\s*$/,
+    transform: (m) => `OUT CLASS:${m[1]}${m[2] ? ` < ${m[2]}` : ""}`,
+    confidence: 0.95
+  },
+  // class Name extends Base {
+  {
+    match: /^class\s+(\w+)(?:\s+extends\s+(\w+))?\s*(?:implements\s+\S+\s*)?\{?\s*$/,
+    transform: (m) => `CLASS:${m[1]}${m[2] ? ` < ${m[2]}` : ""}`,
+    confidence: 0.95
+  },
+  // if (cond) return expr;
+  {
+    match: /^if\s*\(([^)]+)\)\s*return\s+(.+);?\s*$/,
+    transform: (m) => `IF:${m[1].trim()} -> RET ${m[2].trim().replace(/;$/, "")}`,
+    confidence: 0.95
+  },
+  // if (cond) {
+  {
+    match: /^if\s*\(([^)]+)\)\s*\{?\s*$/,
+    transform: (m) => `IF:${m[1].trim()}`,
+    confidence: 0.9
+  },
+  // for (... of/in ...) {
+  {
+    match: /^for\s*\((?:const|let|var)\s+(\w+)\s+(?:of|in)\s+(\w+)\)\s*\{?\s*$/,
+    transform: (m) => `LOOP:${m[2]} -> ${m[1]}`,
+    confidence: 0.9
+  },
+  // return expr
+  {
+    match: /^return\s+(.+);?\s*$/,
+    transform: (m) => `RET ${m[1].trim().replace(/;$/, "")}`,
+    confidence: 0.95
+  },
+  // return;
+  {
+    match: /^return;?\s*$/,
+    transform: () => "RET",
+    confidence: 0.95
+  },
+  // try {
+  {
+    match: /^try\s*\{\s*$/,
+    transform: () => "TRY:",
+    confidence: 0.9
+  },
+  // catch (e) {
+  {
+    match: /^(?:\}\s*)?catch\s*\((\w+)\)\s*\{?\s*$/,
+    transform: (m) => `CATCH:${m[1]}`,
+    confidence: 0.9
+  },
+  // switch (expr) {
+  {
+    match: /^switch\s*\(([^)]+)\)\s*\{?\s*$/,
+    transform: (m) => `SWITCH:${m[1].trim()}`,
+    confidence: 0.9
+  },
+  // case "value":  /  case value:
+  {
+    match: /^case\s+(.+)\s*:\s*$/,
+    transform: (m) => `CASE:${m[1].trim()}`,
+    confidence: 0.9
+  },
+  // default:
+  {
+    match: /^default\s*:\s*$/,
+    transform: () => "DEFAULT:",
+    confidence: 0.9
+  },
+  // export type Name = ...
+  {
+    match: /^export\s+type\s+(\w+)(?:<[^>]+>)?\s*=\s*(.+);?\s*$/,
+    transform: (m) => `OUT TYPE:${m[1]}`,
+    confidence: 0.9
+  },
+  // if (cond) expr;  (inline if with method call)
+  {
+    match: /^if\s*\(([^)]+)\)\s+(\w+.+);?\s*$/,
+    transform: (m) => `IF:${m[1].trim()} -> ${m[2].replace(/;$/, "").trim().slice(0, 50)}`,
+    confidence: 0.9
+  },
+  // export async function name(  (multiline signature)
+  {
+    match: /^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(\s*$/,
+    transform: (m) => `OUT FN:${m[1]}(`,
+    confidence: 0.95
+  },
+  // interface/type property — name: type;
+  {
+    match: /^\s*(\w+)\??\s*:\s*(.+);?\s*$/,
+    transform: (m) => `PROP:${m[1]}: ${m[2].replace(/;$/, "").trim()}`,
+    confidence: 0.75
+  },
+  // const x = await expr;
+  {
+    match: /^(?:export\s+)?(?:const|let|var)\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*await\s+(.+);?\s*$/,
+    transform: (m) => {
+      const prefix = m[0].startsWith("export") ? "OUT " : "";
+      return `${prefix}AWAIT:VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
+    },
+    confidence: 0.85
+  },
+  // export const name = async (params) => {  OR  export const name = (params) => expr;
+  {
+    match: /^export\s+(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
+    transform: (m) => {
+      const asyncPrefix = m[2] ? "ASYNC " : "";
+      const body = m[4].replace(/[{;]\s*$/, "").trim();
+      return `OUT ${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
+    },
+    confidence: 0.9
+  },
+  // const name = async (params) => {  OR  const name = (params) => expr;
+  {
+    match: /^(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
+    transform: (m) => {
+      const asyncPrefix = m[2] ? "ASYNC " : "";
+      const body = m[4].replace(/[{;]\s*$/, "").trim();
+      return `${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
+    },
+    confidence: 0.9
+  },
+  // get name() {
+  {
+    match: /^\s*get\s+(\w+)\s*\(\)\s*(?::\s*\S+\s*)?\{?\s*$/,
+    transform: (m) => `GET:${m[1]}()`,
+    confidence: 0.9
+  },
+  // set name(value) {
+  {
+    match: /^\s*set\s+(\w+)\s*\(([^)]*)\)\s*\{?\s*$/,
+    transform: (m) => `SET:${m[1]}(${m[2].replace(/\s/g, "")})`,
+    confidence: 0.9
+  },
+  // methodName(params) {  (inside class body, indented)
+  {
+    match: /^\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{\s*$/,
+    transform: (m) => {
+      const name = m[1];
+      if (["if", "for", "while", "switch", "catch", "function"].includes(name)) return `${name}`;
+      return `METHOD:${name}(${m[2].replace(/\s/g, "")})`;
+    },
+    confidence: 0.9
+  },
+  // const { a, b } = expr (object destructuring — before regular assignment)
+  {
+    match: /^(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(.+);?\s*$/,
+    transform: (m) => `VAR:{${m[1].replace(/\s/g, "")}} = ${m[2].replace(/;$/, "").trim()}`,
+    confidence: 0.9
+  },
+  // const [a, b] = expr (destructuring — before regular assignment)
+  {
+    match: /^(?:const|let|var)\s+\[([^\]]+)\]\s*=\s*(.+);?\s*$/,
+    transform: (m) => `VAR:[${m[1].replace(/\s/g, "")}] = ${m[2].replace(/;$/, "").trim()}`,
+    confidence: 0.9
+  },
+  // const name = value;
+  {
+    match: /^(?:export\s+)?(?:const|let|var)\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*(.+);?\s*$/,
+    transform: (m) => {
+      const prefix = m[0].startsWith("export") ? "OUT " : "";
+      return `${prefix}VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
+    },
+    confidence: 0.85
+  }
+];
+function fingerprintLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "" || trimmed === "{" || trimmed === "}" || trimmed === "});" || trimmed === ");") {
+    return { type: "fingerprint", ir: "", confidence: 1 };
+  }
+  if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
+    return { type: "fingerprint", ir: "", confidence: 1 };
+  }
+  for (const pattern of PATTERNS) {
+    const match = trimmed.match(pattern.match);
+    if (match) {
+      const ir = pattern.transform(match);
+      if (pattern.confidence > 0.9) {
+        return { type: "fingerprint", ir, confidence: pattern.confidence };
+      }
+      return {
+        type: "fingerprint+hint",
+        ir,
+        hint: trimmed,
+        confidence: pattern.confidence
+      };
+    }
+  }
+  return { type: "raw", ir: trimmed, confidence: 0.1 };
+}
+function fingerprintFile(code, confidenceThreshold = 0.6) {
+  const lines = code.split("\n");
+  const irLines = [];
+  for (const line of lines) {
+    const indent = line.search(/\S/);
+    const indentStr = indent > 0 ? "  ".repeat(Math.floor(indent / 2)) : "";
+    const result = fingerprintLine(line);
+    if (result.ir === "") continue;
+    if (result.confidence >= confidenceThreshold) {
+      irLines.push(`${indentStr}${result.ir}`);
+    }
+  }
+  return irLines.join("\n");
+}
+
+// src/ir/health.ts
+var CHURN_THRESHOLD = 10;
+var FIX_RATIO_THRESHOLD = 0.5;
+function buildHealthTag(health) {
+  const parts = [];
+  if (health.churn > CHURN_THRESHOLD) parts.push(`HOT:${health.churn}/30`);
+  if (health.fixRatio > FIX_RATIO_THRESHOLD) parts.push(`FIX:${Math.round(health.fixRatio * 100)}%`);
+  if (health.coverageTrend === "down") parts.push("COV:\u2193");
+  if (health.consistency === "low") parts.push("INCON");
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+function annotateIR(ir, health) {
+  const tag = buildHealthTag(health);
+  if (!tag) return ir;
+  const lines = ir.split("\n");
+  lines[0] = `${lines[0]} ${tag}`;
+  return lines.join("\n");
+}
+function computeHealthFromTrends(file, trends) {
+  const hotspot = trends.hotspots.find((h) => h.file === file);
+  const decay = trends.decaySignals.find((d) => d.file === file);
+  const inconsistency = trends.inconsistencies.find((i) => i.file === file);
+  return {
+    churn: hotspot?.changesInLast30Commits ?? 0,
+    fixRatio: hotspot?.bugFixRatio ?? 0,
+    coverageTrend: decay?.trend === "declining" ? "down" : decay?.trend === "improving" ? "up" : "stable",
+    staleness: "",
+    authorCount: hotspot?.authorCount ?? 0,
+    consistency: inconsistency ? "low" : "high"
+  };
+}
+
+// src/parser/init.ts
+import { Parser, Language } from "web-tree-sitter";
+import { resolve, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var initialized = false;
+var cache = /* @__PURE__ */ new Map();
+function grammarPath(lang) {
+  const distPath = resolve(__dirname, "grammars", `tree-sitter-${lang}.wasm`);
+  if (existsSync2(distPath)) return distPath;
+  const devPath = resolve(__dirname, "../../grammars", `tree-sitter-${lang}.wasm`);
+  if (existsSync2(devPath)) return devPath;
+  throw new Error(`Grammar not found for ${lang}`);
+}
+async function getParser(lang) {
+  if (!initialized) {
+    await Parser.init();
+    initialized = true;
+  }
+  const cached = cache.get(lang);
+  if (cached) return cached;
+  const parser = new Parser();
+  const language = await Language.load(grammarPath(lang));
+  parser.setLanguage(language);
+  const result = { parser, language };
+  cache.set(lang, result);
+  return result;
+}
+
+// src/parser/languages.ts
+import { extname } from "path";
+var EXT_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust"
+};
+var SUPPORTED_EXTENSIONS = Object.keys(EXT_MAP);
+function detectLanguage(filePath) {
+  const ext = extname(filePath);
+  return EXT_MAP[ext] ?? null;
+}
+
+// src/ir/ast-walker.ts
+var TIER_MAP = {
+  // Tier 1 — structural declarations (JS/TS)
+  import_statement: "T1_KEEP",
+  function_declaration: "T1_KEEP",
+  class_declaration: "T1_KEEP",
+  interface_declaration: "T1_KEEP",
+  type_alias_declaration: "T1_KEEP",
+  enum_declaration: "T1_KEEP",
+  // Tier 1 — Python
+  function_definition: "T1_KEEP",
+  class_definition: "T1_KEEP",
+  import_from_statement: "T1_KEEP",
+  decorated_definition: "T1_KEEP",
+  // Tier 1 — class members (qualified methods only, fields dropped as noise)
+  method_definition: "T1_KEEP",
+  // JS/TS class method
+  // Tier 1 — Go
+  function_item: "T1_KEEP",
+  // Rust
+  method_declaration: "T1_KEEP",
+  // Go
+  type_declaration: "T1_KEEP",
+  // Go
+  import_declaration: "T1_KEEP",
+  // Go
+  use_declaration: "T1_KEEP",
+  // Rust
+  struct_item: "T1_KEEP",
+  // Rust
+  enum_item: "T1_KEEP",
+  // Rust
+  trait_item: "T1_KEEP",
+  // Rust
+  impl_item: "T1_KEEP",
+  // Rust
+  // Tier 2 — control flow (universal)
+  if_statement: "T2_CONTROL",
+  if_expression: "T2_CONTROL",
+  // Rust
+  else_clause: "WALK_ONLY",
+  elif_clause: "T2_CONTROL",
+  // Python
+  for_statement: "T2_CONTROL",
+  for_in_statement: "T2_CONTROL",
+  for_expression: "T2_CONTROL",
+  // Rust
+  while_statement: "T2_CONTROL",
+  do_statement: "T2_CONTROL",
+  switch_statement: "T2_CONTROL",
+  switch_case: "T2_CONTROL",
+  switch_default: "T2_CONTROL",
+  match_expression: "T2_CONTROL",
+  // Rust
+  return_statement: "T2_CONTROL",
+  return_expression: "T2_CONTROL",
+  // Rust
+  throw_statement: "T2_CONTROL",
+  raise_statement: "T2_CONTROL",
+  // Python
+  try_statement: "T2_CONTROL",
+  catch_clause: "T2_CONTROL",
+  except_clause: "T2_CONTROL",
+  // Python
+  with_statement: "T2_CONTROL",
+  // Python
+  defer_statement: "T2_CONTROL",
+  // Go
+  // Tier 3 — compressible expressions
+  lexical_declaration: "T3_COMPRESS",
+  expression_statement: "T3_COMPRESS",
+  assignment: "T3_COMPRESS",
+  // Python
+  short_var_declaration: "T3_COMPRESS",
+  // Go
+  // Walk-only — containers
+  program: "WALK_ONLY",
+  module: "WALK_ONLY",
+  // Python
+  statement_block: "WALK_ONLY",
+  block: "WALK_ONLY",
+  // Python/Go/Rust
+  class_body: "WALK_ONLY",
+  // JS/TS
+  switch_body: "WALK_ONLY",
+  export_statement: "WALK_ONLY",
+  source_file: "WALK_ONLY"
+  // Go/Rust
+};
+function tierOf(nodeType) {
+  return TIER_MAP[nodeType] ?? "T4_DROP";
+}
+function collapseText(text, maxLen) {
+  const collapsed = text.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
+  if (collapsed.length <= maxLen) return collapsed;
+  return collapsed.slice(0, maxLen - 3) + "...";
+}
+function getTypeParams(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child.type === "type_parameters") {
+      return child.text;
+    }
+  }
+  return "";
+}
+function isExported(node) {
+  return node.parent?.type === "export_statement";
+}
+function isAsync(node) {
+  return node.text.trimStart().startsWith("async");
+}
+function extractDocComment(node) {
+  const exported = node.parent?.type === "export_statement";
+  if (!exported) return null;
+  const prev = node.parent?.previousNamedSibling;
+  if (!prev || prev.type !== "comment") return null;
+  const text = prev.text;
+  if (!text.startsWith("/**")) return null;
+  const body = text.replace(/^\/\*\*|\*\/$/g, "").replace(/^\s*\*\s?/gm, "").trim();
+  const hasDeprecated = /@deprecated\b/.test(body);
+  if (hasDeprecated) return "@deprecated";
+  const beforeTags = body.split(/@\w+/)[0].trim();
+  const firstLine = beforeTags.split("\n")[0].trim();
+  if (!firstLine || firstLine.length < 5) return null;
+  return `"${firstLine.length > 30 ? firstLine.slice(0, 27) + "..." : firstLine}"`;
+}
+function extractPythonDocstring(bodyNode) {
+  if (!bodyNode) return null;
+  for (let i = 0; i < bodyNode.childCount; i++) {
+    const child = bodyNode.child(i);
+    if (child.type === "expression_statement" && child.childCount > 0) {
+      const expr = child.child(0);
+      if (expr.type === "string") {
+        const text = expr.text.replace(/^(['"]{3}|['"])|(['"]{3}|['"])$/g, "").trim();
+        const firstLine = text.split("\n")[0].trim();
+        if (firstLine.length < 5) return null;
+        return `"${firstLine.length > 30 ? firstLine.slice(0, 27) + "..." : firstLine}"`;
+      }
+      break;
+    }
+  }
+  return null;
+}
+function extractCondition(node) {
+  const condNode = node.childForFieldName("condition") ?? (() => {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c.type === "parenthesized_expression") return c;
+    }
+    return null;
+  })();
+  if (!condNode) return "...";
+  const text = condNode.text.replace(/^\(/, "").replace(/\)$/, "").trim();
+  return text.length > 60 ? text.slice(0, 57) + "..." : text;
+}
+function emitTier2(node) {
+  switch (node.type) {
+    case "if_statement": {
+      const cond = extractCondition(node);
+      return `IF:${cond}`;
+    }
+    case "else_clause":
+      return "ELSE:";
+    case "for_statement":
+    case "for_in_statement":
+      return "LOOP";
+    case "while_statement": {
+      const cond = extractCondition(node);
+      return `WHILE:${cond}`;
+    }
+    case "do_statement": {
+      const cond = extractCondition(node);
+      return `WHILE:${cond}`;
+    }
+    case "switch_statement": {
+      const expr = node.childForFieldName("value") ?? node.childForFieldName("condition") ?? (() => {
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c.type === "parenthesized_expression") return c;
+        }
+        return null;
+      })();
+      const text = expr ? expr.text.replace(/^\(/, "").replace(/\)$/, "").trim() : "...";
+      return `SWITCH:${text.length > 60 ? text.slice(0, 57) + "..." : text}`;
+    }
+    case "switch_case": {
+      let value = null;
+      const valNode = node.childForFieldName("value");
+      if (valNode) {
+        value = valNode.text;
+      } else {
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c.type !== "case" && c.type !== ":" && c.childCount === 0 && c.text === "case") continue;
+          if (c.type !== "case" && c.text !== "case" && c.text !== ":") {
+            value = c.text;
+            break;
+          }
+        }
+      }
+      return `CASE:${value ?? "..."}`;
+    }
+    case "switch_default":
+      return "DEFAULT:";
+    case "return_statement": {
+      let retText = "";
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.text !== "return" && c.text !== ";") {
+          retText += (retText ? " " : "") + c.text;
+        }
+      }
+      retText = retText.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
+      if (!retText) return "RET";
+      return `RET ${retText.length > 60 ? retText.slice(0, 57) + "..." : retText}`;
+    }
+    case "throw_statement": {
+      let throwText = "";
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.text !== "throw" && c.text !== ";") {
+          throwText += (throwText ? " " : "") + c.text;
+        }
+      }
+      throwText = throwText.trim();
+      return `THROW:${throwText.length > 60 ? throwText.slice(0, 57) + "..." : throwText}`;
+    }
+    case "try_statement":
+      return "TRY";
+    case "catch_clause": {
+      const param = node.childForFieldName("parameter");
+      const paramText = param ? param.text : "...";
+      return `CATCH:${paramText}`;
+    }
+    // Python
+    case "raise_statement": {
+      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
+      return `RAISE:${val.length > 50 ? val.slice(0, 47) + "..." : val}`;
+    }
+    case "except_clause":
+      return "EXCEPT";
+    case "elif_clause": {
+      const cond = extractCondition(node);
+      return `ELIF:${cond}`;
+    }
+    case "with_statement":
+      return "WITH";
+    // Rust
+    case "if_expression": {
+      const cond = extractCondition(node);
+      return `IF:${cond}`;
+    }
+    case "for_expression":
+      return "LOOP";
+    case "match_expression":
+      return "MATCH";
+    case "return_expression": {
+      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
+      return `RET ${val.length > 60 ? val.slice(0, 57) + "..." : val}`.trimEnd();
+    }
+    // Go
+    case "defer_statement":
+      return "DEFER";
+    default:
+      return null;
+  }
+}
+function emitTier1(node) {
+  const exported = isExported(node);
+  const outPrefix = exported ? "OUT " : "";
+  switch (node.type) {
+    case "import_statement": {
+      const text = collapseText(node.text, 80);
+      return `USE:${text}`;
+    }
+    case "function_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const rawParams = node.childForFieldName("parameters")?.text ?? "()";
+      const params = collapseText(rawParams, 60);
+      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}${asyncPrefix}FN:${name}${params}`;
+    }
+    case "class_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const typeParams = getTypeParams(node);
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}CLASS:${name}${typeParams}`;
+    }
+    case "interface_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const typeParams = getTypeParams(node);
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}INTERFACE:${name}${typeParams}`;
+    }
+    case "type_alias_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}TYPE:${name}`;
+    }
+    case "enum_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}ENUM:${name}`;
+    }
+    case "method_definition": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      if (name.startsWith("#") || name.startsWith("_")) return null;
+      let enclosingClass = null;
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === "class_declaration" || parent.type === "class_definition") {
+          enclosingClass = parent.childForFieldName("name")?.text ?? null;
+          break;
+        }
+        parent = parent.parent;
+      }
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
+      const qualifiedName = enclosingClass ? `${enclosingClass}.${name}` : name;
+      return `${asyncPrefix}METHOD:${qualifiedName}${collapseText(params, 40)}`;
+    }
+    // Python
+    case "function_definition": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      const returnType = node.childForFieldName("return_type")?.text ?? "";
+      const rt = returnType ? ` -> ${returnType}` : "";
+      const body = node.childForFieldName("body");
+      const doc = extractPythonDocstring(body);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}FN:${name}${collapseText(params, 60)}${rt}`;
+    }
+    case "class_definition": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const superclass = node.childForFieldName("superclasses")?.text ?? "";
+      const sc = superclass ? `(${collapseText(superclass, 40)})` : "";
+      const body = node.childForFieldName("body");
+      const doc = extractPythonDocstring(body);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}CLASS:${name}${sc}`;
+    }
+    case "import_from_statement": {
+      return `USE:${collapseText(node.text, 80)}`;
+    }
+    case "decorated_definition": {
+      return null;
+    }
+    // Go
+    case "method_declaration":
+    case "type_declaration":
+    case "import_declaration": {
+      return `${collapseText(node.text, 80)}`;
+    }
+    // Rust
+    case "function_item": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      return `FN:${name}${collapseText(params, 60)}`;
+    }
+    case "struct_item":
+    case "enum_item":
+    case "trait_item":
+    case "impl_item":
+    case "use_declaration": {
+      const firstLine = node.text.split("\n")[0];
+      return collapseText(firstLine, 80);
+    }
+    default:
+      return null;
+  }
+}
+function emitTier3(node) {
+  switch (node.type) {
+    case "lexical_declaration": {
+      let declarator = null;
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.type === "variable_declarator") {
+          declarator = c;
+          break;
+        }
+      }
+      if (!declarator) return null;
+      const name = declarator.childForFieldName("name")?.text ?? "?";
+      const value = declarator.childForFieldName("value");
+      if (value) {
+        if (value.type === "arrow_function") {
+          const asyncPrefix = isAsync(value) ? "ASYNC " : "";
+          const params = value.childForFieldName("parameters")?.text ?? "()";
+          return `${asyncPrefix}FN:${name}${collapseText(params, 60)} => ...`;
+        }
+        if (value.type === "await_expression") {
+          const callee = value.childCount > 1 ? value.child(1).text : "...";
+          return `AWAIT:${name}=${collapseText(callee, 40)}`;
+        }
+        if (node.parent?.type === "statement_block") return null;
+        const vt = value.type;
+        if (vt === "number" || vt === "true" || vt === "false") return null;
+        if (vt === "object" || vt === "array") return null;
+        if (vt === "new_expression" || vt === "call_expression") return null;
+        const valText = value.text.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''").replace(/`[^`]*`/g, "``");
+        return `VAR:${name} = ${collapseText(valText, 50)}`;
+      }
+      return null;
+    }
+    case "expression_statement": {
+      const expr = node.child(0);
+      if (!expr) return null;
+      if (expr.type === "await_expression") {
+        return null;
+      }
+      if (expr.type === "call_expression") {
+        const callee = expr.child(0)?.text ?? "";
+        if (callee === "ObjectSetPrototypeOf" || callee === "Object.setPrototypeOf") {
+          const args2 = expr.child(1);
+          if (args2 && args2.childCount >= 4) {
+            const child = args2.child(1)?.text ?? "?";
+            const parent = args2.child(3)?.text ?? "?";
+            const shortChild = child.length > 30 ? child.slice(0, 27) + "..." : child;
+            const shortParent = parent.length > 30 ? parent.slice(0, 27) + "..." : parent;
+            return `EXTENDS:${shortChild} < ${shortParent}`;
+          }
+        }
+        return null;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function walkNode(node, depth, lines) {
+  const tier = tierOf(node.type);
+  switch (tier) {
+    case "T1_KEEP": {
+      const ir = emitTier1(node);
+      if (ir) lines.push(ir);
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        const childType = child.type;
+        if (childType === "statement_block" || childType === "class_body" || childType === "block" || // Python/Go/Rust
+        childType === "body" || // Python class/function body
+        childType === "declaration_list") {
+          walkNode(child, depth + 1, lines);
+        }
+      }
+      break;
+    }
+    case "T2_CONTROL": {
+      if (depth > 4 && node.type !== "return_statement" && node.type !== "throw_statement" && node.type !== "switch_case" && node.type !== "switch_default") break;
+      if (node.type === "if_statement") {
+        let hasElse = false;
+        for (let i = 0; i < node.childCount; i++) {
+          if (node.child(i).type === "else_clause") {
+            hasElse = true;
+            break;
+          }
+        }
+        if (!hasElse) {
+          const body = node.childForFieldName("consequence") ?? (() => {
+            for (let i = 0; i < node.childCount; i++) {
+              const c = node.child(i);
+              if (c.type === "statement_block") return c;
+            }
+            return null;
+          })();
+          if (body) {
+            let singleStmt = null;
+            if (body.type === "statement_block") {
+              const stmts = [];
+              for (let i = 0; i < body.childCount; i++) {
+                const c = body.child(i);
+                if (c.type !== "{" && c.type !== "}") stmts.push(c);
+              }
+              if (stmts.length === 1) singleStmt = stmts[0];
+            } else if (body.type === "return_statement" || body.type === "throw_statement") {
+              singleStmt = body;
+            }
+            if (singleStmt && (singleStmt.type === "return_statement" || singleStmt.type === "throw_statement")) {
+              const cond = extractCondition(node);
+              const retLine = emitTier2(singleStmt);
+              if (retLine) {
+                const indent2 = "  ".repeat(depth);
+                lines.push(`${indent2}IF:${cond} \u2192 ${retLine}`);
+                break;
+              }
+            }
+          }
+        }
+      }
+      const line = emitTier2(node);
+      const indent = "  ".repeat(depth);
+      if (line) lines.push(indent + line);
+      for (let i = 0; i < node.childCount; i++) {
+        walkNode(node.child(i), depth + 1, lines);
+      }
+      break;
+    }
+    case "T3_COMPRESS": {
+      if (depth > 4) break;
+      const line = emitTier3(node);
+      const indent = "  ".repeat(depth);
+      if (line) lines.push(indent + line);
+      break;
+    }
+    case "WALK_ONLY": {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (node.type === "export_statement") {
+          if (child.type === "export" || child.type === "default" || child.text === "export" || child.text === "default") {
+            if (child.childCount === 0 && (child.text === "export" || child.text === "default")) {
+              continue;
+            }
+          }
+        }
+        walkNode(child, depth + 1, lines);
+      }
+      break;
+    }
+    case "T4_DROP":
+    default:
+      break;
+  }
+}
+async function astWalkIR(code, filePath) {
+  const lang = detectLanguage(filePath);
+  if (!lang) return null;
+  const { parser } = await getParser(lang);
+  const tree = parser.parse(code);
+  const root = tree.rootNode;
+  const lines = [];
+  walkNode(root, 0, lines);
+  if (lines.length === 0) return null;
+  const pass1 = [];
+  let useBlock = [];
+  for (const line of lines) {
+    if (line.startsWith("USE:")) {
+      const m = line.match(/from\s+["']([^"']+)["']/);
+      useBlock.push(m ? m[1] : line.slice(4));
+    } else {
+      if (useBlock.length > 0) {
+        if (useBlock.length <= 3) {
+          for (const mod of useBlock) pass1.push(`USE:${mod}`);
+        } else {
+          pass1.push(`USE:[${useBlock.join(", ")}]`);
+        }
+        useBlock = [];
+      }
+      pass1.push(line);
+    }
+  }
+  if (useBlock.length > 0) {
+    if (useBlock.length <= 3) {
+      for (const mod of useBlock) pass1.push(`USE:${mod}`);
+    } else {
+      pass1.push(`USE:[${useBlock.join(", ")}]`);
+    }
+  }
+  const merged = [];
+  let guardBlock = [];
+  for (const line of pass1) {
+    const guardMatch = line.match(/^(\s*)IF:(.+?) \u2192 RET/);
+    if (guardMatch) {
+      guardBlock.push(guardMatch[2].trim());
+      continue;
+    }
+    if (guardBlock.length > 0) {
+      if (guardBlock.length < 3) {
+        for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
+      } else {
+        merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
+      }
+      guardBlock = [];
+    }
+    merged.push(line);
+  }
+  if (guardBlock.length > 0) {
+    if (guardBlock.length < 3) {
+      for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
+    } else {
+      merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
+    }
+  }
+  return merged.join("\n");
+}
+
+// src/ir/layers.ts
+function generateL0(code, filePath) {
+  const structure = extractStructure(code);
+  const topLevel = structure.filter(
+    (s) => s.indent === 0 && ["function-start", "type-start", "export"].includes(s.type)
+  );
+  const declarations = topLevel.map((s) => {
+    const name = s.raw.match(
+      /(?:function|class|interface|const|let|var|export\s+(?:default\s+)?(?:function|class|async\s+function))\s+(\w+)/
+    )?.[1] ?? "unknown";
+    return `  ${s.type === "type-start" ? "CLASS" : "FN"}:${name} L${s.line}`;
+  });
+  return `${filePath}
+${declarations.join("\n")}`;
+}
+async function generateL1(code, filePath, health) {
+  const ir = await astWalkIR(code, filePath) ?? fingerprintFile(code, 0.75);
+  const result = ir.length < code.length ? ir : code;
+  if (health) {
+    return annotateIR(result, health);
+  }
+  return result;
+}
+function generateL2(delta, health) {
+  const parts = [`FILE: ${delta.file}`];
+  for (const hunk of delta.hunks) {
+    if (hunk.functionScope) parts.push(`SCOPE: ${hunk.functionScope}`);
+    parts.push(`CHANGED: ${hunk.changed.join("\n         ")}`);
+    if (hunk.surroundingIR) parts.push(`CONTEXT: ${hunk.surroundingIR}`);
+    if (hunk.blame) {
+      parts.push(`BLAME: ${hunk.blame.author}, ${hunk.blame.date}, commit:"${hunk.blame.commitMessage}"`);
+    }
+  }
+  const ir = parts.join("\n");
+  if (health) return annotateIR(ir, health);
+  return ir;
+}
+function generateL3(code, startLine, endLine) {
+  const lines = code.split("\n");
+  return lines.slice(startLine - 1, endLine).join("\n");
+}
+async function generateLayer(layer, options) {
+  switch (layer) {
+    case "L0":
+      return generateL0(options.code, options.filePath);
+    case "L1":
+      return generateL1(options.code, options.filePath, options.health);
+    case "L2":
+      if (!options.delta) return generateL1(options.code, options.filePath, options.health);
+      return generateL2(options.delta, options.health);
+    case "L3":
+      if (options.lineRange) {
+        return generateL3(options.code, options.lineRange.start, options.lineRange.end);
+      }
+      return options.code;
+  }
+}
+
+// src/trends/git-log-parser.ts
+import { execSync } from "child_process";
+var BUG_FIX_PATTERNS = [
+  /\bfix\b/i,
+  /\bbugfix\b/i,
+  /\bhotfix\b/i,
+  /\bpatch\b/i,
+  /\bresolve\b/i,
+  /\bbug\b/i
+];
+function isBugFixCommit(message) {
+  return BUG_FIX_PATTERNS.some((p) => p.test(message));
+}
+function parseGitLogOutput(output) {
+  const entries = [];
+  const lines = output.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (!line || !line.includes("|")) {
+      i++;
+      continue;
+    }
+    const [hash, author, date, ...messageParts] = line.split("|");
+    const message = messageParts.join("|");
+    const files = [];
+    i++;
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].includes("|")) {
+      const fileLine = lines[i].trim();
+      if (fileLine) files.push(fileLine);
+      i++;
+    }
+    entries.push({ hash, author, date, message, files });
+  }
+  return entries;
+}
+function getGitLog(repoPath, count = 100) {
+  try {
+    const output = execSync(
+      `git log --format="%h|%an|%as|%s" --name-only -n ${count}`,
+      { cwd: repoPath, encoding: "utf-8", timeout: 1e4 }
+    );
+    return parseGitLogOutput(output);
+  } catch {
+    return [];
+  }
+}
+
+// src/trends/hotspot.ts
+function detectHotspots(entries, options) {
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const isFix = isBugFixCommit(entry.message);
+    for (const file of entry.files) {
+      const stats = fileStats.get(file) ?? { changes: 0, fixes: 0, authors: /* @__PURE__ */ new Set() };
+      stats.changes++;
+      if (isFix) stats.fixes++;
+      stats.authors.add(entry.author);
+      fileStats.set(file, stats);
+    }
+  }
+  const hotspots = [];
+  for (const [file, stats] of fileStats) {
+    const fixRatio = stats.changes > 0 ? stats.fixes / stats.changes : 0;
+    if (stats.changes >= options.threshold && fixRatio >= options.fixRatioThreshold) {
+      hotspots.push({
+        file,
+        changesInLast30Commits: stats.changes,
+        bugFixRatio: fixRatio,
+        authorCount: stats.authors.size
+      });
+    }
+  }
+  return hotspots.sort((a, b) => b.changesInLast30Commits - a.changesInLast30Commits);
+}
+
+// src/trends/decay.ts
+function detectDecay(entries) {
+  const fileChanges = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      const changes = fileChanges.get(file) ?? [];
+      changes.push({ date: entry.date });
+      fileChanges.set(file, changes);
+    }
+  }
+  const signals = [];
+  for (const [file, changes] of fileChanges) {
+    if (changes.length < 4) continue;
+    const sorted = [...changes].sort((a, b) => a.date.localeCompare(b.date));
+    const firstDate = new Date(sorted[0].date).getTime();
+    const lastDate = new Date(sorted[sorted.length - 1].date).getTime();
+    const midDate = firstDate + (lastDate - firstDate) / 2;
+    const firstHalfCount = sorted.filter((c) => new Date(c.date).getTime() <= midDate).length;
+    const secondHalfCount = sorted.length - firstHalfCount;
+    if (secondHalfCount > firstHalfCount) {
+      signals.push({
+        file,
+        metric: "churn",
+        trend: "declining",
+        dataPoints: sorted.map((c, i) => ({ date: c.date, value: i + 1 }))
+      });
+    }
+  }
+  return signals;
+}
+
+// src/trends/inconsistency.ts
+function detectInconsistencies(entries, minAuthors = 3) {
+  const fileAuthors = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      const authors = fileAuthors.get(file) ?? /* @__PURE__ */ new Map();
+      const commits = authors.get(entry.author) ?? [];
+      commits.push(entry.message);
+      authors.set(entry.author, commits);
+      fileAuthors.set(file, authors);
+    }
+  }
+  const inconsistencies = [];
+  for (const [file, authors] of fileAuthors) {
+    if (authors.size >= minAuthors) {
+      const patterns = Array.from(authors.entries()).map(([author, commits]) => ({
+        author,
+        style: categorizeStyle(commits)
+      }));
+      inconsistencies.push({ file, patterns });
+    }
+  }
+  return inconsistencies;
+}
+function categorizeStyle(commits) {
+  const types = commits.map((m) => {
+    if (m.match(/^fix/i)) return "fix";
+    if (m.match(/^feat/i)) return "feature";
+    if (m.match(/^refactor/i)) return "refactor";
+    return "other";
+  });
+  const primary = mode(types);
+  return `primarily ${primary} (${commits.length} commits)`;
+}
+function mode(arr) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    counts.set(item, (counts.get(item) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
+}
+
+// src/router/router.ts
+import picomatch2 from "picomatch";
 var DEFAULT_ROUTES = [
   { pattern: "**/auth/**", agents: ["reviewer"], irLayer: "L1" },
   { pattern: "**/*.test.*", agents: ["reviewer"], irLayer: "L0" },
@@ -36,7 +1319,7 @@ var FALLBACK = {
 };
 function route(finding, rules) {
   for (const rule of rules) {
-    if (!picomatch.isMatch(finding.file, rule.pattern)) continue;
+    if (!picomatch2.isMatch(finding.file, rule.pattern)) continue;
     if (rule.contentSignal) {
       const content = finding.message + (finding.file ?? "");
       if (!rule.contentSignal.test(content)) continue;
@@ -114,6 +1397,35 @@ var CLIAdapter = class {
   }
 };
 
+// src/benchmark/tokenizer.ts
+function estimateTokens(text) {
+  if (!text) return 0;
+  const tokens = text.split(/[\s]+|(?<=[{}()[\];,.:=<>!&|?+\-*/^~@#$%\\])|(?=[{}()[\];,.:=<>!&|?+\-*/^~@#$%\\])/).filter(Boolean);
+  return tokens.length;
+}
+
+// src/benchmark/runner.ts
+async function benchmarkFile(code, filePath) {
+  const rawTokens = estimateTokens(code);
+  const irL0 = await generateLayer("L0", { code, filePath, health: null });
+  const irL1 = await generateLayer("L1", { code, filePath, health: null });
+  const irL0Tokens = estimateTokens(irL0);
+  const irL1Tokens = estimateTokens(irL1);
+  const astResult = await astWalkIR(code, filePath);
+  const engine = astResult !== null ? "AST" : "FP";
+  const savedPercent = rawTokens > 0 ? (rawTokens - irL1Tokens) / rawTokens * 100 : 0;
+  return { file: filePath, rawTokens, irL0Tokens, irL1Tokens, savedPercent, engine };
+}
+function summarize(results) {
+  const totalRaw = results.reduce((s, r) => s + r.rawTokens, 0);
+  const totalIRL0 = results.reduce((s, r) => s + r.irL0Tokens, 0);
+  const totalIRL1 = results.reduce((s, r) => s + r.irL1Tokens, 0);
+  const totalSavedPercent = totalRaw > 0 ? (totalRaw - totalIRL1) / totalRaw * 100 : 0;
+  const astCount = results.filter((r) => r.engine === "AST").length;
+  const fpCount = results.filter((r) => r.engine === "FP").length;
+  return { fileCount: results.length, totalRaw, totalIRL0, totalIRL1, totalSavedPercent, astCount, fpCount };
+}
+
 // src/benchmark/quality.ts
 var BENCHMARK_PROMPTS = [
   {
@@ -180,35 +1492,1089 @@ async function runQualityBenchmark(code, filePath, apiKey, promptId = "understan
   return { file: filePath, raw: rawResult, ir: irResult, savedPercent };
 }
 
-// src/cli/commands.ts
-function collectFiles(dir, extensions) {
-  const files = [];
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
+// src/context/packer.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findTargetFile(files, target) {
+  const t = escapeRegex(target);
+  const declarationPatterns = [
+    // JS/TS declarations
+    new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?class\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?interface\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?type\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?enum\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${t}\\b`),
+    // Python
+    new RegExp(`\\bdef\\s+${t}\\b`),
+    // Rust
+    new RegExp(`\\bfn\\s+${t}\\b`),
+    new RegExp(`\\bstruct\\s+${t}\\b`),
+    new RegExp(`\\btrait\\s+${t}\\b`),
+    // Go
+    new RegExp(`\\bfunc\\s+${t}\\b`),
+    new RegExp(`\\btype\\s+${t}\\b`),
+    // Object method shorthand
+    new RegExp(`\\b${t}\\s*:\\s*(?:async\\s+)?function\\b`),
+    new RegExp(`\\b${t}\\s*\\([^)]*\\)\\s*\\{`)
+  ];
+  for (const pattern of declarationPatterns) {
+    const match2 = files.find((f) => pattern.test(f.code));
+    if (match2) return match2.path;
+  }
+  const fallback = new RegExp(`\\b${t}\\s*\\(`);
+  const match = files.find((f) => fallback.test(f.code));
+  return match ? match.path : null;
+}
+function findRelatedFiles(files, targetPath) {
+  const related = /* @__PURE__ */ new Set();
+  const targetFile = files.find((f) => f.path === targetPath);
+  if (!targetFile) return related;
+  const importPattern = /(?:import|require)\s*(?:\([^)]*|\{[^}]*\}|\w+)?\s*(?:from)?\s*["']([^"']+)["']/g;
+  const imports = [...targetFile.code.matchAll(importPattern)].map((m) => m[1]);
+  for (const imp of imports) {
+    const match = files.find((f) => {
+      const basename = f.path.replace(/\.[^.]+$/, "");
+      return imp.includes(basename) || basename.endsWith(imp.replace(/^\.\.?\//, "").replace(/\.[^.]+$/, ""));
+    });
+    if (match) related.add(match.path);
+  }
+  const targetBasename = targetPath.replace(/\.[^.]+$/, "").split("/").pop() ?? "";
+  for (const file of files) {
+    if (file.path === targetPath) continue;
+    if (file.code.includes(targetBasename)) {
+      related.add(file.path);
+    }
+  }
+  return related;
+}
+async function packContext(files, options) {
+  const { budget, hotspots, target } = options;
+  const hotspotSet = new Set(hotspots.map((h) => h.file));
+  let targetPath = null;
+  let relatedFiles = /* @__PURE__ */ new Set();
+  if (target) {
+    targetPath = findTargetFile(files, target);
+    if (targetPath) {
+      relatedFiles = findRelatedFiles(files, targetPath);
+    }
+  }
+  const entries = [];
+  let totalTokens = 0;
+  let filesAtL3 = 0;
+  let targetDowngraded = false;
+  if (targetPath) {
+    const targetFile = files.find((f) => f.path === targetPath);
+    const rawTokens = estimateTokens(targetFile.code);
+    if (rawTokens <= budget * 0.6) {
+      entries.push({
+        path: targetPath,
+        layer: "L3",
+        ir: targetFile.code,
+        tokens: rawTokens,
+        isTarget: true
+      });
+      totalTokens += rawTokens;
+      filesAtL3 = 1;
+    } else {
+      targetDowngraded = true;
+      const l1 = await generateLayer("L1", { code: targetFile.code, filePath: targetFile.path, health: null });
+      const l1Tokens = estimateTokens(l1);
+      entries.push({
+        path: targetPath,
+        layer: "L1",
+        ir: l1,
+        tokens: l1Tokens,
+        isTarget: true
+      });
+      totalTokens += l1Tokens;
+    }
+  }
+  for (const file of files) {
+    if (file.path === targetPath) continue;
+    const l0 = await generateLayer("L0", { code: file.code, filePath: file.path, health: null });
+    const l0Tokens = estimateTokens(l0);
+    entries.push({ path: file.path, layer: "L0", ir: l0, tokens: l0Tokens });
+    totalTokens += l0Tokens;
+  }
+  if (totalTokens > budget) {
+    const truncated = entries.filter((e) => e.isTarget);
+    let used = truncated.reduce((s, e) => s + e.tokens, 0);
     for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
-      if (entry.isDirectory()) {
-        files.push(...collectFiles(fullPath, extensions));
-      } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
-        files.push(fullPath);
+      if (entry.isTarget) continue;
+      if (used + entry.tokens <= budget) {
+        truncated.push(entry);
+        used += entry.tokens;
       }
     }
+    return {
+      entries: truncated,
+      totalTokens: used,
+      budget,
+      filesAtL0: truncated.filter((e) => e.layer === "L0").length,
+      filesAtL1: truncated.filter((e) => e.layer === "L1").length,
+      filesAtL3,
+      targetFile: targetPath ?? void 0,
+      targetDowngraded
+    };
+  }
+  const upgradeOrder = entries.map((e, i) => ({
+    index: i,
+    path: e.path,
+    rawTokens: files.find((f) => f.path === e.path)?.rawTokens ?? 0,
+    isHotspot: hotspotSet.has(e.path),
+    isRelated: relatedFiles.has(e.path),
+    isTarget: e.isTarget ?? false
+  })).filter((x) => x.isTarget === false && entries[x.index].layer === "L0").sort((a, b) => {
+    if (a.isRelated && !b.isRelated) return -1;
+    if (!a.isRelated && b.isRelated) return 1;
+    if (a.isHotspot && !b.isHotspot) return -1;
+    if (!a.isHotspot && b.isHotspot) return 1;
+    return b.rawTokens - a.rawTokens;
+  });
+  let filesAtL1 = 0;
+  for (const item of upgradeOrder) {
+    const file = files.find((f) => f.path === item.path);
+    const l1 = await generateLayer("L1", { code: file.code, filePath: file.path, health: null });
+    const l1Tokens = estimateTokens(l1);
+    const currentTokens = entries[item.index].tokens;
+    const additional = l1Tokens - currentTokens;
+    if (totalTokens + additional <= budget) {
+      entries[item.index] = {
+        path: item.path,
+        layer: "L1",
+        ir: l1,
+        tokens: l1Tokens
+      };
+      totalTokens += additional;
+      filesAtL1++;
+    }
+  }
+  return {
+    entries,
+    totalTokens,
+    budget,
+    filesAtL0: entries.filter((e) => e.layer === "L0").length,
+    filesAtL1,
+    filesAtL3,
+    targetFile: targetPath ?? void 0,
+    targetDowngraded
+  };
+}
+
+// src/utils/collectFiles.ts
+import { readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join2, relative } from "path";
+import ignore from "ignore";
+var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+function loadGitignore(dir) {
+  const ig = ignore();
+  try {
+    const raw = readFileSync2(join2(dir, ".gitignore"), "utf-8");
+    ig.add(raw);
   } catch {
   }
+  return ig;
+}
+function collectFiles(dir, extensions, projectPath) {
+  const root = projectPath ?? dir;
+  const files = [];
+  function walk(currentDir, parentIgnore) {
+    const ig = loadGitignore(currentDir);
+    const merged = ignore().add(parentIgnore).add(ig);
+    try {
+      const entries = readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || ALWAYS_SKIP.has(entry.name)) continue;
+        const fullPath = join2(currentDir, entry.name);
+        const relPath = relative(root, fullPath);
+        if (merged.ignores(relPath)) continue;
+        if (entry.isDirectory()) {
+          walk(fullPath, merged);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir, ignore());
   return files;
 }
+
+// src/memory/db.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+function openDatabase(path) {
+  mkdirSync(dirname2(path), { recursive: true });
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+// src/memory/schema.ts
+var CURRENT_VERSION = 1;
+var V1_SQL = `
+CREATE TABLE IF NOT EXISTS index_state (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS commits (
+  sha         TEXT PRIMARY KEY,
+  parent_sha  TEXT,
+  author      TEXT NOT NULL,
+  timestamp   INTEGER NOT NULL,
+  subject     TEXT NOT NULL,
+  is_fix      INTEGER NOT NULL,
+  is_revert   INTEGER NOT NULL,
+  reverts_sha TEXT,
+  FOREIGN KEY (reverts_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits(timestamp);
+CREATE INDEX IF NOT EXISTS idx_commits_is_fix    ON commits(is_fix) WHERE is_fix = 1;
+
+CREATE TABLE IF NOT EXISTS file_touches (
+  commit_sha    TEXT NOT NULL,
+  file_path     TEXT NOT NULL,
+  adds          INTEGER NOT NULL,
+  dels          INTEGER NOT NULL,
+  change_type   TEXT NOT NULL,
+  renamed_from  TEXT,
+  PRIMARY KEY (commit_sha, file_path),
+  FOREIGN KEY (commit_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_ft_file ON file_touches(file_path);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id              INTEGER PRIMARY KEY,
+  file_path       TEXT NOT NULL,
+  kind            TEXT NOT NULL,
+  qualified_name  TEXT NOT NULL,
+  first_seen_sha  TEXT NOT NULL,
+  last_seen_sha   TEXT,
+  UNIQUE (file_path, kind, qualified_name)
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+
+CREATE TABLE IF NOT EXISTS symbol_touches (
+  commit_sha    TEXT NOT NULL,
+  symbol_id     INTEGER NOT NULL,
+  change_type   TEXT NOT NULL,
+  PRIMARY KEY (commit_sha, symbol_id),
+  FOREIGN KEY (commit_sha) REFERENCES commits(sha),
+  FOREIGN KEY (symbol_id)  REFERENCES symbols(id)
+);
+CREATE INDEX IF NOT EXISTS idx_st_symbol ON symbol_touches(symbol_id);
+
+CREATE TABLE IF NOT EXISTS fix_links (
+  fix_commit_sha       TEXT NOT NULL,
+  suspected_break_sha  TEXT NOT NULL,
+  evidence_type        TEXT NOT NULL,
+  confidence           REAL NOT NULL,
+  window_hours         INTEGER,
+  PRIMARY KEY (fix_commit_sha, suspected_break_sha, evidence_type),
+  FOREIGN KEY (fix_commit_sha)      REFERENCES commits(sha),
+  FOREIGN KEY (suspected_break_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_fl_break ON fix_links(suspected_break_sha);
+
+CREATE TABLE IF NOT EXISTS signal_calibration (
+  signal_type        TEXT PRIMARY KEY,
+  precision          REAL NOT NULL,
+  sample_size        INTEGER NOT NULL,
+  last_computed_sha  TEXT NOT NULL,
+  computed_at        INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS file_index_state (
+  file_path            TEXT PRIMARY KEY,
+  last_commit_indexed  TEXT NOT NULL,
+  last_blob_indexed    TEXT,
+  indexed_at           INTEGER NOT NULL,
+  parse_failed         INTEGER NOT NULL DEFAULT 0,
+  FOREIGN KEY (last_commit_indexed) REFERENCES commits(sha)
+);
+`;
+function runMigrations(db) {
+  const current = db.pragma("user_version", { simple: true });
+  if (current >= CURRENT_VERSION) return;
+  db.exec("BEGIN");
+  try {
+    db.exec(V1_SQL);
+    db.pragma(`user_version = ${CURRENT_VERSION}`);
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/memory/git.ts
+import { execSync as execSync2 } from "child_process";
+function run(cwd, cmd, timeoutMs = 1e4) {
+  return execSync2(cmd, { cwd, encoding: "utf-8", timeout: timeoutMs }).trim();
+}
+function revParseHead(cwd) {
+  return run(cwd, "git rev-parse HEAD");
+}
+function isShallowRepo(cwd) {
+  return run(cwd, "git rev-parse --is-shallow-repository") === "true";
+}
+function revListCount(cwd, from, to) {
+  if (from === to) return 0;
+  const out = run(cwd, `git rev-list --count ${from}..${to}`);
+  return parseInt(out, 10);
+}
+function isAncestor(cwd, ancestor, descendant) {
+  try {
+    execSync2(`git merge-base --is-ancestor ${ancestor} ${descendant}`, {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function countCommits(cwd) {
+  const out = run(cwd, "git rev-list --count HEAD");
+  return parseInt(out, 10);
+}
+
+// src/memory/freshness.ts
+function ensureFresh(db, repoPath) {
+  const head = revParseHead(repoPath);
+  const row = db.prepare("SELECT value FROM index_state WHERE key = 'last_indexed_sha'").get();
+  if (!row) {
+    return {
+      tazelik: "bootstrapping",
+      head,
+      delta: { from: null, to: head },
+      behind_by: 0,
+      rewritten: false
+    };
+  }
+  const last = row.value;
+  if (last === head) {
+    return { tazelik: "fresh", head, delta: null, behind_by: 0, rewritten: false };
+  }
+  const reachable = isAncestor(repoPath, last, head);
+  if (!reachable) {
+    return {
+      tazelik: "bootstrapping",
+      head,
+      delta: { from: null, to: head },
+      behind_by: 0,
+      rewritten: true
+    };
+  }
+  const behind_by = revListCount(repoPath, last, head);
+  return {
+    tazelik: "catching_up",
+    head,
+    delta: { from: last, to: head },
+    behind_by,
+    rewritten: false
+  };
+}
+
+// src/memory/signals/calibration-lookup.ts
+function getCalibration(db, type, fallbackPrecision) {
+  const row = db.prepare("SELECT precision, sample_size FROM signal_calibration WHERE signal_type = ?").get(type);
+  if (!row) {
+    return { precision: fallbackPrecision, sampleSize: 0, source: "heuristic" };
+  }
+  return {
+    precision: row.precision,
+    sampleSize: row.sample_size,
+    source: "repo-calibrated"
+  };
+}
+
+// src/memory/signals/revert-match.ts
+var STRENGTH_BY_EVIDENCE = {
+  revert_marker: 1,
+  short_followup_fix: 0.7,
+  same_region_fix_chain: 0.4
+};
+var FALLBACK_PRECISION = 0.5;
+var MAX_EVIDENCE = 5;
+function computeRevertMatch(db, filePath) {
+  const rows = db.prepare(`
+      SELECT fl.evidence_type, fl.confidence, fl.suspected_break_sha,
+             c.subject, c.timestamp
+        FROM fix_links fl
+        JOIN file_touches ft ON ft.commit_sha = fl.suspected_break_sha
+        JOIN commits c ON c.sha = fl.suspected_break_sha
+       WHERE ft.file_path = ?
+       ORDER BY c.timestamp DESC
+       LIMIT ?
+    `).all(filePath, MAX_EVIDENCE);
+  const cal = getCalibration(db, "revert_match", FALLBACK_PRECISION);
+  if (rows.length === 0) {
+    return {
+      type: "revert_match",
+      strength: 0,
+      precision: cal.precision,
+      sample_size: cal.sampleSize,
+      evidence: []
+    };
+  }
+  let strength = 0;
+  const evidence = [];
+  const now = Math.floor(Date.now() / 1e3);
+  for (const r of rows) {
+    const s = STRENGTH_BY_EVIDENCE[r.evidence_type] ?? 0;
+    if (s > strength) strength = s;
+    evidence.push({
+      commit_sha: r.suspected_break_sha,
+      subject: r.subject,
+      days_ago: Math.floor((now - r.timestamp) / 86400),
+      evidence_type: r.evidence_type
+    });
+  }
+  return {
+    type: "revert_match",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence
+  };
+}
+
+// src/memory/signals/hotspot.ts
+var WINDOW_SECONDS = 90 * 86400;
+var SATURATION_TOUCHES = 30;
+var FALLBACK_PRECISION2 = 0.3;
+function computeHotspot(db, filePath) {
+  const now = Math.floor(Date.now() / 1e3);
+  const lowerBound = now - WINDOW_SECONDS;
+  const row = db.prepare(`
+      SELECT COUNT(*) AS n
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ? AND c.timestamp >= ?
+    `).get(filePath, lowerBound);
+  const touches = row.n;
+  const strength = Math.min(1, touches / SATURATION_TOUCHES);
+  const cal = getCalibration(db, "hotspot", FALLBACK_PRECISION2);
+  return {
+    type: "hotspot",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: [],
+    touches_90d: touches
+  };
+}
+
+// src/memory/signals/fix-ratio.ts
+var WINDOW_COMMITS = 30;
+var DEAD_ZONE = 0.3;
+var SATURATION_OVER_DEAD_ZONE = 0.5;
+var FALLBACK_PRECISION3 = 0.3;
+function computeFixRatio(db, filePath) {
+  const rows = db.prepare(`
+      SELECT c.is_fix
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ?
+      ORDER BY c.timestamp DESC
+      LIMIT ?
+    `).all(filePath, WINDOW_COMMITS);
+  const cal = getCalibration(db, "fix_ratio", FALLBACK_PRECISION3);
+  if (rows.length === 0) {
+    return {
+      type: "fix_ratio",
+      strength: 0,
+      precision: cal.precision,
+      sample_size: cal.sampleSize,
+      evidence: [],
+      ratio: 0
+    };
+  }
+  const fixes = rows.filter((r) => r.is_fix === 1).length;
+  const ratio = fixes / rows.length;
+  const strength = Math.max(0, Math.min(1, (ratio - DEAD_ZONE) / SATURATION_OVER_DEAD_ZONE));
+  return {
+    type: "fix_ratio",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: [],
+    ratio
+  };
+}
+
+// src/memory/signals/coverage-decline.ts
+var FALLBACK_PRECISION4 = 0.3;
+function computeCoverageDecline(db, repoPath, filePath) {
+  const cal = getCalibration(db, "coverage_decline", FALLBACK_PRECISION4);
+  let strength = 0;
+  try {
+    const entries = getGitLog(repoPath, 200);
+    const trends = {
+      hotspots: detectHotspots(entries, { threshold: 10, fixRatioThreshold: 0.5 }),
+      decaySignals: detectDecay(entries),
+      inconsistencies: detectInconsistencies(entries)
+    };
+    const health = computeHealthFromTrends(filePath, trends);
+    if (health.coverageTrend === "down") strength = 1;
+  } catch {
+    strength = 0;
+  }
+  return {
+    type: "coverage_decline",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: []
+  };
+}
+
+// src/memory/signals/author-churn.ts
+var WINDOW_SECONDS2 = 90 * 86400;
+var INACTIVE_THRESHOLD = 5;
+var FALLBACK_PRECISION5 = 0.3;
+function computeAuthorChurn(db, filePath) {
+  const cal = getCalibration(db, "author_churn", FALLBACK_PRECISION5);
+  const base = {
+    type: "author_churn",
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: []
+  };
+  const lastTouch = db.prepare(`
+      SELECT c.author, c.timestamp
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ?
+      ORDER BY c.timestamp DESC
+      LIMIT 1
+    `).get(filePath);
+  if (!lastTouch) return { ...base, strength: 0 };
+  const now = Math.floor(Date.now() / 1e3);
+  const lowerBound = now - WINDOW_SECONDS2;
+  const activity = db.prepare(`SELECT COUNT(*) AS n FROM commits WHERE author = ? AND timestamp >= ?`).get(lastTouch.author, lowerBound);
+  let strength = 0;
+  if (activity.n === 0) strength = 1;
+  else if (activity.n < INACTIVE_THRESHOLD) strength = 0.5;
+  return { ...base, strength };
+}
+
+// src/memory/signals/index.ts
+function collectSignals(db, repoPath, filePath) {
+  return [
+    computeRevertMatch(db, filePath),
+    computeHotspot(db, filePath),
+    computeFixRatio(db, filePath),
+    computeCoverageDecline(db, repoPath, filePath),
+    computeAuthorChurn(db, filePath)
+  ];
+}
+
+// src/memory/confidence.ts
+var USABLE_SAMPLE_THRESHOLD = 20;
+function coverageFactor(signals) {
+  const usable = signals.filter(
+    (s) => s.strength > 0 && s.sample_size >= USABLE_SAMPLE_THRESHOLD
+  ).length;
+  return Math.min(1, usable / 3);
+}
+function calibrationFactor(signals) {
+  const firing = signals.filter((s) => s.strength > 0);
+  if (firing.length === 0) return 1;
+  const avg = firing.reduce((acc, s) => acc + s.sample_size, 0) / firing.length;
+  if (avg < 20) return 0.3;
+  if (avg < 100) return 0.6;
+  return 1;
+}
+function freshnessFactor(ctx) {
+  if (ctx.partial) return 0.4;
+  switch (ctx.tazelik) {
+    case "fresh":
+      return 1;
+    case "catching_up":
+      return 0.8;
+    case "partial":
+      return 0.4;
+    case "bootstrapping":
+      return 0.2;
+  }
+}
+function historyFactor(totalCommits) {
+  if (totalCommits < 50) return 0.2;
+  if (totalCommits < 200) return 0.5;
+  if (totalCommits < 1e3) return 0.8;
+  return 1;
+}
+function computeScoreAndConfidence(signals, ctx) {
+  let num = 0;
+  let den = 0;
+  for (const s of signals) {
+    if (s.strength <= 0 || s.precision <= 0) continue;
+    num += s.strength * s.precision;
+    den += s.precision;
+  }
+  const score = den === 0 ? 0 : num / den;
+  const confidence = Math.min(
+    coverageFactor(signals),
+    calibrationFactor(signals),
+    freshnessFactor(ctx),
+    historyFactor(ctx.totalCommits)
+  );
+  return { score, confidence };
+}
+
+// src/memory/verdict.ts
+function mapVerdict(score, confidence) {
+  if (confidence < 0.3) return "unknown";
+  if (score < 0.3) return "low";
+  if (score < 0.6) return "medium";
+  return "high";
+}
+
+// src/memory/envelope.ts
+var CONFIDENCE_CAP = {
+  ok: 1,
+  empty_repo: 0,
+  insufficient_history: 0.3,
+  shallow_clone: 0,
+  indexing: 0.4,
+  squashed_history: 0.5,
+  reindexing: 0,
+  internal_error: 0,
+  disabled: 0
+};
+var USABLE_SAMPLE_THRESHOLD2 = 20;
+function inferCalibrationSource(signals) {
+  return signals.some((s) => s.sample_size > 0) ? "repo-calibrated" : "heuristic";
+}
+function buildEnvelope(args2) {
+  const cap = CONFIDENCE_CAP[args2.status];
+  const cappedConfidence = Math.min(args2.confidence, cap);
+  const verdict = mapVerdict(args2.score, cappedConfidence);
+  const usable = args2.signals.filter(
+    (s) => s.strength > 0 && s.sample_size >= USABLE_SAMPLE_THRESHOLD2
+  ).length;
+  return {
+    status: args2.status,
+    reason: args2.reason,
+    verdict,
+    score: args2.score,
+    confidence: cappedConfidence,
+    signals: args2.signals,
+    calibration: inferCalibrationSource(args2.signals),
+    retry_hint_ms: args2.retry_hint_ms,
+    confidence_cap: args2.status === "ok" ? void 0 : cap,
+    metadata: {
+      tazelik: args2.tazelik,
+      index_version: 1,
+      indexed_commits_through: args2.indexedThrough,
+      indexed_commits_total: args2.indexedTotal,
+      query_ms: args2.queryMs,
+      signal_coverage: `${usable}/${args2.signals.length}`
+    }
+  };
+}
+
+// src/memory/pool.ts
+import { Worker } from "worker_threads";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+function resolveWorkerPath() {
+  const here = dirname3(fileURLToPath2(import.meta.url));
+  if (here.endsWith("/memory") || here.endsWith("\\memory")) {
+    return join3(here, "worker.js");
+  }
+  return join3(here, "memory", "worker.js");
+}
+var WorkerPool = class {
+  workers = [];
+  nextJobId = 1;
+  pending = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    const size = Math.max(1, opts.size ?? 1);
+    for (let i = 0; i < size; i++) this.spawn();
+  }
+  spawn() {
+    const worker = new Worker(resolveWorkerPath());
+    worker.on("message", (msg) => {
+      const job = this.pending.get(msg.jobId);
+      if (!job) return;
+      this.pending.delete(msg.jobId);
+      if (msg.type === "ingest_done") {
+        job.resolve({ status: "done", commits: msg.commits });
+      } else if (msg.type === "ingest_error") {
+        job.reject(new Error(msg.message));
+      }
+    });
+    worker.on("error", (err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      for (const job of this.pending.values()) job.reject(error);
+      this.pending.clear();
+    });
+    this.workers.push(worker);
+  }
+  runIngest(args2) {
+    const jobId = this.nextJobId++;
+    const worker = this.workers[jobId % this.workers.length];
+    return new Promise((resolve3, reject) => {
+      this.pending.set(jobId, { resolve: resolve3, reject });
+      worker.postMessage({ type: "ingest", jobId, ...args2 });
+    });
+  }
+  async close() {
+    await Promise.all(this.workers.map((w) => w.terminate()));
+    this.workers = [];
+    this.pending.clear();
+  }
+};
+
+// src/memory/detectors.ts
+function detectSquashed(db) {
+  const row = db.prepare(`
+    SELECT author, COUNT(*) AS n, MIN(timestamp) AS t0, MAX(timestamp) AS t1
+    FROM commits
+    GROUP BY author
+    ORDER BY n DESC
+    LIMIT 1
+  `).get();
+  if (!row || row.n < 50) return false;
+  const span = row.t1 - row.t0;
+  return span < 86400;
+}
+
+// src/memory/failure-tracker.ts
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+var STRIKE_THRESHOLD = 3;
+var WINDOW_SECONDS3 = 300;
+function createFailureTracker(composto_dir) {
+  const path = join4(composto_dir, "failures.json");
+  try {
+    mkdirSync2(composto_dir, { recursive: true });
+  } catch {
+  }
+  function load() {
+    try {
+      const raw = readFileSync3(path, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { failures: [], disabled: false };
+    }
+  }
+  function save(s) {
+    try {
+      writeFileSync(path, JSON.stringify(s), "utf-8");
+    } catch {
+    }
+  }
+  function now() {
+    return Math.floor(Date.now() / 1e3);
+  }
+  return {
+    recordFailure: (failureClass) => {
+      const s = load();
+      s.failures.push({ class: failureClass, t: now() });
+      s.failures = s.failures.filter((f) => now() - f.t <= WINDOW_SECONDS3);
+      const sameClass = s.failures.filter((f) => f.class === failureClass);
+      if (sameClass.length >= STRIKE_THRESHOLD) s.disabled = true;
+      save(s);
+    },
+    recordSuccess: () => {
+      save({ failures: [], disabled: false });
+    },
+    isDisabled: () => {
+      return load().disabled;
+    }
+  };
+}
+
+// src/memory/log.ts
+import { appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, renameSync, statSync, unlinkSync } from "fs";
+import { join as join5 } from "path";
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var RETENTION_DAYS = 7;
+function currentThreshold() {
+  const raw = (process.env.COMPOSTO_LOG ?? "info").toLowerCase();
+  if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") return raw;
+  return "info";
+}
+function rotateIfNeeded(dir) {
+  const logPath = join5(dir, "index.log");
+  try {
+    const s = statSync(logPath);
+    const age = (Date.now() - s.mtimeMs) / 864e5;
+    if (age < 1) return;
+    const files = readdirSync2(dir).filter((f) => /^index\.log(\.\d+)?$/.test(f));
+    const numbered = files.map((f) => {
+      const m = f.match(/^index\.log\.(\d+)$/);
+      return { name: f, n: m ? parseInt(m[1], 10) : 0 };
+    }).sort((a, b) => b.n - a.n);
+    for (const f of numbered) {
+      if (f.n >= RETENTION_DAYS) {
+        unlinkSync(join5(dir, f.name));
+        continue;
+      }
+      if (f.n === 0) {
+        renameSync(join5(dir, f.name), join5(dir, "index.log.1"));
+      } else {
+        renameSync(join5(dir, f.name), join5(dir, `index.log.${f.n + 1}`));
+      }
+    }
+  } catch {
+  }
+}
+function createLogger(composto_dir) {
+  let disabled = false;
+  try {
+    mkdirSync3(composto_dir, { recursive: true });
+    rotateIfNeeded(composto_dir);
+  } catch {
+    disabled = true;
+  }
+  const path = join5(composto_dir, "index.log");
+  const threshold = currentThreshold();
+  function write(level, evt, extras) {
+    if (disabled) return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[threshold]) return;
+    const line = JSON.stringify({
+      t: Math.floor(Date.now() / 1e3),
+      lvl: level,
+      evt,
+      ...extras ?? {}
+    });
+    try {
+      appendFileSync(path, line + "\n", "utf-8");
+    } catch {
+      disabled = true;
+    }
+  }
+  return {
+    debug: (evt, extras) => write("debug", evt, extras),
+    info: (evt, extras) => write("info", evt, extras),
+    warn: (evt, extras) => write("warn", evt, extras),
+    error: (evt, extras) => write("error", evt, extras),
+    close: () => {
+    }
+  };
+}
+
+// src/memory/api.ts
+import { dirname as dirname4 } from "path";
+var EMPTY_REPO_THRESHOLD = 10;
+var MemoryAPI = class {
+  db;
+  pool;
+  dbPath;
+  repoPath;
+  compostoDir;
+  log;
+  failures;
+  bootstrapPromise = null;
+  constructor(opts) {
+    this.dbPath = opts.dbPath;
+    this.repoPath = opts.repoPath;
+    this.compostoDir = dirname4(opts.dbPath);
+    this.log = createLogger(this.compostoDir);
+    this.failures = createFailureTracker(this.compostoDir);
+    this.db = openDatabase(opts.dbPath);
+    runMigrations(this.db);
+    this.pool = new WorkerPool({ size: opts.workerPoolSize ?? 1 });
+    this.log.info("api_open", { dbPath: opts.dbPath });
+  }
+  async bootstrapIfNeeded() {
+    if (this.bootstrapPromise) return this.bootstrapPromise;
+    const fresh = ensureFresh(this.db, this.repoPath);
+    if (fresh.tazelik === "fresh" || !fresh.delta) return;
+    this.bootstrapPromise = this.pool.runIngest({ dbPath: this.dbPath, repoPath: this.repoPath, range: fresh.delta }).then(() => {
+      this.log.info("bootstrap_done", { through: fresh.delta?.to });
+    }).catch((err) => {
+      this.log.error("bootstrap_failed", { message: err.message });
+      this.failures.recordFailure("ingest_failure");
+      throw err;
+    }).finally(() => {
+      this.bootstrapPromise = null;
+    });
+    return this.bootstrapPromise;
+  }
+  async blastradius(input) {
+    const start = Date.now();
+    if (this.failures.isDisabled()) {
+      this.log.warn("call_on_disabled", { file: input.file });
+      return buildEnvelope({
+        status: "disabled",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: "tool disabled after repeated failures; clear .composto/failures.json to re-enable"
+      });
+    }
+    try {
+      return await this.runQuery(input, start);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.error("internal_error", { file: input.file, message });
+      this.failures.recordFailure("internal_error");
+      return buildEnvelope({
+        status: "internal_error",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: `internal error: ${message}; see .composto/index.log`
+      });
+    }
+  }
+  async runQuery(input, start) {
+    if (isShallowRepo(this.repoPath)) {
+      return buildEnvelope({
+        status: "shallow_clone",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: "shallow clone detected; run `git fetch --unshallow` or `composto index --deepen`"
+      });
+    }
+    const totalCommits = countCommits(this.repoPath);
+    if (totalCommits < EMPTY_REPO_THRESHOLD) {
+      return buildEnvelope({
+        status: "empty_repo",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: totalCommits,
+        queryMs: Date.now() - start,
+        reason: `repo has ${totalCommits} commits; blastradius requires >= ${EMPTY_REPO_THRESHOLD}`
+      });
+    }
+    const fresh = ensureFresh(this.db, this.repoPath);
+    let status = "ok";
+    if (fresh.rewritten) {
+      status = "reindexing";
+      this.log.warn("history_rewritten", { last_indexed: fresh.head });
+    }
+    if (fresh.tazelik === "bootstrapping") {
+      await this.bootstrapIfNeeded();
+    } else if (fresh.tazelik === "catching_up" && fresh.delta) {
+      this.pool.runIngest({ dbPath: this.dbPath, repoPath: this.repoPath, range: fresh.delta }).catch((err) => {
+        this.log.error("delta_ingest_failed", { message: err.message });
+      });
+    }
+    if (status === "ok" && detectSquashed(this.db)) {
+      status = "squashed_history";
+    }
+    const indexedTotalRow = this.db.prepare("SELECT value FROM index_state WHERE key='indexed_commits_total'").get();
+    const indexedTotal = indexedTotalRow ? parseInt(indexedTotalRow.value, 10) : 0;
+    const indexedThrough = this.db.prepare("SELECT value FROM index_state WHERE key='last_indexed_sha'").get()?.value ?? "";
+    const signals = collectSignals(this.db, this.repoPath, input.file);
+    const tazelik = fresh.tazelik === "bootstrapping" ? "fresh" : fresh.tazelik;
+    const { score, confidence } = computeScoreAndConfidence(signals, {
+      tazelik,
+      partial: false,
+      totalCommits: indexedTotal
+    });
+    const response = buildEnvelope({
+      status,
+      signals,
+      score,
+      confidence,
+      tazelik,
+      indexedThrough,
+      indexedTotal,
+      queryMs: Date.now() - start
+    });
+    this.log.info("query", {
+      file: input.file,
+      status: response.status,
+      verdict: response.verdict,
+      confidence: response.confidence,
+      query_ms: response.metadata.query_ms
+    });
+    this.failures.recordSuccess();
+    return response;
+  }
+  async close() {
+    this.log.info("api_close", {});
+    this.log.close();
+    this.db.close();
+    await this.pool.close();
+  }
+};
+
+// src/memory/status.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+function collectStatus(dbPath) {
+  const db = openDatabase(dbPath);
+  try {
+    const schemaVersion = db.pragma("user_version", { simple: true });
+    const totalRow = db.prepare(
+      "SELECT value FROM index_state WHERE key='indexed_commits_total'"
+    ).get();
+    const headRow = db.prepare(
+      "SELECT value FROM index_state WHERE key='last_indexed_sha'"
+    ).get();
+    const calRefreshRow = db.prepare(
+      "SELECT value FROM index_state WHERE key='calibration_last_refreshed_at'"
+    ).get();
+    const filesWithDeepIndex = db.prepare("SELECT COUNT(*) AS n FROM file_index_state").get().n;
+    const calibrationRows = db.prepare("SELECT COUNT(*) AS n FROM signal_calibration").get().n;
+    const storageBytes = statFileSize(dbPath) + statFileSize(dbPath + "-wal") + statFileSize(dbPath + "-shm");
+    const integrityOk = db.prepare("PRAGMA integrity_check").get().integrity_check === "ok";
+    return {
+      schemaVersion,
+      bootstrapped: !!headRow,
+      indexedCommitsThrough: headRow?.value ?? "",
+      indexedCommitsTotal: totalRow ? parseInt(totalRow.value, 10) : 0,
+      filesWithDeepIndex,
+      calibrationLastRefreshedAt: calRefreshRow ? parseInt(calRefreshRow.value, 10) : null,
+      calibrationRows,
+      storageBytes,
+      integrityOk
+    };
+  } finally {
+    db.close();
+  }
+}
+function statFileSize(path) {
+  try {
+    return existsSync3(path) ? statSync2(path).size : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/cli/commands.ts
 function runScan(projectPath) {
   const adapter = new CLIAdapter();
   const config = loadConfig(projectPath);
-  console.log("composto v0.2.3 \u2014 scanning...\n");
+  console.log("composto v0.4.1 \u2014 scanning...\n");
   const files = collectFiles(projectPath, [".ts", ".tsx", ".js", ".jsx"]);
   console.log(`  Found ${files.length} files
 `);
   const allFindings = [];
   for (const file of files) {
-    const code = readFileSync(file, "utf-8");
-    const relPath = relative(projectPath, file);
+    const code = readFileSync4(file, "utf-8");
+    const relPath = relative2(projectPath, file);
     const findings = runDetector(code, relPath, config.watchers);
     allFindings.push(...findings);
   }
@@ -228,7 +2594,7 @@ function runScan(projectPath) {
 function runTrends(projectPath) {
   const adapter = new CLIAdapter();
   const config = loadConfig(projectPath);
-  console.log("composto v0.2.3 \u2014 trend analysis...\n");
+  console.log("composto v0.4.1 \u2014 trend analysis...\n");
   const entries = getGitLog(projectPath, 100);
   if (entries.length === 0) {
     console.log("  No git history found.\n");
@@ -248,8 +2614,8 @@ function runTrends(projectPath) {
 }
 async function runIR(projectPath, filePath, layer) {
   const config = loadConfig(projectPath);
-  const code = readFileSync(filePath, "utf-8");
-  const relPath = relative(projectPath, filePath);
+  const code = readFileSync4(filePath, "utf-8");
+  const relPath = relative2(projectPath, filePath);
   const entries = getGitLog(projectPath, 100);
   const trends = {
     hotspots: detectHotspots(entries, {
@@ -270,14 +2636,14 @@ async function runIR(projectPath, filePath, layer) {
 }
 var ALL_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs"];
 async function runBenchmark(projectPath) {
-  console.log("composto v0.2.3 \u2014 benchmark\n");
+  console.log("composto v0.4.1 \u2014 benchmark\n");
   const files = collectFiles(projectPath, ALL_EXTENSIONS);
   console.log(`  ${files.length} files
 `);
   const results = [];
   for (const file of files) {
-    const code = readFileSync(file, "utf-8");
-    const relPath = relative(projectPath, file);
+    const code = readFileSync4(file, "utf-8");
+    const relPath = relative2(projectPath, file);
     results.push(await benchmarkFile(code, relPath));
   }
   results.sort((a, b) => b.savedPercent - a.savedPercent);
@@ -315,9 +2681,9 @@ async function runBenchmarkQuality(projectPath, filePath) {
     console.error("  Error: ANTHROPIC_API_KEY environment variable is required.");
     process.exit(1);
   }
-  const code = readFileSync(filePath, "utf-8");
-  const relPath = relative(projectPath, filePath);
-  console.log("composto v0.2.3 \u2014 quality benchmark\n");
+  const code = readFileSync4(filePath, "utf-8");
+  const relPath = relative2(projectPath, filePath);
+  console.log("composto v0.4.1 \u2014 quality benchmark\n");
   console.log(`  File: ${relPath}
 `);
   console.log("  Sending to Claude Haiku...\n");
@@ -347,8 +2713,8 @@ ${result.ir.response}
   }
 }
 async function runContext(projectPath, budget, target) {
-  const header = target ? `composto v0.2.3 \u2014 context (target: ${target}, budget: ${budget} tokens)
-` : `composto v0.2.3 \u2014 context (budget: ${budget} tokens)
+  const header = target ? `composto v0.4.1 \u2014 context (target: ${target}, budget: ${budget} tokens)
+` : `composto v0.4.1 \u2014 context (budget: ${budget} tokens)
 `;
   console.log(header);
   const files = collectFiles(projectPath, ALL_EXTENSIONS);
@@ -361,8 +2727,8 @@ async function runContext(projectPath, budget, target) {
     fixRatioThreshold: config.trends.bugFixRatioThreshold
   });
   const fileInputs = files.map((file) => {
-    const code = readFileSync(file, "utf-8");
-    const relPath = relative(projectPath, file);
+    const code = readFileSync4(file, "utf-8");
+    const relPath = relative2(projectPath, file);
     return { path: relPath, code, rawTokens: estimateTokens(code) };
   });
   const result = await packContext(fileInputs, { budget, hotspots, target });
@@ -416,19 +2782,88 @@ async function runContext(projectPath, budget, target) {
   console.log(`  Budget: ${result.totalTokens}/${result.budget} tokens`);
   console.log(`  Files: ${parts.join(", ")}`);
 }
+async function runImpact(projectPath, file, opts = {}) {
+  const dbPath = join6(projectPath, ".composto", "memory.db");
+  const api = new MemoryAPI({ dbPath, repoPath: projectPath });
+  try {
+    await api.bootstrapIfNeeded();
+    const res = await api.blastradius({
+      file,
+      intent: opts.intent,
+      level: opts.level
+    });
+    if (res.status !== "ok") {
+      console.log(`status:     ${res.status}`);
+      if (res.reason) console.log(`reason:     ${res.reason}`);
+      console.log(`verdict:    ${res.verdict}`);
+      console.log(`confidence: ${res.confidence.toFixed(2)}`);
+      return;
+    }
+    console.log(`verdict:    ${res.verdict}`);
+    console.log(`score:      ${res.score.toFixed(2)}`);
+    console.log(`confidence: ${res.confidence.toFixed(2)}`);
+    console.log(`tazelik:    ${res.metadata.tazelik}`);
+    console.log(`signals:`);
+    for (const s of res.signals) {
+      const bar = s.strength > 0 ? "\u25A0".repeat(Math.max(1, Math.round(s.strength * 10))) : "\xB7";
+      console.log(`  ${s.type.padEnd(18)} ${bar.padEnd(10)} strength=${s.strength.toFixed(2)} precision=${s.precision.toFixed(2)}`);
+    }
+  } finally {
+    await api.close();
+  }
+}
+async function runIndex(projectPath) {
+  const dbPath = join6(projectPath, ".composto", "memory.db");
+  const api = new MemoryAPI({ dbPath, repoPath: projectPath });
+  try {
+    console.log("composto: bootstrapping memory index...");
+    const start = Date.now();
+    await api.bootstrapIfNeeded();
+    console.log(`composto: index ready (${Date.now() - start} ms)`);
+  } finally {
+    await api.close();
+  }
+}
+async function runIndexStatus(projectPath) {
+  const dbPath = join6(projectPath, ".composto", "memory.db");
+  const s = collectStatus(dbPath);
+  console.log(`Composto Memory \u2014 ${projectPath}
+`);
+  console.log("Index state");
+  console.log(`  Schema version:           ${s.schemaVersion}`);
+  console.log(`  Bootstrapped:             ${s.bootstrapped ? "yes" : "no"}`);
+  console.log(`  Indexed through:          ${s.indexedCommitsThrough || "(none)"}`);
+  console.log(`  Indexed commits total:    ${s.indexedCommitsTotal}`);
+  console.log(`  Files w/ deep index:      ${s.filesWithDeepIndex}`);
+  console.log();
+  console.log("Calibration");
+  if (s.calibrationLastRefreshedAt) {
+    const dt = new Date(s.calibrationLastRefreshedAt * 1e3).toISOString();
+    console.log(`  Last refreshed:           ${dt}`);
+  } else {
+    console.log(`  Last refreshed:           (never)`);
+  }
+  console.log(`  Rows populated:           ${s.calibrationRows} / 5`);
+  console.log();
+  console.log("Storage");
+  console.log(`  DB + WAL + SHM:           ${(s.storageBytes / 1024).toFixed(1)} KB`);
+  console.log();
+  console.log("Health");
+  console.log(`  Integrity check:          ${s.integrityOk ? "OK" : "FAIL"}`);
+}
 
 // src/index.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 var args = process.argv.slice(2);
 var command = args[0];
 switch (command) {
   case "scan": {
-    const projectPath = resolve(args[1] ?? ".");
+    const projectPath = resolve2(args[1] ?? ".");
     runScan(projectPath);
     break;
   }
   case "trends": {
-    const projectPath = resolve(args[1] ?? ".");
+    const projectPath = resolve2(args[1] ?? ".");
     runTrends(projectPath);
     break;
   }
@@ -439,11 +2874,11 @@ switch (command) {
       console.error("Usage: composto ir <file> [L0|L1|L2|L3]");
       process.exit(1);
     }
-    await runIR(resolve("."), resolve(filePath), layer);
+    await runIR(resolve2("."), resolve2(filePath), layer);
     break;
   }
   case "benchmark": {
-    const projectPath = resolve(args[1] ?? ".");
+    const projectPath = resolve2(args[1] ?? ".");
     await runBenchmark(projectPath);
     break;
   }
@@ -453,7 +2888,7 @@ switch (command) {
       console.error("Usage: composto benchmark-quality <file>");
       process.exit(1);
     }
-    await runBenchmarkQuality(resolve("."), resolve(filePath));
+    await runBenchmarkQuality(resolve2("."), resolve2(filePath));
     break;
   }
   case "context": {
@@ -465,18 +2900,40 @@ switch (command) {
       return void 0;
     };
     parseFlag2 = parseFlag;
-    const projectPath = resolve(args[1] && !args[1].startsWith("--") ? args[1] : ".");
+    const projectPath = resolve2(args[1] && !args[1].startsWith("--") ? args[1] : ".");
     const budgetStr = parseFlag("budget");
     const budget = budgetStr ? parseInt(budgetStr, 10) : 4e3;
     const target = parseFlag("target");
     await runContext(projectPath, budget, target);
     break;
   }
+  case "impact": {
+    const filePath = args[1];
+    if (!filePath) {
+      console.error("Usage: composto impact <file> [--intent=bugfix] [--level=detail]");
+      process.exit(1);
+    }
+    const intentArg = args.find((a) => a.startsWith("--intent="));
+    const levelArg = args.find((a) => a.startsWith("--level="));
+    await runImpact(resolve2("."), filePath, {
+      intent: intentArg?.slice("--intent=".length),
+      level: levelArg?.slice("--level=".length)
+    });
+    break;
+  }
+  case "index": {
+    if (args.includes("--status")) {
+      await runIndexStatus(resolve2("."));
+    } else {
+      await runIndex(resolve2("."));
+    }
+    break;
+  }
   case "version":
-    console.log("composto v0.2.3");
+    console.log("composto v0.4.1");
     break;
   default:
-    console.log("composto v0.2.3 \u2014 less tokens, more insight\n");
+    console.log("composto v0.4.1 \u2014 less tokens, more insight\n");
     console.log("Commands:");
     console.log("  scan [path]                           Scan codebase for issues");
     console.log("  trends [path]                         Analyze codebase health trends");
@@ -485,6 +2942,9 @@ switch (command) {
     console.log("  benchmark-quality <file>              Compare AI responses: raw vs IR");
     console.log("  context [path] --budget N             Smart context within token budget");
     console.log("  context [path] --target <symbol>      Target file as raw, surrounding as IR");
+    console.log("  impact <file>                         Show historical blast radius for a file");
+    console.log("  index                                 Build or refresh the memory index");
+    console.log("  index --status                        Show memory index diagnostics");
     console.log("  version                               Show version");
     break;
 }