autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/commands/diagnose.ts

@@ -1,6 +1,6 @@
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { dirname } from "path";
-import { daemonRequest } from "../daemon/client";
+import { daemonRequest, getDaemonInfo } from "../daemon/client";
 import type { Symptom, PatchOp, DiagnosisResult } from "../core/immune";
 import { notifyAutoHeal } from "../core/notify";
 
@@ -18,6 +18,9 @@ interface AutoHealResponse {
 function applyPatch(patch: PatchOp): boolean {
   const filePath = patch.path.replace(/^\//, "");
 
+  // Guard: reject path traversal attempts
+  if (filePath.includes("..") || filePath.startsWith("/") || /^[A-Za-z]:/.test(filePath)) return false;
+
   if (patch.op === "add") {
     if (existsSync(filePath)) return false;
     const dir = dirname(filePath);
@@ -52,10 +55,50 @@ export async function diagnoseCommand(opts: DiagnoseOptions) {
     process.exit(1);
   }
 
+  // Helper: fetch past mistakes for passive defense injection
+  async function fetchPastMistakes(): Promise<string[]> {
+    if (!isA2A) return [];
+    try {
+      const info = getDaemonInfo();
+      if (!info) return [];
+      // Query all recent mistakes (not file-specific in healthy path)
+      const resp = await fetch(`http://127.0.0.1:${info.port}/mistake-history?file=*`, {
+        signal: AbortSignal.timeout(500),
+      });
+      // Fall back to empty if the wildcard isn't supported
+      return [];
+    } catch { return []; }
+  }
+
+  async function fetchMistakesForFiles(files: string[]): Promise<string[]> {
+    if (!isA2A) return [];
+    const warnings: string[] = [];
+    try {
+      const info = getDaemonInfo();
+      if (!info) return [];
+      for (const file of files.slice(0, 3)) {
+        try {
+          const resp = await fetch(`http://127.0.0.1:${info.port}/mistake-history?file=${encodeURIComponent(file)}`, {
+            signal: AbortSignal.timeout(500),
+          });
+          const data = await resp.json() as { mistakes: { mistake_type: string; description: string }[] };
+          for (const m of data.mistakes.slice(0, 3)) {
+            warnings.push(`Previous mistake on ${file}: '${m.description}'. Be careful.`.slice(0, 200));
+          }
+        } catch { /* skip this file */ }
+      }
+    } catch { /* crash-only */ }
+    return warnings;
+  }
+
   // No symptoms — nothing to do
   if (diagnosis.symptoms.length === 0) {
     if (isA2A) {
-      console.log(JSON.stringify({ status: "healthy", symptoms: [], healed: [] }));
+      const output: Record<string, unknown> = { status: "healthy", symptoms: [], healed: [] };
+      // Inject past mistakes even when healthy (proactive warning)
+      const pastMistakes = await fetchPastMistakes();
+      if (pastMistakes.length > 0) output.pastMistakes = pastMistakes;
+      console.log(JSON.stringify(output));
     } else {
       console.log("[afd diagnose] System healthy.");
     }
@@ -116,15 +159,15 @@ export async function diagnoseCommand(opts: DiagnoseOptions) {
     if (applied) {
       // Notify daemon of auto-heal event
       try {
-        await fetch(
-          `http://127.0.0.1:${getDaemonPort()}/auto-heal/record`,
-          {
+        const info = getDaemonInfo();
+        if (info) {
+          await fetch(`http://127.0.0.1:${info.port}/auto-heal/record`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ id: symptom.id }),
             signal: AbortSignal.timeout(1000),
-          }
-        );
+          });
+        }
       } catch {
         // Non-critical — don't block
       }
@@ -137,15 +180,14 @@ export async function diagnoseCommand(opts: DiagnoseOptions) {
   }
 
   if (isA2A) {
-    console.log(JSON.stringify({ status: healed.length > 0 ? "healed" : "no-action", healed, skipped }));
+    const output: Record<string, unknown> = { status: healed.length > 0 ? "healed" : "no-action", healed, skipped };
+    // Inject past mistakes for healed files (passive defense)
+    const affectedFiles = diagnosis.symptoms.map(s => s.fileTarget ?? s.id).filter(Boolean);
+    const pastMistakes = await fetchMistakesForFiles(affectedFiles);
+    if (pastMistakes.length > 0) output.pastMistakes = pastMistakes;
+    console.log(JSON.stringify(output));
   } else {
     if (healed.length > 0) console.log(`[afd diagnose] Auto-healed: ${healed.join(", ")}`);
     if (skipped.length > 0) console.log(`[afd diagnose] Skipped (unknown): ${skipped.join(", ")}`);
   }
 }
-
-function getDaemonPort(): number {
-  const { readFileSync } = require("fs");
-  const { PORT_FILE } = require("../constants");
-  return parseInt(readFileSync(PORT_FILE, "utf-8").trim(), 10);
-}

package/src/commands/doctor.ts

@@ -0,0 +1,243 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { loadAllRules, evaluateRules } from "../core/rule-engine";
+import type { DiagnosticRule } from "../core/rule-engine";
+import type { PatchOp, Symptom } from "../core/immune";
+import { notifyAutoHeal } from "../core/notify";
+import { getSystemLanguage } from "../core/locale";
+
+interface DoctorOptions {
+  fix?: boolean;
+}
+
+// ── i18n ──
+const msgs = {
+  en: {
+    title: "afd doctor — Deep Health Analysis",
+    ruleCount: "Rules loaded",
+    builtIn: "built-in",
+    custom: "custom",
+    scanning: "Scanning project health...",
+    healthy: "All checks passed. Project is healthy!",
+    grade: "Health Grade",
+    passed: "Passed",
+    failed: "Failed",
+    findings: "Findings",
+    recommendation: "Recommendation",
+    fixable: "auto-fixable",
+    fixApplied: "Fixed",
+    fixSkipped: "Skipped (no patches)",
+    fixSummary: "Auto-fix complete",
+    fixHint: "Run `afd doctor --fix` to auto-fix {count} issue(s).",
+    severity: { critical: "CRITICAL", warning: "WARNING", info: "INFO" },
+  },
+  ko: {
+    title: "afd doctor — 딥 헬스 분석",
+    ruleCount: "로드된 규칙",
+    builtIn: "내장",
+    custom: "사용자",
+    scanning: "프로젝트 건강 상태 스캔 중...",
+    healthy: "모든 검사 통과. 프로젝트가 건강합니다!",
+    grade: "건강 등급",
+    passed: "통과",
+    failed: "실패",
+    findings: "발견 사항",
+    recommendation: "권고사항",
+    fixable: "자동 수정 가능",
+    fixApplied: "수정 완료",
+    fixSkipped: "건너뜀 (패치 없음)",
+    fixSummary: "자동 수정 완료",
+    fixHint: "`afd doctor --fix`로 {count}건 자동 수정 가능합니다.",
+    severity: { critical: "심각", warning: "경고", info: "정보" },
+  },
+};
+
+// ── Box Drawing ──
+const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+const W = 52;
+
+function line(left: string, right: string) {
+  return `${left}${BOX.h.repeat(W)}${right}`;
+}
+
+function row(content: string) {
+  const visible = visualWidth(content);
+  const pad = Math.max(0, W - 2 - visible);
+  return `${BOX.v}  ${content}${" ".repeat(pad)}${BOX.v}`;
+}
+
+function divider() {
+  return line(BOX.ml, BOX.mr);
+}
+
+function visualWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0)!;
+    // CJK + emoji ranges → width 2
+    if (
+      (cp >= 0x1100 && cp <= 0x11ff) ||
+      (cp >= 0x2e80 && cp <= 0x9fff) ||
+      (cp >= 0xac00 && cp <= 0xd7af) ||
+      (cp >= 0xf900 && cp <= 0xfaff) ||
+      (cp >= 0xfe30 && cp <= 0xfe4f) ||
+      (cp >= 0x1f000 && cp <= 0x1faff) ||
+      (cp >= 0x20000 && cp <= 0x2fa1f)
+    ) {
+      w += 2;
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
+
+function kv(label: string, value: string) {
+  const gap = 16 - visualWidth(label);
+  return row(`${label}${" ".repeat(Math.max(1, gap))}: ${value}`);
+}
+
+function severityIcon(sev: "critical" | "warning" | "info"): string {
+  return sev === "critical" ? "🔴" : sev === "warning" ? "🟡" : "🔵";
+}
+
+function healthGrade(passed: number, total: number): { grade: string; icon: string } {
+  if (total === 0) return { grade: "A+", icon: "💎" };
+  const pct = (passed / total) * 100;
+  if (pct === 100) return { grade: "A+", icon: "💎" };
+  if (pct >= 80) return { grade: "A", icon: "🟢" };
+  if (pct >= 60) return { grade: "B", icon: "🟡" };
+  if (pct >= 40) return { grade: "C", icon: "🟠" };
+  return { grade: "D", icon: "🔴" };
+}
+
+// ── Recommendations ──
+const recommendations: Record<string, { en: string; ko: string }> = {
+  "file-missing": {
+    en: "Create the missing file to ensure proper AI agent behavior.",
+    ko: "파일을 생성하여 AI 에이전트가 정상 동작하도록 하세요.",
+  },
+  "file-empty": {
+    en: "Add meaningful content to the file.",
+    ko: "파일에 유의미한 내용을 추가하세요.",
+  },
+  "file-invalid-json": {
+    en: "Fix the JSON syntax error. Use a JSON validator.",
+    ko: "JSON 구문 오류를 수정하세요. JSON 검증기를 사용해보세요.",
+  },
+  "file-missing-line": {
+    en: "Add the required pattern to the file.",
+    ko: "필수 패턴을 파일에 추가하세요.",
+  },
+  "file-contains": {
+    en: "Remove the unwanted content from the file.",
+    ko: "파일에서 비허용 콘텐츠를 제거하세요.",
+  },
+};
+
+function getRecommendation(patternType: string, lang: "en" | "ko"): string {
+  return recommendations[patternType]?.[lang] ?? (lang === "ko" ? "수동 확인이 필요합니다." : "Manual review required.");
+}
+
+// ── Patch Applier ──
+function applyPatch(patch: PatchOp): boolean {
+  const filePath = patch.path.replace(/^\//, "");
+  if (patch.op === "add") {
+    if (existsSync(filePath)) return false;
+    const dir = dirname(filePath);
+    if (dir !== ".") mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, patch.value ?? "", "utf-8");
+    return true;
+  }
+  if (patch.op === "replace") {
+    const dir = dirname(filePath);
+    if (dir !== ".") mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, patch.value ?? "", "utf-8");
+    return true;
+  }
+  return false;
+}
+
+// ── Main Command ──
+export async function doctorCommand(opts: DoctorOptions) {
+  const lang = getSystemLanguage();
+  const m = msgs[lang];
+
+  const rules = loadAllRules();
+  const builtInCount = rules.filter(r => r.id.startsWith("IMM-")).length;
+  const customCount = rules.length - builtInCount;
+
+  // Evaluate all rules (raw mode — ignore antibody immunization for full picture)
+  const result = evaluateRules(rules, [], { raw: true });
+  const totalChecks = result.symptoms.length + result.healthy.length;
+  const passedCount = result.healthy.length;
+  const failedCount = result.symptoms.length;
+  const { grade, icon } = healthGrade(passedCount, totalChecks);
+
+  const output: string[] = [];
+  output.push(line(BOX.tl, BOX.tr));
+  output.push(row(`${m.title}`));
+  output.push(divider());
+  output.push(kv(m.ruleCount, `${rules.length} (${builtInCount} ${m.builtIn} + ${customCount} ${m.custom})`));
+  output.push(kv(m.grade, `${icon} ${grade} (${passedCount}/${totalChecks})`));
+  output.push(kv(m.passed, `✅ ${passedCount}`));
+  output.push(kv(m.failed, `❌ ${failedCount}`));
+
+  if (failedCount === 0) {
+    output.push(divider());
+    output.push(row(`✅ ${m.healthy}`));
+    output.push(line(BOX.bl, BOX.br));
+    console.log(output.join("\n"));
+    return;
+  }
+
+  // ── Findings ──
+  output.push(divider());
+  output.push(row(`${m.findings}`));
+  output.push(row("─".repeat(W - 4)));
+
+  let fixableCount = 0;
+
+  for (const symptom of result.symptoms) {
+    const sevLabel = m.severity[symptom.severity];
+    const hasPatches = symptom.patches.length > 0;
+    if (hasPatches) fixableCount++;
+
+    output.push(row(`${severityIcon(symptom.severity)} [${sevLabel}] ${symptom.id}: ${symptom.title}`));
+    output.push(row(`  ${symptom.fileTarget}`));
+    output.push(row(`  ${m.recommendation}: ${getRecommendation(symptom.patternType, lang)}`));
+    if (hasPatches) output.push(row(`  🔧 ${m.fixable}`));
+    output.push(row(""));
+  }
+
+  // ── Fix Mode ──
+  if (opts.fix) {
+    output.push(divider());
+    let fixedCount = 0;
+    for (const symptom of result.symptoms) {
+      if (symptom.patches.length === 0) {
+        output.push(row(`⏭️  ${symptom.id}: ${m.fixSkipped}`));
+        continue;
+      }
+      let applied = false;
+      for (const patch of symptom.patches) {
+        if (applyPatch(patch)) applied = true;
+      }
+      if (applied) {
+        output.push(row(`✅ ${symptom.id}: ${m.fixApplied}`));
+        notifyAutoHeal(symptom.id);
+        fixedCount++;
+      } else {
+        output.push(row(`⏭️  ${symptom.id}: ${m.fixSkipped}`));
+      }
+    }
+    output.push(divider());
+    output.push(row(`🩺 ${m.fixSummary}: ${fixedCount}/${failedCount}`));
+  } else if (fixableCount > 0) {
+    output.push(divider());
+    output.push(row(`💡 ${m.fixHint.replace("{count}", String(fixableCount))}`));
+  }
+
+  output.push(line(BOX.bl, BOX.br));
+  console.log(output.join("\n"));
+}

package/src/commands/evolution.ts

@@ -0,0 +1,107 @@
+/**
+ * afd evolution — Self-Evolution command
+ *
+ * Analyzes quarantined files, generates failure lessons,
+ * and writes them to afd-lessons.md for AI agent learning.
+ */
+
+import { evolve, analyzeQuarantine, listQuarantine } from "../core/evolution";
+import { getSystemLanguage } from "../core/locale";
+
+const msgs = {
+  en: {
+    title: "afd Self-Evolution Report",
+    noQuarantine: "No quarantined files found. Nothing to learn from.",
+    noPending: "All quarantined files already learned. No new lessons.",
+    analyzing: "Analyzing quarantined failures...",
+    written: (n: number) => `${n} new lesson(s) written to afd-lessons.md`,
+    total: (n: number) => `Total lessons learned: ${n}`,
+    stats: "Quarantine Stats",
+    quarantined: "Quarantined",
+    learned: "Learned",
+    pending: "Pending",
+    lessonDetail: "New Lessons",
+  },
+  ko: {
+    title: "afd 자가 진화 리포트",
+    noQuarantine: "격리된 파일이 없습니다. 학습할 대상이 없습니다.",
+    noPending: "모든 격리 파일이 이미 학습되었습니다. 새로운 교훈이 없습니다.",
+    analyzing: "격리된 실패 사례 분석 중...",
+    written: (n: number) => `${n}개의 새로운 교훈이 afd-lessons.md에 기록되었습니다`,
+    total: (n: number) => `총 학습된 교훈: ${n}개`,
+    stats: "격리 통계",
+    quarantined: "격리됨",
+    learned: "학습 완료",
+    pending: "대기 중",
+    lessonDetail: "새로운 교훈",
+  },
+};
+
+const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+const W = 58;
+
+function hline(l: string, r: string) { return `${l}${BOX.h.repeat(W)}${r}`; }
+function row(s: string) {
+  const pad = Math.max(0, W - 2 - visualWidth(s));
+  return `${BOX.v} ${s}${" ".repeat(pad)} ${BOX.v}`;
+}
+function visualWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0)!;
+    if ((cp >= 0x1100 && cp <= 0x11ff) || (cp >= 0x2e80 && cp <= 0x9fff) ||
+        (cp >= 0xac00 && cp <= 0xd7af) || (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0x1f000 && cp <= 0x1faff) || (cp >= 0x20000 && cp <= 0x2fa1f)) w += 2;
+    else w += 1;
+  }
+  return w;
+}
+
+export async function evolutionCommand() {
+  const lang = getSystemLanguage();
+  const m = msgs[lang];
+
+  const entries = listQuarantine();
+  if (entries.length === 0) {
+    console.log(m.noQuarantine);
+    return;
+  }
+
+  const stats = analyzeQuarantine();
+  if (stats.pending === 0) {
+    console.log(m.noPending);
+    return;
+  }
+
+  console.log(m.analyzing);
+  const result = evolve();
+
+  console.log("");
+  console.log(hline(BOX.tl, BOX.tr));
+  console.log(row(`🧬 ${m.title}`));
+  console.log(hline(BOX.ml, BOX.mr));
+  console.log(row(`${m.stats}`));
+  console.log(row(`  ${m.quarantined}  : ${stats.totalQuarantined}`));
+  console.log(row(`  ${m.learned}  : ${result.totalLessons}`));
+  console.log(row(`  ${m.pending}  : 0`));
+  console.log(hline(BOX.ml, BOX.mr));
+  console.log(row(`${m.lessonDetail}`));
+  console.log(row(BOX.h.repeat(W - 4)));
+
+  for (const lesson of stats.lessons) {
+    const icon = lesson.failureType === "deletion" ? "🗑️" : "💥";
+    const file = lesson.entry.originalPath;
+    console.log(row(`${icon} ${file}`));
+    // Truncate suggestion to fit box
+    const maxSug = W - 8;
+    const sug = lesson.suggestion.length > maxSug
+      ? lesson.suggestion.slice(0, maxSug - 3) + "..."
+      : lesson.suggestion;
+    console.log(row(`   ${sug}`));
+  }
+
+  console.log(hline(BOX.ml, BOX.mr));
+  console.log(row(m.written(result.lessonsWritten)));
+  console.log(row(m.total(result.totalLessons)));
+  console.log(hline(BOX.bl, BOX.br));
+}

package/src/commands/fix.ts

@@ -13,6 +13,9 @@ function applyPatch(patch: PatchOp): boolean {
   // Map JSON-Patch path to filesystem path (strip leading /)
   const filePath = patch.path.replace(/^\//, "");
 
+  // Guard: reject path traversal attempts
+  if (filePath.includes("..") || filePath.startsWith("/") || /^[A-Za-z]:/.test(filePath)) return false;
+
   if (patch.op === "add") {
     if (existsSync(filePath)) return false; // don't overwrite
     const dir = dirname(filePath);
@@ -50,8 +53,9 @@ async function learnAntibody(symptom: Symptom): Promise<void> {
 
 async function getDaemonPort(): Promise<number> {
   const { readFileSync } = await import("fs");
-  const { PORT_FILE } = await import("../constants");
-  return parseInt(readFileSync(PORT_FILE, "utf-8").trim(), 10);
+  const { resolveWorkspacePaths } = await import("../constants");
+  const paths = resolveWorkspacePaths();
+  return parseInt(readFileSync(paths.portFile, "utf-8").trim(), 10);
 }
 
 export async function fixCommand() {
@@ -85,6 +89,22 @@ export async function fixCommand() {
     console.log();
   }
 
+  // Extract phase: inject hologram context for AI consumers
+  const symptomsWithHologram = diagnosis.symptoms as (Symptom & { hologram?: string })[];
+  const holograms = symptomsWithHologram.filter(s => s.hologram);
+  if (holograms.length > 0) {
+    console.log("[afd fix] Hologram Context (Extract phase — token-optimized file structures):\n");
+    for (const s of holograms) {
+      console.log(`  --- ${s.fileTarget} ---`);
+      console.log(`  Here is the structural hologram of the file to help you understand`);
+      console.log(`  its interfaces without consuming too many tokens:\n`);
+      for (const line of s.hologram!.split("\n")) {
+        console.log(`    ${line}`);
+      }
+      console.log(`\n  Now, generate the JSON-Patch based on the structure above.\n`);
+    }
+  }
+
   // Back-stage: dump full JSON-Patch for AI consumers
   const allPatches = diagnosis.symptoms.flatMap(s =>
     s.patches.map(p => ({ symptomId: s.id, ...p }))

package/src/commands/hooks.ts

@@ -0,0 +1,136 @@
+import { join } from "path";
+import { resolveWorkspacePaths } from "../constants";
+import {
+  readHooksFile,
+  writeHooksFile,
+  mergeHooks,
+  getHookSummary,
+  getAfdDesiredHooks,
+  type HookOwner,
+  type ManagedHook,
+} from "../core/hook-manager";
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+};
+
+const OWNER_COLOR: Record<HookOwner, string> = {
+  afd: C.cyan,
+  omc: C.yellow,
+  user: C.dim,
+};
+
+function formatHookLine(hook: ManagedHook): string {
+  const color = OWNER_COLOR[hook.owner];
+  const ownerTag = `[${hook.owner}]`.padEnd(6);
+  const id = hook.id.padEnd(24);
+  const matcher = hook.matcher || "*";
+  return `  ${color}${ownerTag}${C.reset} ${C.bold}${id}${C.reset} ${C.dim}${matcher}${C.reset}`;
+}
+
+export function hooksCommand(subcommand?: string): void {
+  const hooksPath = join(resolveWorkspacePaths().root, ".claude", "hooks.json");
+
+  if (!subcommand || subcommand === "status") {
+    const summary = getHookSummary(hooksPath);
+    const total = summary.total;
+    console.log("");
+    console.log(`${C.bold}afd hooks — Hook Manager${C.reset}`);
+    console.log("");
+    console.log(`  PreToolUse (${total} hook${total !== 1 ? "s" : ""})`);
+    console.log("  " + "─".repeat(48));
+
+    const allInOrder: ManagedHook[] = [
+      ...summary.zones.afd,
+      ...summary.zones.omc,
+      ...summary.zones.user,
+    ];
+
+    if (allInOrder.length === 0) {
+      console.log(`  ${C.dim}No hooks registered${C.reset}`);
+    } else {
+      for (const hook of allInOrder) {
+        console.log(formatHookLine(hook));
+      }
+    }
+
+    console.log("");
+
+    const orderStatus = summary.orderingOk
+      ? `${C.green}OK${C.reset} ${C.dim}(afd → omc → user)${C.reset}`
+      : `${C.yellow}DISORDERED${C.reset} — run ${C.bold}afd hooks sync${C.reset} to fix`;
+    console.log(`  Ordering:  ${orderStatus}`);
+
+    if (summary.conflicts.length === 0) {
+      console.log(`  Conflicts: ${C.green}none${C.reset}`);
+    } else {
+      console.log(`  Conflicts: ${C.yellow}${summary.conflicts.length} warning(s)${C.reset}`);
+      for (const c of summary.conflicts) {
+        const prefix = c.type === "duplicate-id" ? "✗" : "⚠";
+        console.log(`    ${C.yellow}${prefix}${C.reset} ${c.type}: ${C.bold}${c.hookA.id}${C.reset} ↔ ${C.bold}${c.hookB.id}${C.reset}`);
+        console.log(`      ${C.dim}${c.resolution}${C.reset}`);
+      }
+    }
+
+    console.log("");
+    return;
+  }
+
+  if (subcommand === "sync") {
+    console.log("");
+    console.log(`${C.bold}afd hooks sync${C.reset}`);
+    console.log("");
+
+    const config = readHooksFile(hooksPath);
+    if (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks)) {
+      config.hooks = {};
+    }
+    if (!config.hooks.PreToolUse) config.hooks.PreToolUse = [];
+
+    const result = mergeHooks(config.hooks.PreToolUse, getAfdDesiredHooks());
+    config.hooks.PreToolUse = result.merged;
+    writeHooksFile(hooksPath, config);
+
+    let anyChange = false;
+    if (result.changes.added.length > 0) {
+      console.log(`  Added:     ${result.changes.added.join(", ")}`);
+      anyChange = true;
+    }
+    if (result.changes.removed.length > 0) {
+      console.log(`  Removed:   ${result.changes.removed.join(", ")}`);
+      anyChange = true;
+    }
+    if (result.changes.reordered.length > 0) {
+      console.log(`  Reordered: ${result.changes.reordered.join(", ")}`);
+      anyChange = true;
+    }
+    if (!anyChange) {
+      console.log(`  ${C.green}Already in sync — no changes needed${C.reset}`);
+    }
+
+    if (result.conflicts.length > 0) {
+      console.log(`  Conflicts: ${C.yellow}${result.conflicts.length} warning(s)${C.reset}`);
+      for (const c of result.conflicts) {
+        const prefix = c.type === "duplicate-id" ? "✗" : "⚠";
+        console.log(`    ${C.yellow}${prefix}${C.reset} ${c.type}: ${C.bold}${c.hookA.id}${C.reset} ↔ ${C.bold}${c.hookB.id}${C.reset}`);
+        console.log(`      ${C.dim}${c.resolution}${C.reset}`);
+      }
+    } else {
+      console.log(`  Conflicts: ${C.green}none${C.reset}`);
+    }
+
+    console.log(`  ${C.dim}hooks.json updated.${C.reset}`);
+    console.log("");
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${subcommand}`);
+  console.error("Usage: afd hooks [status|sync]");
+  process.exit(1);
+}

package/src/commands/lang.ts

@@ -0,0 +1,41 @@
+import { getSystemLanguage, getSupportedLanguages, setLanguageOverride } from "../core/locale";
+import type { SupportedLang } from "../core/locale";
+import { writeConfig, getConfigPath } from "../core/config";
+import { getMessages, t } from "../core/i18n/messages";
+
+export function langCommand(targetLang?: string, options?: { list?: boolean }) {
+  const currentLang = getSystemLanguage();
+  const msg = getMessages(currentLang);
+  const supported = getSupportedLanguages();
+
+  // afd lang --list
+  if (options?.list) {
+    console.log(msg.LANG_LIST_TITLE);
+    for (const lang of supported) {
+      const marker = lang === currentLang ? " ← current" : "";
+      console.log(`  ${lang}${marker}`);
+    }
+    return;
+  }
+
+  // afd lang (no argument) — show current
+  if (!targetLang) {
+    console.log(t(msg.LANG_CURRENT, { lang: currentLang }));
+    return;
+  }
+
+  // afd lang <en|ko> — change language
+  if (!supported.includes(targetLang as SupportedLang)) {
+    console.error(t(msg.LANG_INVALID, { lang: targetLang, supported: supported.join(", ") }));
+    process.exit(1);
+  }
+
+  const newLang = targetLang as SupportedLang;
+  writeConfig({ lang: newLang });
+  setLanguageOverride(newLang);
+
+  // Print feedback in the NEW language
+  const newMsg = getMessages(newLang);
+  console.log(t(newMsg.LANG_CHANGED, { lang: newLang }));
+  console.log(t(newMsg.LANG_SAVED, { path: getConfigPath() }));
+}