autonomous-flow-daemon 1.0.0

package/src/adapters/index.ts

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+
+export interface HarnessSchema {
+  configFiles: string[];
+  ignoreFile: string | null;
+  rulesFile: string | null;
+  hooksFile: string | null;
+}
+
+export interface EcosystemAdapter {
+  name: string;
+  detect(cwd: string): boolean;
+  getHarnessSchema(): HarnessSchema;
+  injectHooks?(cwd: string): { injected: boolean; message: string };
+  configureStatusLine?(cwd: string): { configured: boolean; message: string };
+}
+
+const AFD_HOOK_MARKER = "afd-auto-heal";
+
+interface HooksConfig {
+  hooks?: Record<string, HookEntry[]>;
+  [key: string]: unknown;
+}
+
+interface HookEntry {
+  matcher?: string;
+  command: string;
+  id?: string;
+  [key: string]: unknown;
+}
+
+export const ClaudeCodeAdapter: EcosystemAdapter = {
+  name: "Claude Code",
+  detect(cwd: string): boolean {
+    return (
+      existsSync(join(cwd, ".claude")) ||
+      existsSync(join(cwd, "CLAUDE.md"))
+    );
+  },
+  getHarnessSchema(): HarnessSchema {
+    return {
+      configFiles: [".claude/settings.json", ".claude/settings.local.json", "CLAUDE.md"],
+      ignoreFile: ".claudeignore",
+      rulesFile: "CLAUDE.md",
+      hooksFile: ".claude/hooks.json",
+    };
+  },
+  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: {} };
+    }
+
+    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)" };
+    }
+
+    config.hooks.PreToolUse.push(newHook);
+    writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+    return { injected: true, message: "Auto-heal hook injected into PreToolUse" };
+  },
+  configureStatusLine(cwd: string): { configured: boolean; message: string } {
+    const settingsPath = join(cwd, ".claude", "settings.local.json");
+    const statusScript = join(cwd, ".claude", "statusline-command.js").replace(/\\/g, "/");
+
+    // Only configure if the statusline-command.js exists
+    if (!existsSync(statusScript)) {
+      return { configured: false, message: "No statusline-command.js found" };
+    }
+
+    let settings: Record<string, unknown>;
+    if (existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    } else {
+      mkdirSync(dirname(settingsPath), { recursive: true });
+      settings = {};
+    }
+
+    const expectedCommand = `node ${statusScript}`;
+    const current = settings.statusLine as { type?: string; command?: string } | undefined;
+
+    if (current?.type === "command" && current?.command === expectedCommand) {
+      return { configured: false, message: "Status line already configured" };
+    }
+
+    settings.statusLine = { type: "command", command: expectedCommand };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return { configured: true, message: "Status line configured with afd integration" };
+  },
+};
+
+export const CursorAdapter: EcosystemAdapter = {
+  name: "Cursor",
+  detect(cwd: string): boolean {
+    return existsSync(join(cwd, ".cursorrules"));
+  },
+  getHarnessSchema(): HarnessSchema {
+    return {
+      configFiles: [".cursorrules", ".cursor/settings.json"],
+      ignoreFile: ".cursorignore",
+      rulesFile: ".cursorrules",
+      hooksFile: null,
+    };
+  },
+};
+
+const adapters: EcosystemAdapter[] = [ClaudeCodeAdapter, CursorAdapter];
+
+export interface DetectionResult {
+  adapter: EcosystemAdapter;
+  confidence: "primary" | "secondary";
+}
+
+export function detectEcosystem(cwd: string): DetectionResult[] {
+  const results: DetectionResult[] = [];
+  for (const adapter of adapters) {
+    if (adapter.detect(cwd)) {
+      results.push({
+        adapter,
+        confidence: results.length === 0 ? "primary" : "secondary",
+      });
+    }
+  }
+  return results;
+}

package/src/cli.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { startCommand } from "./commands/start";
+import { stopCommand } from "./commands/stop";
+import { scoreCommand } from "./commands/score";
+import { fixCommand } from "./commands/fix";
+import { syncCommand } from "./commands/sync";
+import { diagnoseCommand } from "./commands/diagnose";
+
+const program = new Command();
+
+program
+  .name("afd")
+  .description("Autonomous Flow Daemon - The Immune System for AI Workflows")
+  .version("1.0.0");
+
+program
+  .command("start")
+  .description("Start the afd daemon (background file watcher)")
+  .action(startCommand);
+
+program
+  .command("stop")
+  .description("Stop the afd daemon")
+  .action(stopCommand);
+
+program
+  .command("score")
+  .description("Show current diagnostic stats from the daemon")
+  .action(scoreCommand);
+
+program
+  .command("fix")
+  .description("Auto-fix detected issues in AI workflow config")
+  .action(fixCommand);
+
+program
+  .command("sync")
+  .description("Synchronize AI agent configs across team")
+  .action(syncCommand);
+
+program
+  .command("diagnose")
+  .description("Run headless diagnosis (used by auto-heal hooks)")
+  .option("--format <type>", "Output format: a2a or human", "human")
+  .option("--auto-heal", "Auto-apply patches for known antibodies")
+  .action(diagnoseCommand);
+
+program.parse();

package/src/commands/diagnose.ts

@@ -0,0 +1,151 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { daemonRequest } from "../daemon/client";
+import type { Symptom, PatchOp, DiagnosisResult } from "../core/immune";
+import { notifyAutoHeal } from "../core/notify";
+
+interface DiagnoseOptions {
+  format?: string;
+  autoHeal?: boolean;
+}
+
+interface AutoHealResponse {
+  status: string;
+  healed: string[];
+  skipped: string[];
+}
+
+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;
+}
+
+export async function diagnoseCommand(opts: DiagnoseOptions) {
+  const isA2A = opts.format === "a2a";
+  const autoHeal = opts.autoHeal === true;
+
+  let diagnosis: DiagnosisResult;
+  // In auto-heal mode, use raw diagnosis to detect regressions even for immunized patterns
+  const diagnosePath = autoHeal ? "/diagnose?raw=true" : "/diagnose";
+  try {
+    diagnosis = await daemonRequest<DiagnosisResult>(diagnosePath);
+  } catch {
+    // Daemon not running — exit silently in auto-heal mode to not block agent
+    if (autoHeal) process.exit(0);
+    console.error("[afd diagnose] Daemon not running. Run `afd start` first.");
+    process.exit(1);
+  }
+
+  // No symptoms — nothing to do
+  if (diagnosis.symptoms.length === 0) {
+    if (isA2A) {
+      console.log(JSON.stringify({ status: "healthy", symptoms: [], healed: [] }));
+    } else {
+      console.log("[afd diagnose] System healthy.");
+    }
+    return;
+  }
+
+  if (!autoHeal) {
+    // Non-auto mode: just report
+    if (isA2A) {
+      console.log(JSON.stringify({
+        status: "symptomatic",
+        symptoms: diagnosis.symptoms.map(s => ({
+          id: s.id,
+          title: s.title,
+          severity: s.severity,
+          patches: s.patches,
+        })),
+      }));
+    } else {
+      for (const s of diagnosis.symptoms) {
+        console.log(`[${s.severity}] ${s.id}: ${s.title}`);
+      }
+    }
+    return;
+  }
+
+  // Auto-heal mode: only apply patches for symptoms that have known antibodies
+  // Query antibodies to see which patterns we've learned before
+  let knownIds: string[];
+  try {
+    const abData = await daemonRequest<{ antibodies: { id: string }[] }>("/antibodies");
+    knownIds = abData.antibodies.map(a => a.id);
+  } catch {
+    if (isA2A) console.log(JSON.stringify({ status: "error", healed: [], skipped: [] }));
+    process.exit(0);
+  }
+
+  const healed: string[] = [];
+  const skipped: string[] = [];
+
+  for (const symptom of diagnosis.symptoms) {
+    // Only auto-heal if we have a known antibody for this pattern
+    if (!knownIds.includes(symptom.id)) {
+      skipped.push(symptom.id);
+      continue;
+    }
+
+    if (symptom.patches.length === 0) {
+      skipped.push(symptom.id);
+      continue;
+    }
+
+    let applied = false;
+    for (const patch of symptom.patches) {
+      if (applyPatch(patch)) applied = true;
+    }
+
+    if (applied) {
+      // Notify daemon of auto-heal event
+      try {
+        await fetch(
+          `http://127.0.0.1:${getDaemonPort()}/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
+      }
+      // Fire OS toast notification (async, non-blocking)
+      notifyAutoHeal(symptom.id);
+      healed.push(symptom.id);
+    } else {
+      skipped.push(symptom.id);
+    }
+  }
+
+  if (isA2A) {
+    console.log(JSON.stringify({ status: healed.length > 0 ? "healed" : "no-action", healed, skipped }));
+  } 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/fix.ts

@@ -0,0 +1,138 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import { daemonRequest } from "../daemon/client";
+import type { Symptom, PatchOp, DiagnosisResult } from "../core/immune";
+
+const SEVERITY_ICON: Record<string, string> = {
+  critical: "[!]",
+  warning: "[~]",
+  info: "[i]",
+};
+
+function applyPatch(patch: PatchOp): boolean {
+  // Map JSON-Patch path to filesystem path (strip leading /)
+  const filePath = patch.path.replace(/^\//, "");
+
+  if (patch.op === "add") {
+    if (existsSync(filePath)) return false; // don't overwrite
+    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;
+  }
+
+  // remove, move, copy, test — not needed yet
+  return false;
+}
+
+async function learnAntibody(symptom: Symptom): Promise<void> {
+  await fetch(
+    `http://127.0.0.1:${(await getDaemonPort())}/antibodies/learn`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id: symptom.id,
+        patternType: symptom.patternType,
+        fileTarget: symptom.fileTarget,
+        patches: symptom.patches,
+      }),
+    }
+  );
+}
+
+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);
+}
+
+export async function fixCommand() {
+  let diagnosis: DiagnosisResult;
+  try {
+    diagnosis = await daemonRequest<DiagnosisResult>("/diagnose");
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[afd fix] ${msg}`);
+    process.exit(1);
+  }
+
+  if (diagnosis.symptoms.length === 0) {
+    console.log("[afd fix] No symptoms detected. System is healthy.");
+    if (diagnosis.healthy.length > 0) {
+      console.log(`[afd fix] Passed checks: ${diagnosis.healthy.join(", ")}`);
+    }
+    return;
+  }
+
+  // Display symptoms
+  console.log(`\n[afd fix] Found ${diagnosis.symptoms.length} symptom(s):\n`);
+
+  for (const s of diagnosis.symptoms) {
+    const icon = SEVERITY_ICON[s.severity] ?? "[?]";
+    console.log(`  ${icon} ${s.id}: ${s.title} (${s.severity})`);
+    console.log(`      ${s.description}`);
+    if (s.patches.length > 0) {
+      console.log(`      Patch: ${s.patches.map(p => `${p.op} ${p.path}`).join(", ")}`);
+    }
+    console.log();
+  }
+
+  // Back-stage: dump full JSON-Patch for AI consumers
+  const allPatches = diagnosis.symptoms.flatMap(s =>
+    s.patches.map(p => ({ symptomId: s.id, ...p }))
+  );
+  console.log("[afd fix] JSON-Patch (back-stage):");
+  console.log(JSON.stringify(allPatches, null, 2));
+  console.log();
+
+  // Prompt user
+  process.stdout.write("Apply these fixes? [Y/n] ");
+  const answer = await readLine();
+
+  if (answer.toLowerCase() === "n") {
+    console.log("[afd fix] Aborted.");
+    return;
+  }
+
+  // Apply patches and learn antibodies
+  let applied = 0;
+  for (const symptom of diagnosis.symptoms) {
+    if (symptom.patches.length === 0) continue;
+    let success = true;
+    for (const patch of symptom.patches) {
+      if (!applyPatch(patch)) {
+        console.log(`  [skip] ${patch.op} ${patch.path} (already exists or unsupported)`);
+        success = false;
+      } else {
+        console.log(`  [done] ${patch.op} ${patch.path}`);
+        applied++;
+      }
+    }
+    if (success) {
+      await learnAntibody(symptom);
+      console.log(`  [immune] Learned antibody: ${symptom.id}`);
+    }
+  }
+
+  console.log(`\n[afd fix] Applied ${applied} patch(es). Immune system updated.`);
+}
+
+function readLine(): Promise<string> {
+  return new Promise((resolve) => {
+    const buf: Buffer[] = [];
+    process.stdin.setEncoding("utf-8");
+    process.stdin.resume();
+    process.stdin.once("data", (chunk: string) => {
+      process.stdin.pause();
+      resolve(chunk.toString().trim());
+    });
+  });
+}

package/src/commands/score.ts

@@ -0,0 +1,148 @@
+import { daemonRequest } from "../daemon/client";
+
+interface HologramScore {
+  requests: number;
+  originalChars: number;
+  hologramChars: number;
+  savings: number;
+}
+
+interface AutoHealEntry {
+  id: string;
+  at: number;
+}
+
+interface ImmuneScore {
+  antibodies: number;
+  autoHealed: number;
+  lastAutoHeal: AutoHealEntry | null;
+}
+
+interface EcosystemEntry {
+  name: string;
+  confidence: string;
+}
+
+interface EcosystemScore {
+  detected: EcosystemEntry[];
+  primary: string;
+}
+
+interface ScoreData {
+  uptime: number;
+  filesDetected: number;
+  totalEvents: number;
+  lastEvent: string | null;
+  lastEventAt: number | null;
+  watchedFiles: string[];
+  watchTargets: string[];
+  hologram: HologramScore;
+  immune: ImmuneScore;
+  ecosystem: EcosystemScore;
+}
+
+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 heatBar(value: number, max: number, width = 20): string {
+  const filled = Math.min(Math.round((value / Math.max(max, 1)) * width), width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+
+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`;
+}
+
+const W = 46; // inner box width
+const line = "\u2500".repeat(W);
+const row = (content: string) => `\u2502${content.padEnd(W)}\u2502`;
+
+export async function scoreCommand() {
+  try {
+    const data = await daemonRequest<ScoreData>("/score");
+    const h = data.hologram;
+
+    console.log(`\u250C${line}\u2510`);
+    console.log(row("  afd score \u2014 Daemon Diagnostics"));
+    console.log(`\u251C${line}\u2524`);
+    console.log(row(`  Ecosystem    : ${data.ecosystem.primary}`));
+    if (data.ecosystem.detected.length > 1) {
+      const others = data.ecosystem.detected.slice(1).map(e => e.name).join(", ");
+      console.log(row(`  Also found   : ${others}`));
+    }
+    console.log(`\u251C${line}\u2524`);
+    console.log(row(`  Uptime       : ${formatUptime(data.uptime)}`));
+    console.log(row(`  Events       : ${data.totalEvents}`));
+    console.log(row(`  Files Found  : ${data.watchedFiles.length}`));
+    console.log(`\u251C${line}\u2524`);
+    console.log(row(`  Activity  ${heatBar(data.totalEvents, 100)}`));
+
+    // Context Efficiency section
+    console.log(`\u251C${line}\u2524`);
+    console.log(row("  Context Efficiency (Hologram)"));
+    console.log(row(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+    if (h.requests > 0) {
+      const saved = h.originalChars - h.hologramChars;
+      console.log(row(`  Requests     : ${h.requests}`));
+      console.log(row(`  Original     : ${formatChars(h.originalChars)} chars`));
+      console.log(row(`  Hologram     : ${formatChars(h.hologramChars)} chars`));
+      console.log(row(`  Saved        : ${formatChars(saved)} chars (${h.savings}%)`));
+      console.log(row(`  Efficiency   ${heatBar(h.savings, 100)}`));
+    } else {
+      console.log(row("  No hologram requests yet."));
+      console.log(row("  Use: GET /hologram?file=<path>"));
+    }
+
+    // Immune System section
+    console.log(`\u251C${line}\u2524`);
+    console.log(row("  Immune System"));
+    console.log(row(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+    const ab = data.immune.antibodies;
+    const ah = data.immune.autoHealed;
+    const immuneLevel = ab === 0 ? "Vulnerable" : ab < 3 ? "Learning" : ab < 6 ? "Guarded" : "Fortified";
+    console.log(row(`  Antibodies   : ${ab}`));
+    console.log(row(`  Level        : ${immuneLevel}`));
+    console.log(row(`  Immunity     ${heatBar(ab, 10)}`));
+    console.log(row(`  Auto-healed  : ${ah} background event${ah !== 1 ? "s" : ""}`));
+    if (data.immune.lastAutoHeal) {
+      const ago = formatUptime(Math.floor((Date.now() - data.immune.lastAutoHeal.at) / 1000));
+      console.log(row(`  Last heal    : ${data.immune.lastAutoHeal.id} (${ago} ago)`));
+    }
+
+    // Watched files
+    console.log(`\u251C${line}\u2524`);
+    if (data.watchedFiles.length > 0) {
+      console.log(row("  Watched Files:"));
+      for (const f of data.watchedFiles.slice(0, 8)) {
+        console.log(row(`    ${f.substring(0, W - 6)}`));
+      }
+      if (data.watchedFiles.length > 8) {
+        console.log(row(`    ... +${data.watchedFiles.length - 8} more`));
+      }
+    } else {
+      console.log(row("  No files detected yet."));
+    }
+
+    if (data.lastEvent) {
+      const ago = data.lastEventAt
+        ? formatUptime(Math.floor((Date.now() - data.lastEventAt) / 1000)) + " ago"
+        : "unknown";
+      console.log(`\u251C${line}\u2524`);
+      console.log(row(`  Last: ${data.lastEvent.substring(0, 36)}`));
+      console.log(row(`        ${ago}`));
+    }
+
+    console.log(`\u2514${line}\u2518`);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[afd] ${msg}`);
+    process.exit(1);
+  }
+}

package/src/commands/start.ts

@@ -0,0 +1,55 @@
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { getDaemonInfo, isDaemonAlive } from "../daemon/client";
+import { AFD_DIR } from "../constants";
+import { mkdirSync } from "fs";
+import { detectEcosystem } from "../adapters/index";
+
+export async function startCommand() {
+  mkdirSync(AFD_DIR, { recursive: true });
+
+  // Check if already running
+  const existing = getDaemonInfo();
+  if (existing && await isDaemonAlive(existing)) {
+    console.log(`[afd] Daemon already running (pid=${existing.pid}, port=${existing.port})`);
+    return;
+  }
+
+  // Spawn detached daemon
+  const daemonScript = resolve(import.meta.dirname, "../daemon/server.ts");
+  const bunPath = process.execPath;
+
+  const child = spawn(bunPath, ["run", daemonScript], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    cwd: process.cwd(),
+    env: { ...process.env },
+  });
+
+  child.unref();
+
+  // Wait for daemon to write its port file (Windows needs more time)
+  await new Promise((r) => setTimeout(r, 1500));
+
+  const info = getDaemonInfo();
+  if (info && await isDaemonAlive(info)) {
+    console.log(`[afd] Daemon started (pid=${info.pid}, port=${info.port})`);
+    console.log(`[afd] Watching: .claude/, CLAUDE.md, .cursorrules`);
+
+    // Silently inject auto-heal hook and status line into detected ecosystem
+    const ecosystems = detectEcosystem(process.cwd());
+    for (const { adapter } of ecosystems) {
+      if (adapter.injectHooks) {
+        const hookResult = adapter.injectHooks(process.cwd());
+        console.log(`[afd] ${hookResult.message}`);
+      }
+      if (adapter.configureStatusLine) {
+        const slResult = adapter.configureStatusLine(process.cwd());
+        if (slResult.configured) console.log(`[afd] ${slResult.message}`);
+      }
+    }
+  } else {
+    console.error("[afd] Failed to start daemon. Check logs.");
+    process.exit(1);
+  }
+}