autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/commands/stats.ts

@@ -0,0 +1,103 @@
+/**
+ * `afd stats` — Feature usage telemetry dashboard (developer-only).
+ */
+
+import { queryTelemetry, type TelemetrySummary } from "../core/telemetry";
+
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m",
+  blue: "\x1b[34m", magenta: "\x1b[35m", cyan: "\x1b[36m", white: "\x1b[37m",
+};
+
+function bar(count: number, max: number, width = 20): string {
+  const ratio = max > 0 ? Math.min(count / max, 1) : 0;
+  const filled = Math.round(ratio * width);
+  return `${C.green}${"█".repeat(filled)}${C.dim}${"░".repeat(width - filled)}${C.reset}`;
+}
+
+function sortedEntries(obj: Record<string, number>): [string, number][] {
+  return Object.entries(obj).sort((a, b) => b[1] - a[1]);
+}
+
+function renderRankedList(data: Record<string, number>, barWidth = 16): string[] {
+  const entries = sortedEntries(data);
+  if (entries.length === 0) return [`  ${C.dim}(no data)${C.reset}`];
+  const maxVal = entries[0][1];
+  const maxNameLen = Math.max(...entries.map(([n]) => n.length), 8);
+  return entries.map(([name, count]) => {
+    const pad = " ".repeat(Math.max(1, maxNameLen - name.length + 2));
+    return `  ${C.white}${name}${C.reset}${pad}${bar(count, maxVal, barWidth)} ${count}`;
+  });
+}
+
+function renderSection(title: string): string {
+  return `\n${C.bold}${C.cyan}${title}${C.reset}\n${"─".repeat(50)}`;
+}
+
+export async function statsCommand(opts: { days?: string }) {
+  const days = parseInt(opts.days ?? "7", 10) || 7;
+  const data: TelemetrySummary = queryTelemetry(days);
+
+  const out: string[] = [];
+
+  out.push(`${C.bold}📊 Feature Usage Telemetry${C.reset}  ${C.dim}(last ${days} days, ${data.totalEvents} events total)${C.reset}`);
+
+  // CLI Commands
+  out.push(renderSection("CLI Commands"));
+  out.push(...renderRankedList(data.cli));
+
+  // MCP Tools
+  out.push(renderSection("MCP Tools"));
+  out.push(...renderRankedList(data.mcp));
+
+  // S.E.A.M Cycle
+  out.push(renderSection("S.E.A.M Cycle"));
+  const seamEntries = sortedEntries(data.seam.counts);
+  if (seamEntries.length === 0) {
+    out.push(`  ${C.dim}(no data)${C.reset}`);
+  } else {
+    const maxSeam = seamEntries[0][1];
+    const maxNameLen = Math.max(...seamEntries.map(([n]) => n.length), 8);
+    for (const [action, count] of seamEntries) {
+      const pad = " ".repeat(Math.max(1, maxNameLen - action.length + 2));
+      const avg = data.seam.avgDurationMs[action];
+      const avgStr = avg != null ? `${C.dim}avg ${avg}ms${C.reset}` : "";
+      out.push(`  ${C.white}${action}${C.reset}${pad}${bar(count, maxSeam, 12)} ${count}  ${avgStr}`);
+    }
+  }
+
+  // Immune Activity + Accuracy
+  out.push(renderSection("Immune Activity"));
+  const hits = data.immune["heal_hit"] ?? 0;
+  const falsePos = data.immune["heal_false_positive"] ?? 0;
+  const passes = data.immune["heal_pass"] ?? 0;
+  const suppressions = data.immune["suppression"] ?? 0;
+  const totalJudgments = hits + falsePos + passes;
+  const accuracy = totalJudgments > 0 ? Math.round((hits + passes) / totalJudgments * 100) : null;
+  const precisionLabel = (hits + falsePos) > 0 ? `${Math.round(hits / (hits + falsePos) * 100)}%` : "—";
+
+  out.push(`  ${C.white}Hits${C.reset}       ${hits}  ${C.dim}(corruption detected & restored)${C.reset}`);
+  out.push(`  ${C.white}Passes${C.reset}     ${passes}  ${C.dim}(immune file changed, valid)${C.reset}`);
+  out.push(`  ${C.white}False +${C.reset}    ${falsePos}  ${C.dim}(restored but user overrode)${C.reset}`);
+  out.push(`  ${C.white}Suppress${C.reset}   ${suppressions}  ${C.dim}(mass event skip)${C.reset}`);
+  out.push("");
+  out.push(`  ${C.bold}Accuracy${C.reset}   ${accuracy != null ? `${C.green}${accuracy}%${C.reset}` : `${C.dim}—${C.reset}`}  ${C.dim}(correct judgments / total)${C.reset}`);
+  out.push(`  ${C.bold}Precision${C.reset}  ${(hits + falsePos) > 0 ? `${C.green}${precisionLabel}${C.reset}` : `${C.dim}—${C.reset}`}  ${C.dim}(true hits / all blocks)${C.reset}`);
+
+  // Validators
+  if (Object.keys(data.validator).length > 0) {
+    out.push(renderSection("Validator Triggers"));
+    out.push(...renderRankedList(data.validator));
+  }
+
+  // Dead features warning
+  const allCli = ["start", "stop", "restart", "status", "score", "fix", "sync", "doctor", "diagnose", "vaccine", "evolution", "mcp", "lang", "stats"];
+  const unusedCli = allCli.filter(cmd => !(cmd in data.cli));
+  if (unusedCli.length > 0 && Object.keys(data.cli).length > 0) {
+    out.push(renderSection("Unused CLI Commands"));
+    out.push(`  ${C.yellow}${unusedCli.join(", ")}${C.reset}`);
+  }
+
+  console.log(out.join("\n"));
+}

package/src/commands/status.ts

@@ -0,0 +1,157 @@
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { getDaemonInfo, isDaemonAlive, daemonRequest } from "../daemon/client";
+import { resolveWorkspacePaths } from "../constants";
+import { getSystemLanguage } from "../core/locale";
+
+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",
+};
+
+const ko = getSystemLanguage() === "ko";
+
+interface HealthData {
+  status: string;
+  pid: number;
+  workspace: string;
+  port: number;
+}
+
+interface ScoreData {
+  uptime: number;
+  immune: { antibodies: number; autoHealed: number };
+  ecosystem: { primary: string };
+  dynamicImmune?: { activeValidators: number };
+}
+
+function checkHooksInjected(): boolean {
+  const hooksPath = join(resolveWorkspacePaths().root, ".claude/hooks.json");
+  if (!existsSync(hooksPath)) return false;
+  try {
+    const content = readFileSync(hooksPath, "utf-8");
+    return content.includes("afd-auto-heal");
+  } catch {
+    return false;
+  }
+}
+
+function checkMcpRegistered(): boolean {
+  const mcpPath = join(resolveWorkspacePaths().root, ".mcp.json");
+  if (!existsSync(mcpPath)) return false;
+  try {
+    const content = readFileSync(mcpPath, "utf-8");
+    return content.includes('"afd"');
+  } catch {
+    return false;
+  }
+}
+
+function getQuarantinedFiles(): string[] {
+  const paths = resolveWorkspacePaths();
+  if (!existsSync(paths.quarantineDir)) return [];
+  try {
+    return readdirSync(paths.quarantineDir).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+
+function formatUptime(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  return `${h}h ${m}m`;
+}
+
+function indicator(ok: boolean): string {
+  return ok ? `${C.green}●${C.reset}` : `${C.red}●${C.reset}`;
+}
+
+export async function statusCommand() {
+  const out: string[] = [];
+
+  out.push("");
+  out.push(`${C.bold}afd status${C.reset}`);
+  out.push("");
+
+  // ── 1. Daemon ──
+  const info = getDaemonInfo();
+  if (!info || !(await isDaemonAlive(info))) {
+    out.push(`  ${C.red}●${C.reset} ${C.bold}Daemon${C.reset}       ${C.red}STOPPED${C.reset}`);
+    out.push("");
+    out.push(`  ${C.dim}${ko ? "→ afd start 를 실행하세요" : "→ Run afd start to activate"}${C.reset}`);
+    out.push("");
+    console.log(out.join("\n"));
+    return;
+  }
+
+  // Fetch live data
+  let score: ScoreData | null = null;
+  try {
+    score = await daemonRequest<ScoreData>("/score");
+  } catch { /* use fallback */ }
+
+  const uptime = score ? formatUptime(score.uptime) : "?";
+  const ecosystem = score?.ecosystem.primary ?? "Unknown";
+
+  out.push(`  ${C.green}●${C.reset} ${C.bold}Daemon${C.reset}       ${C.green}ACTIVE${C.reset} ${C.dim}(pid=${info.pid} port=${info.port})${C.reset}`);
+  out.push(`  ${C.dim}  Uptime${C.reset}      ${uptime}  ${C.dim}|${C.reset}  ${ecosystem}`);
+  out.push("");
+
+  // ── 2. Connections ──
+  out.push(`  ${C.bold}${ko ? "연결 상태" : "Connections"}${C.reset}`);
+
+  const hooksOk = checkHooksInjected();
+  out.push(`  ${indicator(hooksOk)} Hook        ${hooksOk ? `${C.green}INJECTED${C.reset}` : `${C.red}MISSING${C.reset} ${C.dim}(afd start로 주입)${C.reset}`}`);
+
+  const mcpOk = checkMcpRegistered();
+  out.push(`  ${indicator(mcpOk)} MCP         ${mcpOk ? `${C.green}REGISTERED${C.reset}` : `${C.yellow}NOT SET${C.reset}`}`);
+
+  out.push("");
+
+  // ── 3. Defenses ──
+  out.push(`  ${C.bold}${ko ? "방어막" : "Defenses"}${C.reset}`);
+
+  const antibodies = score?.immune.antibodies ?? 0;
+  const healed = score?.immune.autoHealed ?? 0;
+  const validators = score?.dynamicImmune?.activeValidators ?? 0;
+
+  out.push(`  ${indicator(antibodies > 0)} ${ko ? "항체" : "Antibodies"}   ${C.bold}${antibodies}${C.reset} ${ko ? "활성" : "active"}${healed > 0 ? `  ${C.dim}(${healed}${ko ? "회 치유" : " healed"})${C.reset}` : ""}`);
+  out.push(`  ${indicator(validators > 0)} ${ko ? "검증기" : "Validators"}  ${validators > 0 ? `${C.bold}${validators}${C.reset} ${ko ? "로드됨" : "loaded"}` : `${C.dim}${ko ? "없음" : "none"}${C.reset} ${C.dim}(.afd/validators/)${C.reset}`}`);
+
+  out.push("");
+
+  // ── 4. Quarantine ──
+  const quarantined = getQuarantinedFiles();
+
+  if (quarantined.length > 0) {
+    out.push(`  ${C.yellow}⚠${C.reset}  ${C.bold}${C.yellow}${ko ? "격리 구역" : "Quarantine"}${C.reset} ${C.dim}(${quarantined.length} ${ko ? "파일" : "file"}${quarantined.length !== 1 ? "s" : ""})${C.reset}`);
+
+    const show = quarantined.slice(0, 5);
+    for (const file of show) {
+      out.push(`     ${C.dim}${file}${C.reset}`);
+    }
+    if (quarantined.length > 5) {
+      out.push(`     ${C.dim}... +${quarantined.length - 5} more${C.reset}`);
+    }
+
+    out.push("");
+    out.push(`  ${C.dim}💡 ${ko
+      ? "격리된 파일에서 코드를 구출하거나 불필요하면 삭제하세요."
+      : "Rescue code from quarantined files or delete if unneeded."}${C.reset}`);
+    out.push(`  ${C.dim}   ${ko ? "경로" : "Path"}: .afd/quarantine/${C.reset}`);
+  } else {
+    out.push(`  ${C.green}●${C.reset} ${ko ? "격리 구역" : "Quarantine"}   ${C.dim}${ko ? "비어있음 — 이상 없음" : "empty — all clear"}${C.reset}`);
+  }
+
+  out.push("");
+  console.log(out.join("\n"));
+}

package/src/commands/stop.ts

@@ -1,35 +1,68 @@
 import { getDaemonInfo, isDaemonAlive, daemonRequest } from "../daemon/client";
 import { unlinkSync } from "fs";
-import { PID_FILE, PORT_FILE } from "../constants";
+import { resolveWorkspacePaths } from "../constants";
+import { formatShiftSummary } from "../core/boast";
+import type { ShiftSummary } from "../core/boast";
+import { getSystemLanguage } from "../core/locale";
+import { getMessages, t } from "../core/i18n/messages";
+import { detectEcosystem } from "../adapters/index";
 
 function cleanupFiles() {
-  try { unlinkSync(PID_FILE); } catch {}
-  try { unlinkSync(PORT_FILE); } catch {}
+  const paths = resolveWorkspacePaths();
+  try { unlinkSync(paths.pidFile); } catch {}
+  try { unlinkSync(paths.portFile); } catch {}
 }
 
-export async function stopCommand() {
+export async function stopCommand(options?: { clean?: boolean }) {
+  const lang = getSystemLanguage();
+  const msg = getMessages(lang);
   const info = getDaemonInfo();
+
   if (!info) {
-    console.log("[afd] No daemon running.");
+    console.log(msg.DAEMON_NOT_RUNNING);
     return;
   }
 
   if (await isDaemonAlive(info)) {
+    // Fetch shift summary before stopping
+    try {
+      const summary = await daemonRequest<ShiftSummary>("/shift-summary");
+      console.log(formatShiftSummary(summary, lang));
+    } catch {
+      // Non-fatal: summary is a nicety, not a requirement
+    }
+
     try {
       await daemonRequest("/stop");
-      console.log(`[afd] Daemon stopped (pid=${info.pid})`);
+      console.log(t(msg.DAEMON_STOPPED, { pid: info.pid }));
     } catch {
-      // Force kill if graceful stop fails
       try {
         process.kill(info.pid, "SIGTERM");
-        console.log(`[afd] Daemon killed (pid=${info.pid})`);
+        console.log(t(msg.DAEMON_KILLED, { pid: info.pid }));
       } catch {
         console.log("[afd] Daemon process already gone.");
       }
     }
   } else {
-    console.log("[afd] Daemon not responding. Cleaning up stale PID files.");
+    console.log(msg.DAEMON_NOT_RESPONDING);
   }
 
   cleanupFiles();
+
+  // --clean: remove injected hooks and MCP registration
+  if (options?.clean) {
+    const cwd = process.cwd();
+    const ecosystems = detectEcosystem(cwd);
+    for (const { adapter } of ecosystems) {
+      if (adapter.removeHooks) {
+        const r = adapter.removeHooks(cwd);
+        if (r.removed) console.log(`[afd] ${r.message}`);
+      }
+      if (adapter.unregisterMcp) {
+        const r = adapter.unregisterMcp(cwd);
+        if (r.removed) console.log(`[afd] ${r.message}`);
+      }
+    }
+    console.log("[afd] Clean stop complete. All afd integrations removed.");
+  }
 }

package/src/commands/sync.ts

@@ -1,7 +1,8 @@
-import { readFileSync } from "fs";
-import { resolve } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, join } from "path";
 import { daemonRequest } from "../daemon/client";
 import { AFD_DIR } from "../constants";
+import { getSystemLanguage } from "../core/locale";
 
 interface SyncResponse {
   status: string;
@@ -9,7 +10,95 @@ interface SyncResponse {
   count: number;
 }
 
-export async function syncCommand() {
+interface VaccinePayload {
+  version: string;
+  generatedAt: string;
+  ecosystem: string;
+  antibodyCount: number;
+  antibodies: VaccineAntibody[];
+}
+
+interface VaccineAntibody {
+  id: string;
+  patternType: string;
+  fileTarget: string;
+  patches: { op: string; path: string; value?: string }[];
+  learnedAt: string;
+}
+
+interface SyncOptions {
+  push?: boolean;
+  pull?: boolean;
+  remote?: string;
+}
+
+const msgs = {
+  en: {
+    title: "afd sync — Vaccine Network",
+    ecosystem: "Ecosystem",
+    antibodies: "Antibodies",
+    generated: "Generated",
+    payload: "Payload",
+    noAntibodies: "No antibodies to export. Run `afd fix` first.",
+    exported: "Vaccine payload generated.",
+    pushTitle: "afd sync --push",
+    pushSuccess: "Pushed to team vaccine store",
+    pushCreated: "Created team vaccine store",
+    pullTitle: "afd sync --pull",
+    pullSuccess: "Pulled from team vaccine store",
+    pullMerged: "merged",
+    pullNew: "new",
+    pullSkipped: "skipped (already known)",
+    pullNoStore: "No team vaccine store found.",
+    pullHint: "Run `afd sync --push` first to create the shared store.",
+    learnedVia: "Learned via pull",
+    ready: "antibody(ies) ready for global federation.",
+  },
+  ko: {
+    title: "afd sync — 백신 네트워크",
+    ecosystem: "에코시스템",
+    antibodies: "항체",
+    generated: "생성일",
+    payload: "페이로드",
+    noAntibodies: "내보낼 항체가 없습니다. `afd fix`를 먼저 실행하세요.",
+    exported: "백신 페이로드 생성 완료.",
+    pushTitle: "afd sync --push",
+    pushSuccess: "팀 백신 저장소에 푸시 완료",
+    pushCreated: "팀 백신 저장소 생성",
+    pullTitle: "afd sync --pull",
+    pullSuccess: "팀 백신 저장소에서 풀 완료",
+    pullMerged: "병합됨",
+    pullNew: "신규",
+    pullSkipped: "건너뜀 (이미 존재)",
+    pullNoStore: "팀 백신 저장소를 찾을 수 없습니다.",
+    pullHint: "`afd sync --push`를 먼저 실행하여 공유 저장소를 생성하세요.",
+    learnedVia: "풀로 학습됨",
+    ready: "개 항체가 글로벌 페더레이션 준비 완료.",
+  },
+};
+
+const TEAM_STORE_DIR = join(AFD_DIR, "team-vaccines");
+const TEAM_PAYLOAD_FILE = join(TEAM_STORE_DIR, "shared-vaccine-payload.json");
+
+export async function syncCommand(opts: SyncOptions = {}) {
+  const lang = getSystemLanguage();
+  const m = msgs[lang];
+
+  if (opts.push) {
+    await syncPush(m);
+    return;
+  }
+
+  if (opts.pull) {
+    await syncPull(m);
+    return;
+  }
+
+  // Default: export local payload (original behavior)
+  await syncExport(m);
+}
+
+async function syncExport(m: typeof msgs.en) {
   let result: SyncResponse;
   try {
     result = await daemonRequest<SyncResponse>("/sync");
@@ -20,31 +109,175 @@ export async function syncCommand() {
   }
 
   if (result.count === 0) {
-    console.log("[afd sync] No antibodies to export. Run `afd fix` first to learn patterns.");
+    console.log(`[afd sync] ${m.noAntibodies}`);
     return;
   }
 
-  // Read the generated payload for display
   const payloadPath = resolve(AFD_DIR, "global-vaccine-payload.json");
   const payload = JSON.parse(readFileSync(payloadPath, "utf-8"));
+  renderPayloadBox(payload, m);
+  console.log(`\n[afd sync] ${m.exported} ${result.count} ${m.ready}`);
+}
+
+async function syncPush(m: typeof msgs.en) {
+  // First, export latest payload
+  let result: SyncResponse;
+  try {
+    result = await daemonRequest<SyncResponse>("/sync");
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[afd sync] ${msg}`);
+    process.exit(1);
+  }
+
+  if (result.count === 0) {
+    console.log(`[afd sync] ${m.noAntibodies}`);
+    return;
+  }
+
+  // Copy to team store
+  const localPayloadPath = resolve(AFD_DIR, "global-vaccine-payload.json");
+  const localPayload = readFileSync(localPayloadPath, "utf-8");
+
+  mkdirSync(TEAM_STORE_DIR, { recursive: true });
+
+  // Merge with existing team payload if present
+  let teamPayload: VaccinePayload;
+  if (existsSync(TEAM_PAYLOAD_FILE)) {
+    try {
+      teamPayload = JSON.parse(readFileSync(TEAM_PAYLOAD_FILE, "utf-8"));
+    } catch {
+      teamPayload = JSON.parse(localPayload);
+    }
+    // Merge: add new antibodies, update existing ones
+    const newPayload = JSON.parse(localPayload) as VaccinePayload;
+    const existingIds = new Set(teamPayload.antibodies.map(a => a.id));
+    for (const ab of newPayload.antibodies) {
+      if (existingIds.has(ab.id)) {
+        // Update existing
+        const idx = teamPayload.antibodies.findIndex(a => a.id === ab.id);
+        if (idx >= 0) teamPayload.antibodies[idx] = ab;
+      } else {
+        teamPayload.antibodies.push(ab);
+      }
+    }
+    teamPayload.antibodyCount = teamPayload.antibodies.length;
+    teamPayload.generatedAt = new Date().toISOString();
+  } else {
+    teamPayload = JSON.parse(localPayload);
+    console.log(`[afd sync] ${m.pushCreated}`);
+  }
+
+  writeFileSync(TEAM_PAYLOAD_FILE, JSON.stringify(teamPayload, null, 2), "utf-8");
+
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 50;
+  const line = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v}  ${s}${" ".repeat(Math.max(0, W - 2 - s.length))}${BOX.v}`;
+
+  console.log(line(BOX.tl, BOX.tr));
+  console.log(row(`📤 ${m.pushTitle}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`${m.antibodies}: ${teamPayload.antibodyCount}`));
+  console.log(row(`${m.payload}: ${TEAM_PAYLOAD_FILE}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`✅ ${m.pushSuccess}`));
+  console.log(line(BOX.bl, BOX.br));
+}
+
+async function syncPull(m: typeof msgs.en) {
+  if (!existsSync(TEAM_PAYLOAD_FILE)) {
+    console.log(`[afd sync] ${m.pullNoStore}`);
+    console.log(`[afd sync] ${m.pullHint}`);
+    return;
+  }
+
+  let teamPayload: VaccinePayload;
+  try {
+    teamPayload = JSON.parse(readFileSync(TEAM_PAYLOAD_FILE, "utf-8"));
+  } catch {
+    console.error("[afd sync] Failed to parse team vaccine payload.");
+    process.exit(1);
+  }
+
+  // Learn each antibody into the daemon
+  let newCount = 0;
+  let skippedCount = 0;
+  const results: { id: string; status: string }[] = [];
+
+  for (const ab of teamPayload.antibodies) {
+    try {
+      // Try to learn via daemon API
+      const res = await fetch(`http://127.0.0.1:${getDaemonPort()}/antibodies/learn`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: ab.id,
+          patternType: ab.patternType,
+          fileTarget: ab.fileTarget,
+          patches: ab.patches,
+        }),
+        signal: AbortSignal.timeout(2000),
+      });
+      if (res.ok) {
+        results.push({ id: ab.id, status: m.pullNew });
+        newCount++;
+      } else {
+        results.push({ id: ab.id, status: m.pullSkipped });
+        skippedCount++;
+      }
+    } catch {
+      results.push({ id: ab.id, status: m.pullSkipped });
+      skippedCount++;
+    }
+  }
+
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 50;
+  const line = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v}  ${s}${" ".repeat(Math.max(0, W - 2 - s.length))}${BOX.v}`;
+
+  console.log(line(BOX.tl, BOX.tr));
+  console.log(row(`📥 ${m.pullTitle}`));
+  console.log(line(BOX.ml, BOX.mr));
+
+  for (const r of results) {
+    const icon = r.status === m.pullNew ? "✅" : "⏭️";
+    console.log(row(`${icon} ${r.id}: ${r.status}`));
+  }
+
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`✅ ${m.pullSuccess}: ${newCount} ${m.pullMerged}`));
+  console.log(line(BOX.bl, BOX.br));
+}
+
+function getDaemonPort(): number {
+  const { getDaemonInfo } = require("../daemon/client");
+  const info = getDaemonInfo();
+  if (!info) throw new Error("Daemon not running");
+  return info.port;
+}
+
+function renderPayloadBox(payload: VaccinePayload, m: typeof msgs.en) {
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 48;
+  const line = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v}  ${s}${" ".repeat(Math.max(0, W - 2 - s.length))}${BOX.v}`;
 
-  const box = "\u2500".repeat(46);
-  console.log(`\u250C${box}\u2510`);
-  console.log(`\u2502  afd sync \u2014 Vaccine Network                    \u2502`);
-  console.log(`\u251C${box}\u2524`);
-  console.log(`\u2502  Ecosystem  : ${payload.ecosystem.padEnd(31)}\u2502`);
-  console.log(`\u2502  Antibodies : ${String(payload.antibodyCount).padEnd(31)}\u2502`);
-  console.log(`\u2502  Generated  : ${payload.generatedAt.substring(0, 19).padEnd(31)}\u2502`);
-  console.log(`\u251C${box}\u2524`);
+  console.log(line(BOX.tl, BOX.tr));
+  console.log(row(`${m.title}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`${m.ecosystem}  : ${payload.ecosystem}`));
+  console.log(row(`${m.antibodies} : ${payload.antibodyCount}`));
+  console.log(row(`${m.generated}  : ${payload.generatedAt.substring(0, 19)}`));
+  console.log(line(BOX.ml, BOX.mr));
 
   for (const ab of payload.antibodies) {
-    const patches = ab.patches.map((p: { op: string; path: string }) => `${p.op} ${p.path}`).join(", ");
-    console.log(`\u2502  [${ab.id}] ${ab.patternType.padEnd(20)} ${patches.substring(0, 12).padEnd(12)}\u2502`);
+    const patches = ab.patches.map(p => `${p.op} ${p.path}`).join(", ");
+    console.log(row(`[${ab.id}] ${ab.patternType.padEnd(18)} ${patches.substring(0, 14)}`));
   }
 
-  console.log(`\u251C${box}\u2524`);
-  console.log(`\u2502  Payload: .afd/global-vaccine-payload.json     \u2502`);
-  console.log(`\u2514${box}\u2518`);
-  console.log();
-  console.log(`[afd sync] Vaccine payload generated. ${result.count} antibody(ies) ready for global federation.`);
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`${m.payload}: .afd/global-vaccine-payload.json`));
+  console.log(line(BOX.bl, BOX.br));
 }