autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/adapters/index.ts

@@ -1,5 +1,13 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
+import { resolveHookCommand } from "../platform";
+import {
+  readHooksFile,
+  writeHooksFile,
+  mergeHooks,
+  getAfdDesiredHooks,
+  KNOWN_AFD_HOOKS,
+} from "../core/hook-manager";
 
 export interface HarnessSchema {
   configFiles: string[];
@@ -14,6 +22,9 @@ export interface EcosystemAdapter {
   getHarnessSchema(): HarnessSchema;
   injectHooks?(cwd: string): { injected: boolean; message: string };
   configureStatusLine?(cwd: string): { configured: boolean; message: string };
+  registerMcp?(cwd: string): { registered: boolean; message: string };
+  removeHooks?(cwd: string): { removed: boolean; message: string };
+  unregisterMcp?(cwd: string): { removed: boolean; message: string };
 }
 
 const AFD_HOOK_MARKER = "afd-auto-heal";
@@ -48,45 +59,27 @@ export const ClaudeCodeAdapter: EcosystemAdapter = {
   },
   injectHooks(cwd: string): { injected: boolean; message: string } {
     const hooksPath = join(cwd, ".claude", "hooks.json");
-    const hookCommand = "bun run " + join(cwd, "src", "cli.ts").replace(/\\/g, "/") + " diagnose --format a2a --auto-heal";
-
-    const newHook: HookEntry = {
-      id: AFD_HOOK_MARKER,
-      matcher: "",
-      command: hookCommand,
-    };
-
-    let config: HooksConfig;
-    if (existsSync(hooksPath)) {
-      try {
-        config = JSON.parse(readFileSync(hooksPath, "utf-8"));
-      } catch {
-        config = { hooks: {} };
-      }
-    } else {
-      mkdirSync(dirname(hooksPath), { recursive: true });
-      config = { hooks: {} };
-    }
+    const config = readHooksFile(hooksPath);
 
     if (!config.hooks || Array.isArray(config.hooks) || typeof config.hooks !== "object") {
       config.hooks = {};
     }
     if (!config.hooks.PreToolUse) config.hooks.PreToolUse = [];
 
-    // Check if already injected
-    const existing = config.hooks.PreToolUse.find(
-      (h: HookEntry) => h.id === AFD_HOOK_MARKER
-    );
-    if (existing) {
-      // Update command in case path changed
-      existing.command = hookCommand;
-      writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
-      return { injected: false, message: "Auto-heal hook already present (updated)" };
-    }
+    const before = config.hooks.PreToolUse.length;
+    const result = mergeHooks(config.hooks.PreToolUse, getAfdDesiredHooks());
+    config.hooks.PreToolUse = result.merged;
+    writeHooksFile(hooksPath, config);
 
-    config.hooks.PreToolUse.push(newHook);
-    writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
-    return { injected: true, message: "Auto-heal hook injected into PreToolUse" };
+    const added = result.changes.added.length > 0;
+    const after = config.hooks.PreToolUse.length;
+    if (added) {
+      return { injected: true, message: "Auto-heal hook injected into PreToolUse" };
+    }
+    return {
+      injected: false,
+      message: `Auto-heal hook already present (${after} hook${after !== 1 ? "s" : ""} total, ordering: afd → omc → user)`,
+    };
   },
   configureStatusLine(cwd: string): { configured: boolean; message: string } {
     const settingsPath = join(cwd, ".claude", "settings.local.json");
@@ -120,24 +113,243 @@ export const ClaudeCodeAdapter: EcosystemAdapter = {
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
     return { configured: true, message: "Status line configured with afd integration" };
   },
+  registerMcp(cwd: string): { registered: boolean; message: string } {
+    const mcpPath = join(cwd, ".mcp.json");
+    const serverScript = "src/daemon/server.ts";
+    const expectedArgs = ["run", serverScript, "--mcp"];
+
+    let config: Record<string, unknown>;
+    if (existsSync(mcpPath)) {
+      try {
+        config = JSON.parse(readFileSync(mcpPath, "utf-8"));
+      } catch {
+        config = {};
+      }
+    } else {
+      config = {};
+    }
+
+    const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
+    const existing = mcpServers.afd as { command?: string; args?: string[] } | undefined;
+
+    if (existing?.command === "bun" &&
+        JSON.stringify(existing.args) === JSON.stringify(expectedArgs)) {
+      return { registered: false, message: "MCP server already registered in .mcp.json" };
+    }
+
+    mcpServers.afd = {
+      command: "bun",
+      args: expectedArgs,
+    };
+    config.mcpServers = mcpServers;
+    writeFileSync(mcpPath, JSON.stringify(config, null, 2), "utf-8");
+    return { registered: true, message: "MCP server 'afd' registered in .mcp.json" };
+  },
+  removeHooks(cwd: string): { removed: boolean; message: string } {
+    const hooksPath = join(cwd, ".claude", "hooks.json");
+    if (!existsSync(hooksPath)) {
+      return { removed: false, message: "No hooks file found" };
+    }
+    try {
+      const config: HooksConfig = JSON.parse(readFileSync(hooksPath, "utf-8"));
+      const arr = config.hooks?.PreToolUse;
+      if (!arr) return { removed: false, message: "No PreToolUse hooks" };
+
+      // Only remove hooks that are in the canonical KNOWN_AFD_HOOKS set.
+      // User hooks with an `afd-` prefix (e.g., afd-read-gate) are preserved.
+      const before = arr.length;
+      config.hooks!.PreToolUse = arr.filter(
+        (h: HookEntry) => !KNOWN_AFD_HOOKS.has(h.id ?? "")
+      );
+      const removed = before - config.hooks!.PreToolUse.length;
+      if (removed === 0) return { removed: false, message: "No afd-managed hooks found" };
+
+      writeHooksFile(hooksPath, config);
+      return { removed: true, message: `Removed ${removed} afd-managed hook${removed !== 1 ? "s" : ""} from PreToolUse` };
+    } catch {
+      return { removed: false, message: "Failed to parse hooks file" };
+    }
+  },
+  unregisterMcp(cwd: string): { removed: boolean; message: string } {
+    const mcpPath = join(cwd, ".mcp.json");
+    if (!existsSync(mcpPath)) {
+      return { removed: false, message: "No .mcp.json found" };
+    }
+    try {
+      const config = JSON.parse(readFileSync(mcpPath, "utf-8"));
+      const servers = config.mcpServers as Record<string, unknown> | undefined;
+      if (!servers?.afd) return { removed: false, message: "afd not in .mcp.json" };
+      delete servers.afd;
+      if (Object.keys(servers).length === 0) delete config.mcpServers;
+      writeFileSync(mcpPath, JSON.stringify(config, null, 2), "utf-8");
+      return { removed: true, message: "MCP server 'afd' removed from .mcp.json" };
+    } catch {
+      return { removed: false, message: "Failed to parse .mcp.json" };
+    }
+  },
 };
 
 export const CursorAdapter: EcosystemAdapter = {
   name: "Cursor",
   detect(cwd: string): boolean {
-    return existsSync(join(cwd, ".cursorrules"));
+    return existsSync(join(cwd, ".cursorrules")) || existsSync(join(cwd, ".cursor"));
   },
   getHarnessSchema(): HarnessSchema {
     return {
       configFiles: [".cursorrules", ".cursor/settings.json"],
       ignoreFile: ".cursorignore",
       rulesFile: ".cursorrules",
-      hooksFile: null,
+      hooksFile: ".cursor/hooks.json",
+    };
+  },
+  injectHooks(cwd: string): { injected: boolean; message: string } {
+    // Cursor supports hooks via .cursor/hooks.json (same format as Claude Code)
+    const hooksPath = join(cwd, ".cursor", "hooks.json");
+    const hookCommand = resolveHookCommand();
+
+    const newHook: HookEntry = {
+      id: AFD_HOOK_MARKER,
+      matcher: "",
+      command: hookCommand,
+    };
+
+    let config: HooksConfig;
+    if (existsSync(hooksPath)) {
+      try {
+        config = JSON.parse(readFileSync(hooksPath, "utf-8"));
+      } catch {
+        config = { hooks: {} };
+      }
+    } else {
+      mkdirSync(join(cwd, ".cursor"), { recursive: true });
+      config = { hooks: {} };
+    }
+
+    if (!config.hooks || Array.isArray(config.hooks) || typeof config.hooks !== "object") {
+      config.hooks = {};
+    }
+    if (!config.hooks.PreToolUse) config.hooks.PreToolUse = [];
+
+    const existing = config.hooks.PreToolUse.find((h: HookEntry) => h.id === AFD_HOOK_MARKER);
+    if (existing) {
+      existing.command = hookCommand;
+      writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+      return { injected: false, message: "Cursor: auto-heal hook already present (updated)" };
+    }
+
+    config.hooks.PreToolUse.push(newHook);
+    writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+    return { injected: true, message: "Cursor: auto-heal hook injected" };
+  },
+};
+
+export const WindsurfAdapter: EcosystemAdapter = {
+  name: "Windsurf",
+  detect(cwd: string): boolean {
+    return existsSync(join(cwd, ".windsurfrules")) || existsSync(join(cwd, ".windsurf"));
+  },
+  getHarnessSchema(): HarnessSchema {
+    return {
+      configFiles: [".windsurfrules", ".windsurf/settings.json"],
+      ignoreFile: ".windsurfignore",
+      rulesFile: ".windsurfrules",
+      hooksFile: ".windsurf/hooks.json",
+    };
+  },
+  injectHooks(cwd: string): { injected: boolean; message: string } {
+    const hooksPath = join(cwd, ".windsurf", "hooks.json");
+    const hookCommand = resolveHookCommand();
+
+    const newHook: HookEntry = {
+      id: AFD_HOOK_MARKER,
+      matcher: "",
+      command: hookCommand,
+    };
+
+    let config: HooksConfig;
+    if (existsSync(hooksPath)) {
+      try {
+        config = JSON.parse(readFileSync(hooksPath, "utf-8"));
+      } catch {
+        config = { hooks: {} };
+      }
+    } else {
+      mkdirSync(join(cwd, ".windsurf"), { recursive: true });
+      config = { hooks: {} };
+    }
+
+    if (!config.hooks || Array.isArray(config.hooks) || typeof config.hooks !== "object") {
+      config.hooks = {};
+    }
+    if (!config.hooks.PreToolUse) config.hooks.PreToolUse = [];
+
+    const existing = config.hooks.PreToolUse.find((h: HookEntry) => h.id === AFD_HOOK_MARKER);
+    if (existing) {
+      existing.command = hookCommand;
+      writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+      return { injected: false, message: "Windsurf: auto-heal hook already present (updated)" };
+    }
+
+    config.hooks.PreToolUse.push(newHook);
+    writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+    return { injected: true, message: "Windsurf: auto-heal hook injected" };
+  },
+};
+
+export const CodexAdapter: EcosystemAdapter = {
+  name: "Codex",
+  detect(cwd: string): boolean {
+    return existsSync(join(cwd, "codex.md")) || existsSync(join(cwd, ".codex"));
+  },
+  getHarnessSchema(): HarnessSchema {
+    return {
+      configFiles: ["codex.md", ".codex/settings.json"],
+      ignoreFile: ".codexignore",
+      rulesFile: "codex.md",
+      hooksFile: ".codex/hooks.json",
+    };
+  },
+  injectHooks(cwd: string): { injected: boolean; message: string } {
+    const hooksPath = join(cwd, ".codex", "hooks.json");
+    const hookCommand = resolveHookCommand();
+
+    const newHook: HookEntry = {
+      id: AFD_HOOK_MARKER,
+      matcher: "",
+      command: hookCommand,
     };
+
+    let config: HooksConfig;
+    if (existsSync(hooksPath)) {
+      try {
+        config = JSON.parse(readFileSync(hooksPath, "utf-8"));
+      } catch {
+        config = { hooks: {} };
+      }
+    } else {
+      mkdirSync(join(cwd, ".codex"), { recursive: true });
+      config = { hooks: {} };
+    }
+
+    if (!config.hooks || Array.isArray(config.hooks) || typeof config.hooks !== "object") {
+      config.hooks = {};
+    }
+    if (!config.hooks.PreToolUse) config.hooks.PreToolUse = [];
+
+    const existing = config.hooks.PreToolUse.find((h: HookEntry) => h.id === AFD_HOOK_MARKER);
+    if (existing) {
+      existing.command = hookCommand;
+      writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+      return { injected: false, message: "Codex: auto-heal hook already present (updated)" };
+    }
+
+    config.hooks.PreToolUse.push(newHook);
+    writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+    return { injected: true, message: "Codex: auto-heal hook injected" };
   },
 };
 
-const adapters: EcosystemAdapter[] = [ClaudeCodeAdapter, CursorAdapter];
+const adapters: EcosystemAdapter[] = [ClaudeCodeAdapter, CursorAdapter, WindsurfAdapter, CodexAdapter];
 
 export interface DetectionResult {
   adapter: EcosystemAdapter;

package/src/cli.ts

@@ -2,28 +2,57 @@
 import { Command } from "commander";
 import { startCommand } from "./commands/start";
 import { stopCommand } from "./commands/stop";
+import { restartCommand } from "./commands/restart";
+import { statusCommand } from "./commands/status";
 import { scoreCommand } from "./commands/score";
 import { fixCommand } from "./commands/fix";
 import { syncCommand } from "./commands/sync";
 import { diagnoseCommand } from "./commands/diagnose";
+import { doctorCommand } from "./commands/doctor";
+
+import { vaccineCommand } from "./commands/vaccine";
+import { langCommand } from "./commands/lang";
+import { evolutionCommand } from "./commands/evolution";
+import { mcpCommand } from "./commands/mcp";
+import { statsCommand } from "./commands/stats";
+import { hooksCommand } from "./commands/hooks";
+import { benchmarkCommand } from "./commands/benchmark";
+import { APP_VERSION } from "./version";
+import { trackCliCommand } from "./core/telemetry";
 
 const program = new Command();
 
 program
   .name("afd")
   .description("Autonomous Flow Daemon - The Immune System for AI Workflows")
-  .version("1.0.0");
+  .version(APP_VERSION);
+
+program.hook("preAction", (thisCommand) => {
+  trackCliCommand(thisCommand.name());
+});
 
 program
   .command("start")
   .description("Start the afd daemon (background file watcher)")
+  .option("--mcp", "Run in MCP stdio mode (for Claude Code tool integration)")
   .action(startCommand);
 
 program
   .command("stop")
   .description("Stop the afd daemon")
+  .option("--clean", "Remove all injected hooks and MCP registrations")
   .action(stopCommand);
 
+program
+  .command("restart")
+  .description("Restart the afd daemon (stop + start)")
+  .action(restartCommand);
+
+program
+  .command("status")
+  .description("Quick health check — daemon, hooks, defenses, quarantine")
+  .action(statusCommand);
+
 program
   .command("score")
   .description("Show current diagnostic stats from the daemon")
@@ -37,8 +66,17 @@ program
 program
   .command("sync")
   .description("Synchronize AI agent configs across team")
+  .option("--push", "Push local antibodies to team vaccine store")
+  .option("--pull", "Pull antibodies from team vaccine store")
+  .option("--remote <url>", "Remote vaccine store URL (future)")
   .action(syncCommand);
 
+program
+  .command("doctor")
+  .description("Deep health analysis with recommendations and auto-fix")
+  .option("--fix", "Auto-fix detected issues")
+  .action(doctorCommand);
+
 program
   .command("diagnose")
   .description("Run headless diagnosis (used by auto-heal hooks)")
@@ -46,4 +84,44 @@ program
   .option("--auto-heal", "Auto-apply patches for known antibodies")
   .action(diagnoseCommand);
 
+program
+  .command("vaccine [subcommand] [arg]")
+  .description("Vaccine registry: list, search, install, publish")
+  .action(vaccineCommand);
+
+program
+  .command("evolution")
+  .description("Self-Evolution: analyze quarantined failures and generate lessons for AI agents")
+  .action(evolutionCommand);
+
+program
+  .command("mcp [subcommand]")
+  .description("MCP server management (install)")
+  .action(mcpCommand);
+
+program
+  .command("lang [language]")
+  .description("Show or change display language (en, ko)")
+  .option("--list", "Show all supported languages")
+  .action(langCommand);
+
+program
+  .command("stats")
+  .description("Feature usage telemetry dashboard (developer-only)")
+  .option("--days <n>", "Number of days to aggregate", "7")
+  .action(statsCommand);
+
+program
+  .command("hooks [subcommand]")
+  .description("Hook Manager: inspect and sync hook ordering (afd → omc → user)")
+  .action(hooksCommand);
+
+program
+  .command("benchmark")
+  .description("Hologram AST compression benchmark across all source files")
+  .option("--sort <key>", "Sort by: savings (default), size, name")
+  .option("--top <n>", "Show only top N files")
+  .option("--json", "Output raw JSON for programmatic use")
+  .action(benchmarkCommand);
+
 program.parse();

package/src/commands/benchmark.ts

@@ -0,0 +1,187 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { generateHologram } from "../core/hologram";
+import { getSystemLanguage } from "../core/locale";
+
+// ── ANSI helpers ──
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+};
+
+interface FileResult {
+  path: string;
+  originalLines: number;
+  hologramLines: number;
+  originalChars: number;
+  hologramChars: number;
+  savings: number;
+}
+
+function collectTsFiles(dir: string, base: string): string[] {
+  const results: string[] = [];
+  const skipDirs = new Set(["node_modules", ".git", ".afd", "dist", "coverage", ".omc"]);
+
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!skipDirs.has(entry.name)) {
+        results.push(...collectTsFiles(join(dir, entry.name), base));
+      }
+    } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      results.push(join(dir, entry.name));
+    }
+  }
+  return results;
+}
+
+function formatChars(n: number): string {
+  if (n < 1000) return `${n}`;
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}K`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+function savingsColor(pct: number): string {
+  if (pct >= 80) return C.green;
+  if (pct >= 50) return C.yellow;
+  return C.red;
+}
+
+function padRight(s: string, w: number): string {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, "");
+  return s + " ".repeat(Math.max(0, w - stripped.length));
+}
+
+function padLeft(s: string, w: number): string {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, "");
+  return " ".repeat(Math.max(0, w - stripped.length)) + s;
+}
+
+export async function benchmarkCommand(options: { sort?: string; top?: string; json?: boolean }) {
+  const lang = getSystemLanguage();
+  const ko = lang === "ko";
+  const cwd = process.cwd();
+  const files = collectTsFiles(join(cwd, "src"), cwd);
+
+  if (files.length === 0) {
+    console.error(`${C.red}[afd] ${ko ? "src/ 디렉토리에 TS/JS 파일이 없습니다." : "No TS/JS files found in src/."}${C.reset}`);
+    process.exit(1);
+  }
+
+  const results: FileResult[] = [];
+  const startTime = performance.now();
+
+  for (const filePath of files) {
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      const { hologram, originalLength, hologramLength, savings } = await generateHologram(filePath, source);
+      results.push({
+        path: relative(cwd, filePath),
+        originalLines: source.split("\n").length,
+        hologramLines: hologram.split("\n").length,
+        originalChars: originalLength,
+        hologramChars: hologramLength,
+        savings: Math.round(savings * 10) / 10,
+      });
+    } catch {
+      // Skip files that fail to parse
+    }
+  }
+
+  const elapsed = Math.round(performance.now() - startTime);
+
+  // Sort
+  const sortKey = options.sort ?? "savings";
+  results.sort((a, b) => {
+    if (sortKey === "size") return b.originalChars - a.originalChars;
+    if (sortKey === "name") return a.path.localeCompare(b.path);
+    return b.savings - a.savings; // default: savings desc
+  });
+
+  const limit = options.top ? parseInt(options.top, 10) : results.length;
+  const display = results.slice(0, limit);
+
+  // JSON output
+  if (options.json) {
+    const totalOriginal = results.reduce((s, r) => s + r.originalChars, 0);
+    const totalHologram = results.reduce((s, r) => s + r.hologramChars, 0);
+    console.log(JSON.stringify({
+      files: results.length,
+      totalOriginalChars: totalOriginal,
+      totalHologramChars: totalHologram,
+      totalSavedChars: totalOriginal - totalHologram,
+      overallCompression: totalOriginal > 0 ? Math.round((1 - totalHologram / totalOriginal) * 1000) / 10 : 0,
+      estimatedTokensSaved: Math.round((totalOriginal - totalHologram) / 4),
+      elapsedMs: elapsed,
+      results: results.map(r => ({
+        path: r.path,
+        originalLines: r.originalLines,
+        hologramLines: r.hologramLines,
+        originalChars: r.originalChars,
+        hologramChars: r.hologramChars,
+        savings: r.savings,
+      })),
+    }, null, 2));
+    return;
+  }
+
+  // ── Header ──
+  console.log();
+  console.log(`${C.bold}${C.cyan}  ╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bold}${C.cyan}  ║       ${ko ? "홀로그램 AST 압축 벤치마크" : "Hologram AST Compression Benchmark"}                       ║${C.reset}`);
+  console.log(`${C.bold}${C.cyan}  ╚══════════════════════════════════════════════════════════════╝${C.reset}`);
+  console.log();
+
+  // ── Table Header ──
+  const colFile = ko ? "파일" : "File";
+  const colLines = ko ? "원본줄" : "Lines";
+  const colHolo = ko ? "홀로줄" : "Holo";
+  const colOrig = ko ? "원본" : "Original";
+  const colComp = ko ? "압축" : "Compressed";
+  const colSave = ko ? "절감률" : "Savings";
+
+  console.log(
+    `  ${C.dim}${padRight(colFile, 40)} ${padLeft(colLines, 6)} ${padLeft(colHolo, 6)} ${padLeft(colOrig, 8)} ${padLeft(colComp, 8)} ${padLeft(colSave, 8)}${C.reset}`
+  );
+  console.log(`  ${C.dim}${"─".repeat(80)}${C.reset}`);
+
+  // ── Rows ──
+  for (const r of display) {
+    const sc = savingsColor(r.savings);
+    const savingsStr = `${sc}${r.savings.toFixed(1)}%${C.reset}`;
+    console.log(
+      `  ${padRight(r.path, 40)} ${padLeft(String(r.originalLines), 6)} ${padLeft(String(r.hologramLines), 6)} ${padLeft(formatChars(r.originalChars), 8)} ${padLeft(formatChars(r.hologramChars), 8)} ${padLeft(savingsStr, 8)}`
+    );
+  }
+
+  if (limit < results.length) {
+    console.log(`  ${C.dim}... ${ko ? `외 ${results.length - limit}개 파일` : `and ${results.length - limit} more files`}${C.reset}`);
+  }
+
+  // ── Summary ──
+  const totalOriginal = results.reduce((s, r) => s + r.originalChars, 0);
+  const totalHologram = results.reduce((s, r) => s + r.hologramChars, 0);
+  const totalSaved = totalOriginal - totalHologram;
+  const overallPct = totalOriginal > 0 ? Math.round((1 - totalHologram / totalOriginal) * 1000) / 10 : 0;
+  const estimatedTokens = Math.round(totalSaved / 4);
+  const high = results.filter(r => r.savings >= 70).length;
+
+  console.log();
+  console.log(`  ${C.dim}${"─".repeat(80)}${C.reset}`);
+  console.log(`  ${C.bold}${ko ? "요약" : "Summary"}${C.reset}`);
+  console.log();
+  console.log(`  ${ko ? "분석 파일" : "Files analyzed"}     ${C.bold}${results.length}${C.reset}`);
+  console.log(`  ${ko ? "전체 압축률" : "Overall compression"} ${C.bold}${savingsColor(overallPct)}${overallPct}%${C.reset}`);
+  console.log(`  ${ko ? "원본 크기" : "Original size"}      ${C.bold}${formatChars(totalOriginal)}${C.reset} ${C.dim}(${(totalOriginal / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "압축 크기" : "Compressed size"}    ${C.bold}${formatChars(totalHologram)}${C.reset} ${C.dim}(${(totalHologram / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "절약 크기" : "Saved"}              ${C.bold}${C.green}${formatChars(totalSaved)}${C.reset} ${C.dim}(${(totalSaved / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "추정 토큰 절약" : "Est. tokens saved"}  ${C.bold}${C.green}~${estimatedTokens.toLocaleString()}${C.reset}`);
+  console.log(`  ${ko ? "70%+ 압축 파일" : "70%+ compression"}   ${C.bold}${high}${C.reset}/${results.length} ${C.dim}(${Math.round(high / results.length * 100)}%)${C.reset}`);
+  console.log(`  ${ko ? "처리 시간" : "Elapsed"}            ${C.dim}${elapsed}ms${C.reset}`);
+  console.log();
+}