autonomous-flow-daemon 1.1.0 → 1.6.0

package/src/daemon/http-routes.ts

@@ -0,0 +1,293 @@
+/**
+ * HTTP routes for daemon IPC — extracted from server.ts.
+ */
+
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { generateHologram } from "../core/hologram";
+import { diagnose } from "../core/immune";
+import type { PatchOp } from "../core/immune";
+import { buildShiftSummary } from "../core/boast";
+import { analyzeQuarantine, listQuarantine, evolve } from "../core/evolution";
+import { MAX_SSE_CLIENTS } from "./types";
+import type { DaemonContext } from "./types";
+import { assertInsideWorkspace as _assertWs } from "./guards";
+
+/** Create the HTTP fetch handler for Bun.serve */
+export function createHttpHandler(ctx: DaemonContext, cleanup: () => void) {
+  return async function fetch(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+
+    if (url.pathname === "/health") {
+      return Response.json({ status: "alive", pid: process.pid, workspace: ctx.ws.root, port: ctx.port });
+    }
+
+    if (url.pathname === "/mini-status") {
+      const last = ctx.state.autoHealLog.length > 0
+        ? ctx.state.autoHealLog[ctx.state.autoHealLog.length - 1].id
+        : null;
+      // Defense reasons from in-memory mistakeCache (not DB query — stays under 200ms)
+      const reasonSet = new Set<string>();
+      for (const entries of ctx.state.mistakeCache.values()) {
+        for (const e of entries) {
+          reasonSet.add(e.mistake_type);
+          if (reasonSet.size >= 3) break;
+        }
+        if (reasonSet.size >= 3) break;
+      }
+      return Response.json({
+        status: "ON",
+        healed_count: ctx.state.autoHealCount,
+        last_healed: last,
+        total_defenses: ctx.state.autoHealCount,
+        defense_reasons: [...reasonSet],
+        saved_tokens_k: Math.round(Math.max(0, ctx.state.hologramStats.totalOriginalChars - ctx.state.hologramStats.totalHologramChars) / 4 / 100) / 10,
+        session_saved_tokens_k: Math.round(Math.max(0, ctx.state.hologramStats.sessionOriginalChars - ctx.state.hologramStats.sessionHologramChars) / 4 / 100) / 10,
+      });
+    }
+
+    // Track HTTP API calls as telemetry
+    const _apiPath = url.pathname.replace(/^\//, "");
+    if (["/hologram", "/read", "/diagnose", "/score", "/evolution", "/sync"].includes(url.pathname)) {
+      try { ctx.insertTelemetry.run("mcp", `http_${_apiPath}`, null, null, Date.now()); } catch { /* crash-only */ }
+    }
+
+    if (url.pathname === "/hologram") {
+      const file = url.searchParams.get("file");
+      if (!file) return Response.json({ error: "?file= required" }, { status: 400 });
+      try {
+        const absPath = resolve(file);
+        _assertWs(absPath, ctx.ws.root);
+        const source = readFileSync(absPath, "utf-8");
+        const contextFile = url.searchParams.get("contextFile");
+        const result = await generateHologram(file, source, contextFile ? { contextFile: resolve(contextFile) } : undefined);
+        ctx.persistHologramStats(result.originalLength, result.hologramLength);
+        return Response.json(result);
+      } catch (err: unknown) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 404 });
+      }
+    }
+
+    if (url.pathname === "/workspace-map") {
+      return new Response(ctx.getWorkspaceMap(), { headers: { "Content-Type": "text/plain" } });
+    }
+
+    if (url.pathname === "/read") {
+      const file = url.searchParams.get("file");
+      if (!file) return Response.json({ error: "?file= required" }, { status: 400 });
+      try {
+        const AFD_READ_THRESHOLD = 10 * 1024;
+        const absPath = resolve(file);
+        _assertWs(absPath, ctx.ws.root);
+        const source = readFileSync(absPath, "utf-8");
+        const rawStart = parseInt(url.searchParams.get("startLine") ?? "", 10);
+        const rawEnd = parseInt(url.searchParams.get("endLine") ?? "", 10);
+
+        if (Number.isFinite(rawStart) && Number.isFinite(rawEnd)) {
+          const lines = source.split("\n");
+          const s = Math.max(1, rawStart) - 1;
+          const e = Math.min(lines.length, rawEnd);
+          return Response.json({ file, lines: lines.slice(s, e), range: [s + 1, e], totalLines: lines.length });
+        }
+        if (source.length < AFD_READ_THRESHOLD) {
+          return Response.json({ file, content: source, mode: "full" });
+        }
+        const result = await generateHologram(file, source);
+        ctx.persistHologramStats(result.originalLength, result.hologramLength);
+        return Response.json({ file, hologram: result.hologram, mode: "hologram", originalSize: source.length, totalLines: source.split("\n").length });
+      } catch (err: unknown) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 404 });
+      }
+    }
+
+    if (url.pathname === "/mistake-history") {
+      const file = url.searchParams.get("file");
+      if (!file) return Response.json({ error: "?file= required" }, { status: 400 });
+      const normalizedFile = file.replace(/\\/g, "/");
+      const cached = ctx.state.mistakeCache.get(normalizedFile);
+      return Response.json({ mistakes: cached ?? [] });
+    }
+
+    if (url.pathname === "/diagnose") {
+      const raw = url.searchParams.get("raw") === "true";
+      const known = ctx.antibodyIds.all().map(r => r.id);
+      const result = diagnose(known, { raw });
+      const PROACTIVE_HOLOGRAM_THRESHOLD = 5 * 1024;
+
+      const enriched = await Promise.all(result.symptoms.map(async (s: { fileTarget: string; [k: string]: unknown }) => {
+        const snapshot = ctx.state.fileSnapshots.get(s.fileTarget)
+          ?? ctx.state.fileSnapshots.get(s.fileTarget.replace(/\//g, "\\"));
+        if (!snapshot) return s;
+        if (snapshot.length > PROACTIVE_HOLOGRAM_THRESHOLD) {
+          const hologram = await ctx.safeHologram(s.fileTarget, snapshot);
+          return {
+            ...s, hologram,
+            contextNote: `File is ${(snapshot.length / 1024).toFixed(1)}KB — hologram skeleton provided to save tokens (${Math.round((1 - hologram.length / snapshot.length) * 100)}% reduction).`,
+          };
+        }
+        return { ...s, context: snapshot };
+      }));
+      return Response.json({ ...result, symptoms: enriched });
+    }
+
+    if (url.pathname === "/antibodies") {
+      return Response.json({ antibodies: ctx.listAntibodies.all() });
+    }
+
+    if (url.pathname === "/antibodies/learn" && req.method === "POST") {
+      try {
+        const body = await req.json() as { id: string; patternType: string; fileTarget: string; patches: PatchOp[] };
+        ctx.insertAntibody.run(body.id, body.patternType, body.fileTarget, JSON.stringify(body.patches));
+        return Response.json({ status: "learned", id: body.id });
+      } catch (err: unknown) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
+      }
+    }
+
+    if (url.pathname === "/auto-heal/record" && req.method === "POST") {
+      try {
+        const body = await req.json() as { id: string };
+        ctx.state.autoHealCount++;
+        ctx.state.autoHealLog.push({ id: body.id, at: Date.now() });
+        if (ctx.state.autoHealLog.length > 100) ctx.state.autoHealLog.shift();
+        try { ctx.insertTelemetry.run("immune", "heal_hit", JSON.stringify({ antibodyId: body.id }), null, Date.now()); } catch { /* crash-only */ }
+        return Response.json({ status: "recorded", total: ctx.state.autoHealCount });
+      } catch (err: unknown) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
+      }
+    }
+
+    if (url.pathname === "/score") {
+      const uptime = Math.floor((Date.now() - ctx.state.startedAt) / 1000);
+      const eventCount = ctx.db.query("SELECT COUNT(*) as cnt FROM events").get() as { cnt: number };
+      const abCount = ctx.countAntibodies.get() as { cnt: number };
+      const hs = ctx.state.hologramStats;
+      const globalSavings = hs.totalOriginalChars > 0
+        ? Math.round((hs.totalOriginalChars - hs.totalHologramChars) / hs.totalOriginalChars * 1000) / 10
+        : 0;
+      const dailyRows = ctx.getDailyAll.all() as { date: string; requests: number; original_chars: number; hologram_chars: number }[];
+      const todayRow = dailyRows.find(r => r.date === ctx.today());
+      return Response.json({
+        uptime,
+        filesDetected: ctx.state.filesDetected,
+        totalEvents: eventCount.cnt,
+        lastEvent: ctx.state.lastEvent,
+        lastEventAt: ctx.state.lastEventAt,
+        watchedFiles: [...ctx.state.watchedFiles],
+        watchTargets: ctx.discoveryTargets,
+        hologram: {
+          lifetime: { requests: hs.totalRequests, originalChars: hs.totalOriginalChars, hologramChars: hs.totalHologramChars, savings: globalSavings },
+          today: todayRow ? {
+            requests: todayRow.requests, originalChars: todayRow.original_chars, hologramChars: todayRow.hologram_chars,
+            savings: todayRow.original_chars > 0 ? Math.round((todayRow.original_chars - todayRow.hologram_chars) / todayRow.original_chars * 1000) / 10 : 0,
+          } : null,
+          daily: dailyRows.map(r => ({ date: r.date, requests: r.requests, originalChars: r.original_chars, hologramChars: r.hologram_chars })),
+        },
+        immune: {
+          antibodies: abCount.cnt,
+          autoHealed: ctx.state.autoHealCount,
+          lastAutoHeal: ctx.state.autoHealLog.length > 0 ? ctx.state.autoHealLog[ctx.state.autoHealLog.length - 1] : null,
+        },
+        ecosystem: {
+          detected: ctx.state.ecosystems.map(e => ({ name: e.adapter.name, confidence: e.confidence, schema: e.adapter.getHarnessSchema() })),
+          primary: ctx.state.ecosystems[0]?.adapter.name ?? "Unknown",
+        },
+        suppression: {
+          massEventsSkipped: ctx.state.suppressionSkippedCount,
+          dormantTransitions: ctx.state.dormantTransitions.length,
+          activeTaps: ctx.state.firstTapTimestamps.size,
+        },
+        evolution: (() => {
+          const q = listQuarantine();
+          return { totalQuarantined: q.length, totalLearned: q.filter(e => e.learned).length, pending: q.filter(e => !e.learned).length };
+        })(),
+        dynamicImmune: {
+          activeValidators: ctx.state.customValidators.size,
+          validatorNames: [...ctx.state.customValidators.keys()],
+        },
+      });
+    }
+
+    if (url.pathname === "/evolution") {
+      return Response.json(evolve());
+    }
+
+    if (url.pathname === "/evolution/status") {
+      const q = listQuarantine();
+      const stats = analyzeQuarantine();
+      return Response.json({
+        totalQuarantined: q.length, totalLearned: q.filter(e => e.learned).length, pending: stats.pending,
+        lessons: stats.lessons.map(l => ({ file: l.entry.originalPath, type: l.failureType, timestamp: l.entry.timestamp, suggestion: l.suggestion })),
+      });
+    }
+
+    if (url.pathname === "/sync") {
+      const rows = ctx.listAntibodies.all() as { id: string; pattern_type: string; file_target: string; patch_op: string; created_at: string }[];
+      const sanitized = rows.flatMap(r => {
+        let patches: PatchOp[];
+        try { patches = JSON.parse(r.patch_op) as PatchOp[]; } catch { return []; }
+        const cleanPatches = patches.map(p => ({
+          ...p,
+          path: p.path.replace(/^[A-Za-z]:/, "").replace(/\\/g, "/"),
+          value: p.value?.replace(/[A-Za-z]:\\[^\s"']*/g, "<redacted>"),
+        }));
+        return [{ id: r.id, patternType: r.pattern_type, fileTarget: r.file_target.replace(/^[A-Za-z]:/, "").replace(/\\/g, "/"), patches: cleanPatches, learnedAt: r.created_at }];
+      });
+      const payload = {
+        version: "0.1.0", generatedAt: new Date().toISOString(),
+        ecosystem: ctx.state.ecosystems[0]?.adapter.name ?? "Unknown",
+        antibodyCount: sanitized.length, antibodies: sanitized,
+      };
+      const payloadPath = resolve(ctx.ws.afdDir, "global-vaccine-payload.json");
+      writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
+      return Response.json({ status: "exported", path: payloadPath, count: sanitized.length });
+    }
+
+    if (url.pathname === "/shift-summary") {
+      const uptime = Math.floor((Date.now() - ctx.state.startedAt) / 1000);
+      const eventCount = ctx.db.query("SELECT COUNT(*) as cnt FROM events").get() as { cnt: number };
+      const hs = ctx.state.hologramStats;
+      const hologramSavedChars = Math.max(0, hs.totalOriginalChars - hs.totalHologramChars);
+      return Response.json(buildShiftSummary({
+        uptimeSeconds: uptime, totalEvents: eventCount.cnt, healsPerformed: ctx.state.autoHealCount,
+        totalFileBytesSaved: ctx.state.totalFileBytesSaved, suppressionsSkipped: ctx.state.suppressionSkippedCount,
+        dormantTransitions: ctx.state.dormantTransitions.length, hologramSavedChars,
+      }));
+    }
+
+    if (url.pathname === "/events") {
+      if (ctx.state.sseClients.size >= MAX_SSE_CLIENTS) {
+        return Response.json({ error: "Too many SSE clients" }, { status: 429 });
+      }
+      let sseController: ReadableStreamDefaultController<Uint8Array> | null = null;
+      const stream = new ReadableStream<Uint8Array>({
+        start(controller) { sseController = controller; ctx.state.sseClients.add(controller); },
+        cancel() { if (sseController) ctx.state.sseClients.delete(sseController); },
+      });
+      return new Response(stream, {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" },
+      });
+    }
+
+    if (url.pathname === "/telemetry") {
+      const days = parseInt(url.searchParams.get("days") ?? "7", 10) || 7;
+      const since = Date.now() - days * 86_400_000;
+      try {
+        const rows = ctx.db.prepare(
+          "SELECT category, action, COUNT(*) as cnt, AVG(duration_ms) as avg_ms FROM telemetry WHERE timestamp >= ? GROUP BY category, action ORDER BY cnt DESC"
+        ).all(since) as { category: string; action: string; cnt: number; avg_ms: number | null }[];
+        return Response.json({ days, rows });
+      } catch {
+        return Response.json({ days, rows: [] });
+      }
+    }
+
+    if (url.pathname === "/stop") {
+      cleanup();
+      setTimeout(() => process.exit(0), 100);
+      return Response.json({ status: "stopping" });
+    }
+
+    return Response.json({ error: "not found" }, { status: 404 });
+  };
+}

package/src/daemon/mcp-handler.ts

@@ -0,0 +1,270 @@
+/**
+ * MCP stdio handler — JSON-RPC dispatcher for tools and resources.
+ * Extracted from server.ts for modularity.
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { generateHologram } from "../core/hologram";
+import { diagnose } from "../core/immune";
+import type { DaemonContext } from "./types";
+import { APP_VERSION } from "../version";
+import { assertInsideWorkspace as _assertWs } from "./guards";
+
+const MCP_MAX_BUFFER = 1024 * 1024; // 1 MB
+
+const mcpToolDefs = [
+  {
+    name: "afd_diagnose",
+    description: "Run health diagnosis on the current project. Returns symptoms and healthy checks.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        raw: { type: "boolean" as const, description: "If true, report all symptoms ignoring antibodies" },
+      },
+    },
+  },
+  {
+    name: "afd_score",
+    description: "Get daemon runtime stats: uptime, events, heals, hologram savings, suppression metrics.",
+    inputSchema: { type: "object" as const, properties: {} },
+  },
+  {
+    name: "afd_hologram",
+    description: "Generate a token-efficient hologram (type skeleton) for a source file (TS, JS, Python). Use contextFile for L1 filtering. Use diffOnly for incremental updates showing only changed declarations.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        file: { type: "string" as const, description: "Relative or absolute file path" },
+        contextFile: { type: "string" as const, description: "Optional: the file that imports from 'file'. Enables L1 filtering for higher compression." },
+        diffOnly: { type: "boolean" as const, description: "Optional: return only changed declarations since last hologram call (unified-diff format). Saves tokens on repeated reads." },
+      },
+      required: ["file"],
+    },
+  },
+  {
+    name: "afd_read",
+    description: "Smart file reader that saves tokens. Files <10KB return full content. Files >=10KB return a structural hologram instead. Use 'startLine' and 'endLine' to read specific line ranges of large files at full fidelity.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        file: { type: "string" as const, description: "Relative or absolute file path" },
+        startLine: { type: "number" as const, description: "Start line number (1-based, inclusive). Use with endLine to read a specific range of large files." },
+        endLine: { type: "number" as const, description: "End line number (1-based, inclusive)." },
+      },
+      required: ["file"],
+    },
+  },
+];
+
+function mcpResponse(id: unknown, result: unknown) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+}
+
+function mcpError(id: unknown, code: number, message: string) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+}
+
+
+async function handleMcpRequest(ctx: DaemonContext, req: { id?: unknown; method?: string; params?: Record<string, unknown> }) {
+  const { id, method, params } = req;
+
+  if (method === "initialize") {
+    mcpResponse(id, {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {}, resources: {} },
+      serverInfo: { name: "afd", version: APP_VERSION },
+    });
+    return;
+  }
+
+  if (method === "notifications/initialized") return;
+
+  if (method === "tools/list") {
+    mcpResponse(id, { tools: mcpToolDefs });
+    return;
+  }
+
+  if (method === "resources/list") {
+    mcpResponse(id, {
+      resources: [{
+        uri: "afd://workspace-map",
+        name: "Workspace Map",
+        description: "Project file tree with export signatures. Read this first to understand the codebase structure before reading individual files.",
+        mimeType: "text/plain",
+      }],
+    });
+    return;
+  }
+
+  if (method === "resources/read") {
+    const uri = params?.uri as string | undefined;
+    if (uri === "afd://workspace-map") {
+      mcpResponse(id, {
+        contents: [{ uri: "afd://workspace-map", mimeType: "text/plain", text: ctx.getWorkspaceMap() }],
+      });
+      return;
+    }
+    mcpError(id, -32602, `Unknown resource: ${uri}`);
+    return;
+  }
+
+  if (method === "tools/call") {
+    const toolName = params?.name as string | undefined;
+    const args = (params?.arguments ?? {}) as Record<string, unknown>;
+
+    // Track MCP tool call
+    if (toolName) {
+      try { ctx.insertTelemetry.run("mcp", toolName, null, null, Date.now()); } catch { /* crash-only */ }
+    }
+
+    if (toolName === "afd_diagnose") {
+      const raw = args.raw === true;
+      const known = ctx.antibodyIds.all().map(r => r.id);
+      const result = diagnose(known, { raw });
+
+      const PROACTIVE_THRESHOLD = 5 * 1024;
+      const enriched = await Promise.all(result.symptoms.map(async (s: { fileTarget: string; [k: string]: unknown }) => {
+        const snapshot = ctx.state.fileSnapshots.get(s.fileTarget)
+          ?? ctx.state.fileSnapshots.get(s.fileTarget.replace(/\//g, "\\"));
+        if (!snapshot) return s;
+        if (snapshot.length > PROACTIVE_THRESHOLD) {
+          const hologram = await ctx.safeHologram(s.fileTarget, snapshot);
+          return { ...s, hologram, contextNote: `File is ${(snapshot.length / 1024).toFixed(1)}KB — hologram provided to save tokens.` };
+        }
+        return { ...s, context: snapshot };
+      }));
+
+      mcpResponse(id, {
+        content: [{ type: "text", text: JSON.stringify({ ...result, symptoms: enriched }, null, 2), cache_control: { type: "ephemeral" } }],
+      });
+      return;
+    }
+
+    if (toolName === "afd_score") {
+      const uptime = Math.floor((Date.now() - ctx.state.startedAt) / 1000);
+      const eventCount = ctx.db.query("SELECT COUNT(*) as cnt FROM events").get() as { cnt: number };
+      const abCount = ctx.countAntibodies.get() as { cnt: number };
+      const hs = ctx.state.hologramStats;
+      mcpResponse(id, {
+        content: [{ type: "text", text: JSON.stringify({
+          uptime,
+          filesDetected: ctx.state.filesDetected,
+          totalEvents: eventCount.cnt,
+          antibodies: abCount.cnt,
+          autoHealed: ctx.state.autoHealCount,
+          hologramRequests: hs.totalRequests,
+          hologramSavings: hs.totalOriginalChars > 0
+            ? `${Math.round((hs.totalOriginalChars - hs.totalHologramChars) / hs.totalOriginalChars * 100)}%`
+            : "0%",
+          suppression: {
+            massEventsSkipped: ctx.state.suppressionSkippedCount,
+            dormantTransitions: ctx.state.dormantTransitions.length,
+          },
+        }, null, 2), cache_control: { type: "ephemeral" } }],
+      });
+      return;
+    }
+
+    if (toolName === "afd_hologram") {
+      const file = args.file as string | undefined;
+      if (!file) { mcpError(id, -32602, "Missing required argument: file"); return; }
+      try {
+        const absPath = resolve(file);
+        _assertWs(absPath, ctx.ws.root);
+        const source = readFileSync(absPath, "utf-8");
+        const contextFile = args.contextFile as string | undefined;
+        const diffOnly = args.diffOnly === true;
+        const opts: Record<string, unknown> = {};
+        if (contextFile) opts.contextFile = resolve(contextFile);
+        if (diffOnly) opts.diffOnly = true;
+        const result = await generateHologram(file, source, Object.keys(opts).length > 0 ? opts as { contextFile?: string; diffOnly?: boolean } : undefined);
+        ctx.persistHologramStats(result.originalLength, result.hologramLength);
+        mcpResponse(id, {
+          content: [{ type: "text", text: result.hologram, cache_control: { type: "ephemeral" } }],
+        });
+      } catch (err: unknown) {
+        mcpError(id, -32603, err instanceof Error ? err.message : String(err));
+      }
+      return;
+    }
+
+    if (toolName === "afd_read") {
+      const file = args.file as string | undefined;
+      if (!file) { mcpError(id, -32602, "Missing required argument: file"); return; }
+      try {
+        const AFD_READ_THRESHOLD = 10 * 1024;
+        const absPath = resolve(file);
+        _assertWs(absPath, ctx.ws.root);
+        const source = readFileSync(absPath, "utf-8");
+        const sizeKB = (source.length / 1024).toFixed(1);
+        const rawStart = args.startLine;
+        const rawEnd = args.endLine;
+        const startLine = typeof rawStart === "number" && Number.isFinite(rawStart) ? rawStart : undefined;
+        const endLine = typeof rawEnd === "number" && Number.isFinite(rawEnd) ? rawEnd : undefined;
+
+        if (startLine !== undefined && endLine !== undefined) {
+          const lines = source.split("\n");
+          const start = Math.max(1, Math.floor(startLine)) - 1;
+          const end = Math.min(lines.length, Math.floor(endLine));
+          const slice = lines.slice(start, end).map((l, i) => `${start + i + 1}\t${l}`).join("\n");
+          mcpResponse(id, {
+            content: [{ type: "text", text: `// ${file} lines ${start + 1}-${end} (${sizeKB}KB total)\n${slice}`, cache_control: { type: "ephemeral" } }],
+          });
+          return;
+        }
+
+        if (source.length < AFD_READ_THRESHOLD) {
+          mcpResponse(id, {
+            content: [{ type: "text", text: source, cache_control: { type: "ephemeral" } }],
+          });
+          return;
+        }
+
+        const result = await generateHologram(file, source);
+        ctx.persistHologramStats(result.originalLength, result.hologramLength);
+        const savings = Math.round((1 - result.hologramLength / result.originalLength) * 100);
+        const header = `⚠️ [afd-Optimizer]: File is ${sizeKB}KB. To save tokens, only the structural hologram is provided (${savings}% reduction).\nUse afd_read with startLine/endLine to read specific sections at full fidelity.\nTotal lines: ${source.split("\n").length}\n\n`;
+        mcpResponse(id, {
+          content: [{ type: "text", text: header + result.hologram, cache_control: { type: "ephemeral" } }],
+        });
+      } catch (err: unknown) {
+        mcpError(id, -32603, err instanceof Error ? err.message : String(err));
+      }
+      return;
+    }
+
+    mcpError(id, -32601, `Unknown tool: ${toolName}`);
+    return;
+  }
+
+  mcpError(id, -32601, `Unknown method: ${method}`);
+}
+
+/** Start MCP stdio mode — blocks until stdin closes */
+export function startMcpStdio(ctx: DaemonContext) {
+  console.error("[afd] MCP stdio mode — awaiting JSON-RPC on stdin");
+
+  (async () => {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of Bun.stdin.stream()) {
+      buffer += decoder.decode(chunk);
+      if (buffer.length > MCP_MAX_BUFFER) {
+        console.error("[afd] MCP buffer overflow — dropping buffer");
+        buffer = "";
+        continue;
+      }
+      let newlineIdx: number;
+      while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (!line) continue;
+        try { handleMcpRequest(ctx, JSON.parse(line)); } catch { /* crash-only */ }
+      }
+    }
+  })().catch((err) => {
+    console.error("[afd] MCP stdin loop error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}