@c-d-cc/reap 0.1.3 → 0.2.2

package/dist/cli.js

@@ -8840,8 +8840,8 @@ var {
 } = import__.default;
 
 // src/cli/commands/init.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join4 } from "path";
 
 // src/core/paths.ts
 import { join, dirname } from "path";
@@ -9001,167 +9001,408 @@ class ConfigManager {
   }
 }
 
-// src/core/hooks.ts
+// src/core/agents/claude-code.ts
 import { join as join2 } from "path";
-import { mkdir, unlink } from "fs/promises";
-function getReapHookEntry() {
-  const sessionStartPath = join2(ReapPaths.packageHooksDir, "session-start.sh");
-  return {
-    matcher: "",
-    hooks: [
-      {
-        type: "command",
-        command: `bash "${sessionStartPath}"`
-      }
-    ]
-  };
-}
-async function readSettingsJson() {
-  const fileContent = await readTextFile(ReapPaths.userClaudeSettingsJson);
-  if (fileContent === null)
-    return {};
-  try {
-    return JSON.parse(fileContent);
-  } catch {
-    return {};
+import { homedir as homedir2 } from "os";
+import { mkdir, readdir, unlink } from "fs/promises";
+class ClaudeCodeAdapter {
+  name = "claude-code";
+  displayName = "Claude Code";
+  get userDir() {
+    return join2(homedir2(), ".claude");
   }
-}
-async function writeSettingsJson(settings) {
-  await mkdir(ReapPaths.userClaudeDir, { recursive: true });
-  await writeTextFile(ReapPaths.userClaudeSettingsJson, JSON.stringify(settings, null, 2) + `
-`);
-}
-function hasReapHookInArray(sessionStartHooks) {
-  return sessionStartHooks.some((entry) => {
-    if (typeof entry !== "object" || entry === null)
-      return false;
-    const hooks = entry["hooks"];
-    if (!Array.isArray(hooks))
+  get commandsDir() {
+    return join2(this.userDir, "commands");
+  }
+  get settingsPath() {
+    return join2(this.userDir, "settings.json");
+  }
+  get hooksJsonPath() {
+    return join2(this.userDir, "hooks.json");
+  }
+  async detect() {
+    try {
+      const { execSync } = await import("child_process");
+      execSync("which claude", { stdio: "ignore" });
+      return true;
+    } catch {
       return false;
-    return hooks.some((h) => {
-      if (typeof h !== "object" || h === null)
-        return false;
-      const cmd = h["command"];
-      return typeof cmd === "string" && cmd.includes("session-start");
-    });
-  });
-}
-async function registerClaudeHook(dryRun = false) {
-  await mkdir(ReapPaths.userClaudeDir, { recursive: true });
-  const settings = await readSettingsJson();
-  const hooks = settings["hooks"] ?? {};
-  const sessionStartHooks = hooks["SessionStart"] ?? [];
-  if (Array.isArray(sessionStartHooks) && hasReapHookInArray(sessionStartHooks)) {
-    return { action: "skipped" };
-  }
-  const hadHooksSection = "hooks" in settings;
-  settings["hooks"] = {
-    ...hooks,
-    SessionStart: [
-      ...Array.isArray(sessionStartHooks) ? sessionStartHooks : [],
-      getReapHookEntry()
-    ]
-  };
-  if (!dryRun) {
-    await writeSettingsJson(settings);
+    }
   }
-  return { action: hadHooksSection ? "updated" : "created" };
-}
-async function syncHookRegistration(dryRun = false) {
-  const settings = await readSettingsJson();
-  const hooks = settings["hooks"] ?? {};
-  const sessionStartHooks = hooks["SessionStart"] ?? [];
-  if (!Array.isArray(sessionStartHooks) || !hasReapHookInArray(sessionStartHooks)) {
-    await registerClaudeHook(dryRun);
-    return { action: "updated" };
-  }
-  const expectedEntry = getReapHookEntry();
-  let changed = false;
-  const updated = sessionStartHooks.map((entry) => {
-    if (typeof entry !== "object" || entry === null)
-      return entry;
-    const entryHooks = entry["hooks"];
-    if (!Array.isArray(entryHooks))
+  getCommandsDir() {
+    return this.commandsDir;
+  }
+  async installCommands(commandNames, sourceDir) {
+    await mkdir(this.commandsDir, { recursive: true });
+    for (const cmd of commandNames) {
+      const src = join2(sourceDir, `${cmd}.md`);
+      const dest = join2(this.commandsDir, `${cmd}.md`);
+      await writeTextFile(dest, await readTextFileOrThrow(src));
+    }
+  }
+  async removeStaleCommands(validNames) {
+    try {
+      const existing = await readdir(this.commandsDir);
+      for (const file of existing) {
+        if (!file.startsWith("reap.") || !file.endsWith(".md"))
+          continue;
+        if (!validNames.has(file)) {
+          await unlink(join2(this.commandsDir, file));
+        }
+      }
+    } catch {}
+  }
+  async registerSessionHook(dryRun = false) {
+    await mkdir(this.userDir, { recursive: true });
+    const settings = await this.readSettings();
+    const hooks = settings["hooks"] ?? {};
+    const sessionStartHooks = hooks["SessionStart"] ?? [];
+    if (Array.isArray(sessionStartHooks) && this.hasReapHook(sessionStartHooks)) {
+      return { action: "skipped" };
+    }
+    const hadHooksSection = "hooks" in settings;
+    settings["hooks"] = {
+      ...hooks,
+      SessionStart: [
+        ...Array.isArray(sessionStartHooks) ? sessionStartHooks : [],
+        this.getHookEntry()
+      ]
+    };
+    if (!dryRun) {
+      await this.writeSettings(settings);
+    }
+    return { action: hadHooksSection ? "updated" : "created" };
+  }
+  async syncSessionHook(dryRun = false) {
+    const settings = await this.readSettings();
+    const hooks = settings["hooks"] ?? {};
+    const sessionStartHooks = hooks["SessionStart"] ?? [];
+    if (!Array.isArray(sessionStartHooks) || !this.hasReapHook(sessionStartHooks)) {
+      await this.registerSessionHook(dryRun);
+      return { action: "updated" };
+    }
+    const expectedEntry = this.getHookEntry();
+    let changed = false;
+    const updated = sessionStartHooks.map((entry) => {
+      if (typeof entry !== "object" || entry === null)
+        return entry;
+      const entryHooks = entry["hooks"];
+      if (!Array.isArray(entryHooks))
+        return entry;
+      const isReap = entryHooks.some((h) => {
+        if (typeof h !== "object" || h === null)
+          return false;
+        const cmd = h["command"];
+        return typeof cmd === "string" && cmd.includes("session-start");
+      });
+      if (isReap) {
+        if (JSON.stringify(entry) !== JSON.stringify(expectedEntry)) {
+          changed = true;
+          return expectedEntry;
+        }
+      }
       return entry;
-    const isReap = entryHooks.some((h) => {
-      if (typeof h !== "object" || h === null)
-        return false;
-      const cmd = h["command"];
-      return typeof cmd === "string" && cmd.includes("session-start");
     });
-    if (isReap) {
-      const currentJson = JSON.stringify(entry);
-      const expectedJson = JSON.stringify(expectedEntry);
-      if (currentJson !== expectedJson) {
-        changed = true;
-        return expectedEntry;
-      }
+    if (changed && !dryRun) {
+      settings["hooks"] = { ...hooks, SessionStart: updated };
+      await this.writeSettings(settings);
     }
-    return entry;
-  });
-  if (changed && !dryRun) {
-    settings["hooks"] = { ...hooks, SessionStart: updated };
-    await writeSettingsJson(settings);
+    return { action: changed ? "updated" : "skipped" };
   }
-  return { action: changed ? "updated" : "skipped" };
-}
-async function migrateHooksJsonToSettings(dryRun = false) {
-  const hooksJsonPath = ReapPaths.userClaudeHooksJson;
-  const fileContent = await readTextFile(hooksJsonPath);
-  if (fileContent === null)
-    return { action: "skipped" };
-  let hooksJson;
-  try {
-    hooksJson = JSON.parse(fileContent);
-  } catch {
-    return { action: "skipped" };
+  async readLanguage() {
+    const content = await readTextFile(this.settingsPath);
+    if (!content)
+      return null;
+    try {
+      const settings = JSON.parse(content);
+      return settings.language ?? null;
+    } catch {
+      return null;
+    }
   }
-  const sessionStartHooks = hooksJson["SessionStart"];
-  if (!Array.isArray(sessionStartHooks))
-    return { action: "skipped" };
-  const reapEntries = sessionStartHooks.filter((entry) => {
-    if (typeof entry !== "object" || entry === null)
-      return false;
-    const hooks = entry["hooks"];
-    if (!Array.isArray(hooks))
-      return false;
-    return hooks.some((h) => {
-      if (typeof h !== "object" || h === null)
+  async migrate(dryRun = false) {
+    const fileContent = await readTextFile(this.hooksJsonPath);
+    if (fileContent === null)
+      return { action: "skipped" };
+    let hooksJson;
+    try {
+      hooksJson = JSON.parse(fileContent);
+    } catch {
+      return { action: "skipped" };
+    }
+    const sessionStartHooks = hooksJson["SessionStart"];
+    if (!Array.isArray(sessionStartHooks))
+      return { action: "skipped" };
+    const reapEntries = sessionStartHooks.filter((entry) => {
+      if (typeof entry !== "object" || entry === null)
         return false;
-      const cmd = h["command"];
-      return typeof cmd === "string" && cmd.includes("session-start");
+      const hooks = entry["hooks"];
+      if (!Array.isArray(hooks))
+        return false;
+      return hooks.some((h) => {
+        if (typeof h !== "object" || h === null)
+          return false;
+        const cmd = h["command"];
+        return typeof cmd === "string" && cmd.includes("session-start");
+      });
     });
-  });
-  if (reapEntries.length === 0)
-    return { action: "skipped" };
-  if (!dryRun) {
-    await registerClaudeHook(false);
-    const filtered = sessionStartHooks.filter((entry) => {
+    if (reapEntries.length === 0)
+      return { action: "skipped" };
+    if (!dryRun) {
+      await this.registerSessionHook(false);
+      const filtered = sessionStartHooks.filter((entry) => {
+        if (typeof entry !== "object" || entry === null)
+          return true;
+        const hooks = entry["hooks"];
+        if (!Array.isArray(hooks))
+          return true;
+        return !hooks.some((h) => {
+          if (typeof h !== "object" || h === null)
+            return false;
+          const cmd = h["command"];
+          return typeof cmd === "string" && cmd.includes("session-start");
+        });
+      });
+      if (filtered.length === 0) {
+        delete hooksJson["SessionStart"];
+      } else {
+        hooksJson["SessionStart"] = filtered;
+      }
+      if (Object.keys(hooksJson).length === 0) {
+        await unlink(this.hooksJsonPath);
+      } else {
+        await writeTextFile(this.hooksJsonPath, JSON.stringify(hooksJson, null, 2) + `
+`);
+      }
+    }
+    return { action: "migrated" };
+  }
+  getHookEntry() {
+    const sessionStartPath = join2(ReapPaths.packageHooksDir, "session-start.sh");
+    return {
+      matcher: "",
+      hooks: [{ type: "command", command: `bash "${sessionStartPath}"` }]
+    };
+  }
+  hasReapHook(sessionStartHooks) {
+    return sessionStartHooks.some((entry) => {
       if (typeof entry !== "object" || entry === null)
-        return true;
+        return false;
       const hooks = entry["hooks"];
       if (!Array.isArray(hooks))
-        return true;
-      return !hooks.some((h) => {
+        return false;
+      return hooks.some((h) => {
         if (typeof h !== "object" || h === null)
           return false;
         const cmd = h["command"];
         return typeof cmd === "string" && cmd.includes("session-start");
       });
     });
-    if (filtered.length === 0) {
-      delete hooksJson["SessionStart"];
-    } else {
-      hooksJson["SessionStart"] = filtered;
+  }
+  async readSettings() {
+    const content = await readTextFile(this.settingsPath);
+    if (content === null)
+      return {};
+    try {
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  async writeSettings(settings) {
+    await mkdir(this.userDir, { recursive: true });
+    await writeTextFile(this.settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+  }
+}
+
+// src/core/agents/opencode.ts
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { mkdir as mkdir2, readdir as readdir2, unlink as unlink2 } from "fs/promises";
+var OPENCODE_STATE_DIR = join3(homedir3(), ".local", "state", "opencode");
+
+class OpenCodeAdapter {
+  name = "opencode";
+  displayName = "OpenCode";
+  get configDir() {
+    return join3(homedir3(), ".config", "opencode");
+  }
+  get commandsDir() {
+    return join3(this.configDir, "commands");
+  }
+  get pluginsDir() {
+    return join3(this.configDir, "plugins");
+  }
+  get settingsPath() {
+    return join3(this.configDir, "opencode.json");
+  }
+  get tuiConfigPath() {
+    return join3(this.configDir, "tui.json");
+  }
+  async detect() {
+    try {
+      const { execSync } = await import("child_process");
+      execSync("which opencode", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCommandsDir() {
+    return this.commandsDir;
+  }
+  async installCommands(commandNames, sourceDir) {
+    await mkdir2(this.commandsDir, { recursive: true });
+    for (const cmd of commandNames) {
+      const src = join3(sourceDir, `${cmd}.md`);
+      const dest = join3(this.commandsDir, `${cmd}.md`);
+      await writeTextFile(dest, await readTextFileOrThrow(src));
     }
-    if (Object.keys(hooksJson).length === 0) {
-      await unlink(hooksJsonPath);
+  }
+  async removeStaleCommands(validNames) {
+    try {
+      const existing = await readdir2(this.commandsDir);
+      for (const file of existing) {
+        if (!file.startsWith("reap.") || !file.endsWith(".md"))
+          continue;
+        if (!validNames.has(file)) {
+          await unlink2(join3(this.commandsDir, file));
+        }
+      }
+    } catch {}
+  }
+  async registerSessionHook(dryRun = false) {
+    const pluginPath = join3(this.pluginsDir, "reap-session-start.js");
+    const exists = await fileExists(pluginPath);
+    let pluginAction = "skipped";
+    if (exists) {
+      const current = await readTextFile(pluginPath);
+      const expected = await this.getPluginContent();
+      if (current !== expected) {
+        if (!dryRun)
+          await writeTextFile(pluginPath, expected);
+        pluginAction = "updated";
+      }
     } else {
-      await writeTextFile(hooksJsonPath, JSON.stringify(hooksJson, null, 2) + `
+      if (!dryRun) {
+        await mkdir2(this.pluginsDir, { recursive: true });
+        await writeTextFile(pluginPath, await this.getPluginContent());
+      }
+      pluginAction = "created";
+    }
+    if (!dryRun) {
+      await this.ensureTuiConfig();
+      await this.ensureDefaultVisibility();
+    }
+    return { action: pluginAction };
+  }
+  async syncSessionHook(dryRun = false) {
+    const result = await this.registerSessionHook(dryRun);
+    return { action: result.action === "skipped" ? "skipped" : "updated" };
+  }
+  async readLanguage() {
+    const content = await readTextFile(this.settingsPath);
+    if (!content)
+      return null;
+    try {
+      const settings = JSON.parse(content);
+      return settings.language ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getPluginContent() {
+    const templatePath = join3(ReapPaths.packageHooksDir, "opencode-session-start.js");
+    return readTextFileOrThrow(templatePath);
+  }
+  async ensureDefaultVisibility() {
+    const kvPath = join3(OPENCODE_STATE_DIR, "kv.json");
+    await mkdir2(OPENCODE_STATE_DIR, { recursive: true });
+    let kv = {};
+    const existing = await readTextFile(kvPath);
+    if (existing) {
+      try {
+        kv = JSON.parse(existing);
+      } catch {}
+    }
+    let changed = false;
+    if (kv["tool_details_visibility"] === undefined) {
+      kv["tool_details_visibility"] = false;
+      changed = true;
+    }
+    if (changed) {
+      await writeTextFile(kvPath, JSON.stringify(kv, null, 2) + `
+`);
+    }
+  }
+  async ensureTuiConfig() {
+    await mkdir2(this.configDir, { recursive: true });
+    const reapKeybinds = {
+      display_thinking: "<leader>t",
+      tool_details: "<leader>d"
+    };
+    let config = {};
+    const existing = await readTextFile(this.tuiConfigPath);
+    if (existing) {
+      try {
+        config = JSON.parse(existing);
+      } catch {}
+    }
+    const keybinds = config["keybinds"] ?? {};
+    let changed = false;
+    for (const [key, value] of Object.entries(reapKeybinds)) {
+      if (!keybinds[key] || keybinds[key] === "none") {
+        keybinds[key] = value;
+        changed = true;
+      }
+    }
+    if (changed) {
+      config["keybinds"] = keybinds;
+      if (!config["$schema"]) {
+        config = { $schema: "https://opencode.ai/tui.json", ...config };
+      }
+      await writeTextFile(this.tuiConfigPath, JSON.stringify(config, null, 2) + `
 `);
     }
   }
-  return { action: "migrated" };
+}
+
+// src/core/agents/index.ts
+var ALL_ADAPTERS = [
+  new ClaudeCodeAdapter,
+  new OpenCodeAdapter
+];
+
+class AgentRegistry {
+  static allAdapters() {
+    return ALL_ADAPTERS;
+  }
+  static getAdapter(name) {
+    return ALL_ADAPTERS.find((a) => a.name === name);
+  }
+  static async detectInstalled() {
+    const results = await Promise.all(ALL_ADAPTERS.map(async (adapter) => ({
+      adapter,
+      installed: await adapter.detect()
+    })));
+    return results.filter((r) => r.installed).map((r) => r.adapter);
+  }
+  static async getActiveAdapters(config) {
+    if (config?.agents && config.agents.length > 0) {
+      return config.agents.map((name) => AgentRegistry.getAdapter(name)).filter((a) => a !== undefined);
+    }
+    return AgentRegistry.detectInstalled();
+  }
+  static async readLanguage(adapters) {
+    const list = adapters ?? ALL_ADAPTERS;
+    for (const adapter of list) {
+      const lang = await adapter.readLanguage();
+      if (lang)
+        return lang;
+    }
+    return null;
+  }
 }
 
 // src/cli/commands/init.ts
@@ -9177,26 +9418,30 @@ var COMMAND_NAMES = [
   "reap.back",
   "reap.status",
   "reap.sync",
-  "reap.help"
+  "reap.help",
+  "reap.update"
 ];
-async function initProject(projectRoot, projectName, entryMode, preset) {
+async function initProject(projectRoot, projectName, entryMode, preset, onProgress) {
+  const log = onProgress ?? (() => {});
   const paths = new ReapPaths(projectRoot);
   if (await paths.isReapProject()) {
     throw new Error(".reap/ already exists. This is already a REAP project.");
   }
   if (preset) {
-    const presetDir = join3(ReapPaths.packageTemplatesDir, "presets", preset);
-    const presetExists = await fileExists(join3(presetDir, "principles.md"));
+    const presetDir = join4(ReapPaths.packageTemplatesDir, "presets", preset);
+    const presetExists = await fileExists(join4(presetDir, "principles.md"));
     if (!presetExists) {
       throw new Error(`Unknown preset: "${preset}". Available presets: bun-hono-react`);
     }
   }
-  await mkdir2(paths.genome, { recursive: true });
-  await mkdir2(paths.domain, { recursive: true });
-  await mkdir2(paths.environment, { recursive: true });
-  await mkdir2(paths.life, { recursive: true });
-  await mkdir2(paths.backlog, { recursive: true });
-  await mkdir2(paths.lineage, { recursive: true });
+  log("Creating .reap/ directory structure...");
+  await mkdir3(paths.genome, { recursive: true });
+  await mkdir3(paths.domain, { recursive: true });
+  await mkdir3(paths.environment, { recursive: true });
+  await mkdir3(paths.life, { recursive: true });
+  await mkdir3(paths.backlog, { recursive: true });
+  await mkdir3(paths.lineage, { recursive: true });
+  log("Writing config.yml...");
   const config = {
     version: "0.1.0",
     project: projectName,
@@ -9204,76 +9449,97 @@ async function initProject(projectRoot, projectName, entryMode, preset) {
     ...preset && { preset }
   };
   await ConfigManager.write(paths, config);
+  log("Setting up Genome templates...");
   const genomeTemplates = ["principles.md", "conventions.md", "constraints.md"];
-  const genomeSourceDir = preset ? join3(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
+  const genomeSourceDir = preset ? join4(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
   for (const file of genomeTemplates) {
-    const src = join3(genomeSourceDir, file);
-    const dest = join3(paths.genome, file);
+    const src = join4(genomeSourceDir, file);
+    const dest = join4(paths.genome, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
-  await mkdir2(ReapPaths.userReapTemplates, { recursive: true });
+  log("Installing artifact templates...");
+  await mkdir3(ReapPaths.userReapTemplates, { recursive: true });
   const artifactFiles = ["01-objective.md", "02-planning.md", "03-implementation.md", "04-validation.md", "05-completion.md"];
   for (const file of artifactFiles) {
-    const src = join3(ReapPaths.packageArtifactsDir, file);
-    const dest = join3(ReapPaths.userReapTemplates, file);
+    const src = join4(ReapPaths.packageArtifactsDir, file);
+    const dest = join4(ReapPaths.userReapTemplates, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
-  const domainGuideSrc = join3(ReapPaths.packageGenomeDir, "domain/README.md");
-  const domainGuideDest = join3(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = join4(ReapPaths.packageGenomeDir, "domain/README.md");
+  const domainGuideDest = join4(ReapPaths.userReapTemplates, "domain-guide.md");
   await writeTextFile(domainGuideDest, await readTextFileOrThrow(domainGuideSrc));
-  await mkdir2(ReapPaths.userClaudeCommands, { recursive: true });
-  for (const cmd of COMMAND_NAMES) {
-    const src = join3(ReapPaths.packageCommandsDir, `${cmd}.md`);
-    const dest = join3(ReapPaths.userClaudeCommands, `${cmd}.md`);
-    await writeTextFile(dest, await readTextFileOrThrow(src));
+  log("Detecting AI agents...");
+  const detectedAgents = await AgentRegistry.detectInstalled();
+  const sourceDir = ReapPaths.packageCommandsDir;
+  for (const adapter of detectedAgents) {
+    log(`  Installing commands for ${adapter.displayName}...`);
+    await adapter.installCommands(COMMAND_NAMES, sourceDir);
+    log(`  Registering session hook for ${adapter.displayName}...`);
+    await adapter.registerSessionHook();
+  }
+  if (detectedAgents.length === 0) {
+    log("  No AI agents detected.");
+  }
+  return { agents: detectedAgents.map((a) => a.displayName) };
+}
+
+// src/cli/commands/update.ts
+import { readdir as readdir3, unlink as unlink3, rm, mkdir as mkdir4 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/core/hooks.ts
+async function migrateHooks(dryRun = false) {
+  const adapters = AgentRegistry.allAdapters();
+  const results = [];
+  for (const adapter of adapters) {
+    if (adapter.migrate) {
+      const result = await adapter.migrate(dryRun);
+      results.push({ agent: adapter.displayName, action: result.action });
+    }
   }
-  await registerClaudeHook();
+  return { results };
 }
 
 // src/cli/commands/update.ts
-import { readdir, unlink as unlink2, rm, mkdir as mkdir3 } from "fs/promises";
-import { join as join4 } from "path";
 async function updateProject(projectRoot, dryRun = false) {
   const paths = new ReapPaths(projectRoot);
   if (!await paths.isReapProject()) {
     throw new Error("Not a REAP project. Run 'reap init' first.");
   }
   const result = { updated: [], skipped: [], removed: [] };
-  await mkdir3(ReapPaths.userClaudeCommands, { recursive: true });
+  const config = await ConfigManager.read(paths);
+  const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
   const commandsDir = ReapPaths.packageCommandsDir;
-  const commandFiles = await readdir(commandsDir);
-  for (const file of commandFiles) {
-    if (!file.endsWith(".md"))
-      continue;
-    const src = await readTextFileOrThrow(join4(commandsDir, file));
-    const dest = join4(ReapPaths.userClaudeCommands, file);
-    const existingContent = await readTextFile(dest);
-    if (existingContent !== null && existingContent === src) {
-      result.skipped.push(`~/.claude/commands/${file}`);
-    } else {
-      if (!dryRun)
-        await writeTextFile(dest, src);
-      result.updated.push(`~/.claude/commands/${file}`);
-    }
-  }
-  const validCommandFiles = new Set(commandFiles);
-  try {
-    const existing = await readdir(ReapPaths.userClaudeCommands);
-    for (const file of existing) {
-      if (!file.startsWith("reap.") || !file.endsWith(".md"))
+  const commandFiles = await readdir3(commandsDir);
+  for (const adapter of adapters) {
+    const agentCmdDir = adapter.getCommandsDir();
+    const label = `${adapter.displayName}`;
+    for (const file of commandFiles) {
+      if (!file.endsWith(".md"))
         continue;
-      if (!validCommandFiles.has(file)) {
-        if (!dryRun)
-          await unlink2(join4(ReapPaths.userClaudeCommands, file));
-        result.removed.push(`~/.claude/commands/${file}`);
+      const src = await readTextFileOrThrow(join5(commandsDir, file));
+      const dest = join5(agentCmdDir, file);
+      const existingContent = await readTextFile(dest);
+      if (existingContent !== null && existingContent === src) {
+        result.skipped.push(`[${label}] commands/${file}`);
+      } else {
+        if (!dryRun) {
+          await mkdir4(agentCmdDir, { recursive: true });
+          await writeTextFile(dest, src);
+        }
+        result.updated.push(`[${label}] commands/${file}`);
       }
     }
-  } catch {}
-  await mkdir3(ReapPaths.userReapTemplates, { recursive: true });
+    const validCommandFiles = new Set(commandFiles);
+    if (!dryRun) {
+      await adapter.removeStaleCommands(validCommandFiles);
+    }
+  }
+  await mkdir4(ReapPaths.userReapTemplates, { recursive: true });
   const artifactFiles = ["01-objective.md", "02-planning.md", "03-implementation.md", "04-validation.md", "05-completion.md"];
   for (const file of artifactFiles) {
-    const src = await readTextFileOrThrow(join4(ReapPaths.packageArtifactsDir, file));
-    const dest = join4(ReapPaths.userReapTemplates, file);
+    const src = await readTextFileOrThrow(join5(ReapPaths.packageArtifactsDir, file));
+    const dest = join5(ReapPaths.userReapTemplates, file);
     const existingContent = await readTextFile(dest);
     if (existingContent !== null && existingContent === src) {
       result.skipped.push(`~/.reap/templates/${file}`);
@@ -9283,8 +9549,8 @@ async function updateProject(projectRoot, dryRun = false) {
       result.updated.push(`~/.reap/templates/${file}`);
     }
   }
-  const domainGuideSrc = await readTextFileOrThrow(join4(ReapPaths.packageGenomeDir, "domain/README.md"));
-  const domainGuideDest = join4(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = await readTextFileOrThrow(join5(ReapPaths.packageGenomeDir, "domain/README.md"));
+  const domainGuideDest = join5(ReapPaths.userReapTemplates, "domain-guide.md");
   const domainExistingContent = await readTextFile(domainGuideDest);
   if (domainExistingContent !== null && domainExistingContent === domainGuideSrc) {
     result.skipped.push(`~/.reap/templates/domain-guide.md`);
@@ -9293,15 +9559,19 @@ async function updateProject(projectRoot, dryRun = false) {
       await writeTextFile(domainGuideDest, domainGuideSrc);
     result.updated.push(`~/.reap/templates/domain-guide.md`);
   }
-  const migration = await migrateHooksJsonToSettings(dryRun);
-  if (migration.action === "migrated") {
-    result.updated.push(`~/.claude/settings.json (migrated from hooks.json)`);
+  const migrations = await migrateHooks(dryRun);
+  for (const m of migrations.results) {
+    if (m.action === "migrated") {
+      result.updated.push(`[${m.agent}] hooks (migrated)`);
+    }
   }
-  const hookReg = await syncHookRegistration(dryRun);
-  if (hookReg.action === "updated") {
-    result.updated.push(`~/.claude/settings.json (hooks)`);
-  } else {
-    result.skipped.push(`~/.claude/settings.json (hooks)`);
+  for (const adapter of adapters) {
+    const hookResult = await adapter.syncSessionHook(dryRun);
+    if (hookResult.action === "updated") {
+      result.updated.push(`[${adapter.displayName}] session hook`);
+    } else {
+      result.skipped.push(`[${adapter.displayName}] session hook`);
+    }
   }
   await migrateLegacyFiles(paths, dryRun, result);
   return result;
@@ -9312,11 +9582,11 @@ async function migrateLegacyFiles(paths, dryRun, result) {
   await removeDirIfExists(paths.legacyHooks, ".reap/hooks/", dryRun, result);
   try {
     const claudeCmdDir = paths.legacyClaudeCommands;
-    const files = await readdir(claudeCmdDir);
+    const files = await readdir3(claudeCmdDir);
     for (const file of files) {
       if (file.startsWith("reap.") && file.endsWith(".md")) {
         if (!dryRun)
-          await unlink2(join4(claudeCmdDir, file));
+          await unlink3(join5(claudeCmdDir, file));
         result.removed.push(`.claude/commands/${file}`);
       }
     }
@@ -9344,7 +9614,7 @@ async function migrateLegacyFiles(paths, dryRun, result) {
         if (filtered.length !== sessionStart.length) {
           if (!dryRun) {
             if (filtered.length === 0 && Object.keys(content).length === 1) {
-              await unlink2(legacyHooksJson);
+              await unlink3(legacyHooksJson);
               result.removed.push(`.claude/hooks.json (legacy)`);
             } else {
               content["SessionStart"] = filtered;
@@ -9360,7 +9630,7 @@ async function migrateLegacyFiles(paths, dryRun, result) {
 }
 async function removeDirIfExists(dirPath, label, dryRun, result) {
   try {
-    const entries = await readdir(dirPath);
+    const entries = await readdir3(dirPath);
     if (entries.length > 0 || true) {
       if (!dryRun)
         await rm(dirPath, { recursive: true });
@@ -9371,8 +9641,8 @@ async function removeDirIfExists(dirPath, label, dryRun, result) {
 
 // src/core/generation.ts
 var import_yaml2 = __toESM(require_dist(), 1);
-import { readdir as readdir3, mkdir as mkdir4, rename } from "fs/promises";
-import { join as join6 } from "path";
+import { readdir as readdir5, mkdir as mkdir5, rename } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/types/index.ts
 var LIFECYCLE_ORDER = [
@@ -9426,8 +9696,8 @@ class LifeCycle {
 }
 
 // src/core/compression.ts
-import { readdir as readdir2, rm as rm2 } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir4, rm as rm2 } from "fs/promises";
+import { join as join6 } from "path";
 var LINEAGE_MAX_LINES = 1e4;
 var MIN_GENERATIONS_FOR_COMPRESSION = 5;
 var LEVEL1_MAX_LINES = 40;
@@ -9443,9 +9713,9 @@ async function countLines(filePath) {
 async function countDirLines(dirPath) {
   let total = 0;
   try {
-    const entries = await readdir2(dirPath, { withFileTypes: true });
+    const entries = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join5(dirPath, entry.name);
+      const fullPath = join6(dirPath, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         total += await countLines(fullPath);
       } else if (entry.isDirectory()) {
@@ -9458,9 +9728,9 @@ async function countDirLines(dirPath) {
 async function scanLineage(paths) {
   const entries = [];
   try {
-    const items = await readdir2(paths.lineage, { withFileTypes: true });
+    const items = await readdir4(paths.lineage, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = join5(paths.lineage, item.name);
+      const fullPath = join6(paths.lineage, item.name);
       if (item.isDirectory() && item.name.startsWith("gen-")) {
         const genNum = parseInt(item.name.replace("gen-", ""), 10);
         const lines = await countDirLines(fullPath);
@@ -9481,7 +9751,7 @@ async function compressLevel1(genDir, genName) {
   const lines = [];
   let goal = "", completionConditions = "";
   {
-    const objective = await readTextFile(join5(genDir, "01-objective.md"));
+    const objective = await readTextFile(join6(genDir, "01-objective.md"));
     if (objective) {
       const goalMatch = objective.match(/## Goal\n([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -9493,7 +9763,7 @@ async function compressLevel1(genDir, genName) {
   }
   let lessons = "", genomeChanges = "", nextBacklog = "";
   {
-    const completion = await readTextFile(join5(genDir, "05-completion.md"));
+    const completion = await readTextFile(join6(genDir, "05-completion.md"));
     if (completion) {
       const lessonsMatch = completion.match(/### Lessons Learned\n([\s\S]*?)(?=\n###)/);
       if (lessonsMatch)
@@ -9508,7 +9778,7 @@ async function compressLevel1(genDir, genName) {
   }
   let metadata = "";
   {
-    const completion = await readTextFile(join5(genDir, "05-completion.md"));
+    const completion = await readTextFile(join6(genDir, "05-completion.md"));
     if (completion) {
       const summaryMatch = completion.match(/## Summary\n([\s\S]*?)(?=\n##)/);
       if (summaryMatch)
@@ -9517,7 +9787,7 @@ async function compressLevel1(genDir, genName) {
   }
   let validationResult = "";
   {
-    const validation = await readTextFile(join5(genDir, "04-validation.md"));
+    const validation = await readTextFile(join6(genDir, "04-validation.md"));
     if (validation) {
       const resultMatch = validation.match(/## Result: (.+)/);
       if (resultMatch)
@@ -9526,7 +9796,7 @@ async function compressLevel1(genDir, genName) {
   }
   let deferred = "";
   {
-    const impl = await readTextFile(join5(genDir, "03-implementation.md"));
+    const impl = await readTextFile(join6(genDir, "03-implementation.md"));
     if (impl) {
       const deferredMatch = impl.match(/## Deferred Tasks\n([\s\S]*?)(?=\n##)/);
       if (deferredMatch) {
@@ -9646,10 +9916,10 @@ async function compressLineageIfNeeded(paths) {
     const currentTotal = await countDirLines(paths.lineage);
     if (currentTotal <= LINEAGE_MAX_LINES)
       break;
-    const dirPath = join5(paths.lineage, dir.name);
+    const dirPath = join6(paths.lineage, dir.name);
     const compressed = await compressLevel1(dirPath, dir.name);
     const genId = dir.name.match(/^gen-\d+/)?.[0] ?? dir.name;
-    const outPath = join5(paths.lineage, `${genId}.md`);
+    const outPath = join6(paths.lineage, `${genId}.md`);
     await writeTextFile(outPath, compressed);
     await rm2(dirPath, { recursive: true });
     result.level1.push(genId);
@@ -9663,10 +9933,10 @@ async function compressLineageIfNeeded(paths) {
       const batch = level1s.slice(i * LEVEL2_BATCH_SIZE, (i + 1) * LEVEL2_BATCH_SIZE);
       const files = batch.map((e) => ({
         name: e.name,
-        path: join5(paths.lineage, e.name)
+        path: join6(paths.lineage, e.name)
       }));
       const compressed = await compressLevel2(files, epochNum);
-      const outPath = join5(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
+      const outPath = join6(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
       await writeTextFile(outPath, compressed);
       for (const file of files) {
         await rm2(file.path);
@@ -9727,28 +9997,28 @@ class GenerationManager {
     const goalSlug = state.goal.toLowerCase().replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
     const genDirName = `${state.id}-${goalSlug}`;
     const genDir = this.paths.generationDir(genDirName);
-    await mkdir4(genDir, { recursive: true });
-    const lifeEntries = await readdir3(this.paths.life);
+    await mkdir5(genDir, { recursive: true });
+    const lifeEntries = await readdir5(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        await rename(join6(this.paths.life, entry), join6(genDir, entry));
+        await rename(join7(this.paths.life, entry), join7(genDir, entry));
       }
     }
-    const backlogDir = join6(genDir, "backlog");
-    await mkdir4(backlogDir, { recursive: true });
+    const backlogDir = join7(genDir, "backlog");
+    await mkdir5(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir3(this.paths.backlog);
+      const backlogEntries = await readdir5(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename(join6(this.paths.backlog, entry), join6(backlogDir, entry));
+        await rename(join7(this.paths.backlog, entry), join7(backlogDir, entry));
       }
     } catch {}
     try {
-      const mutEntries = await readdir3(this.paths.mutations);
+      const mutEntries = await readdir5(this.paths.mutations);
       if (mutEntries.length > 0) {
-        const mutDir = join6(genDir, "mutations");
-        await mkdir4(mutDir, { recursive: true });
+        const mutDir = join7(genDir, "mutations");
+        await mkdir5(mutDir, { recursive: true });
         for (const entry of mutEntries) {
-          await rename(join6(this.paths.mutations, entry), join6(mutDir, entry));
+          await rename(join7(this.paths.mutations, entry), join7(mutDir, entry));
         }
       }
     } catch {}
@@ -9761,7 +10031,7 @@ class GenerationManager {
   }
   async listCompleted() {
     try {
-      const entries = await readdir3(this.paths.lineage);
+      const entries = await readdir5(this.paths.lineage);
       return entries.filter((e) => e.startsWith("gen-")).sort();
     } catch {
       return [];
@@ -9806,7 +10076,7 @@ async function getStatus(projectRoot) {
 
 // src/cli/commands/fix.ts
 var import_yaml3 = __toESM(require_dist(), 1);
-import { mkdir as mkdir5, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir6, stat as stat2 } from "fs/promises";
 async function dirExists(path) {
   try {
     const s = await stat2(path);
@@ -9829,7 +10099,7 @@ async function fixProject(projectRoot) {
   ];
   for (const dir of requiredDirs) {
     if (!await dirExists(dir.path)) {
-      await mkdir5(dir.path, { recursive: true });
+      await mkdir6(dir.path, { recursive: true });
       fixed.push(`Recreated missing directory: ${dir.name}/`);
     }
   }
@@ -9849,7 +10119,7 @@ async function fixProject(projectRoot) {
         if (!state.goal)
           issues.push("current.yml is missing 'goal' field. Manual correction required.");
         if (!await dirExists(paths.backlog)) {
-          await mkdir5(paths.backlog, { recursive: true });
+          await mkdir6(paths.backlog, { recursive: true });
           fixed.push("Recreated missing backlog/ directory for active generation");
         }
       } catch {
@@ -9862,8 +10132,8 @@ async function fixProject(projectRoot) {
 }
 
 // src/cli/index.ts
-import { join as join7 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.1.3");
+import { join as join8 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.2.2");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();
@@ -9880,11 +10150,32 @@ program.command("init").description("Initialize a new REAP project (Genesis)").a
 `);
       }
     }
-    await initProject(cwd, name, mode, options.preset);
-    console.log(`✓ REAP project "${name}" initialized (${mode} mode)`);
-    console.log(`  .reap/ directory created with genome, environment, life, lineage`);
     console.log(`
-Next: run '/reap.start' to start your first Generation`);
+Initializing REAP project "${name}" (${mode} mode)...
+`);
+    const initResult = await initProject(cwd, name, mode, options.preset, (msg) => {
+      console.log(`  ${msg}`);
+    });
+    console.log(`
+✓ REAP project "${name}" initialized successfully!
+`);
+    console.log(`  Project:  ${name} (${mode})`);
+    if (initResult.agents.length > 0) {
+      console.log(`  Agents:   ${initResult.agents.join(", ")}`);
+    } else {
+      console.log(`  Agents:   None detected`);
+    }
+    console.log(`  Config:   .reap/config.yml`);
+    console.log(`  Genome:   .reap/genome/ (principles, conventions, constraints)`);
+    console.log(`
+  Getting started:`);
+    console.log(`    1. Open your AI agent (${initResult.agents[0] || "Claude Code or OpenCode"})`);
+    console.log(`    2. Run /reap.start to begin your first Generation`);
+    console.log(`    3. Or run /reap.evolve for autonomous execution`);
+    if (initResult.agents.length === 0) {
+      console.log(`
+  ⚠ No AI agents detected. Install Claude Code or OpenCode, then run 'reap update'.`);
+    }
   } catch (e) {
     console.error(`Error: ${e.message}`);
     process.exit(1);
@@ -9958,21 +10249,16 @@ program.command("update").description("Sync slash commands, templates, and hooks
 });
 program.command("help").description("Show REAP commands, slash commands, and workflow overview").action(async () => {
   let lang = "en";
-  const settingsContent = await readTextFile(ReapPaths.userClaudeSettingsJson);
-  if (settingsContent) {
-    try {
-      const settings = JSON.parse(settingsContent);
-      if (settings.language) {
-        const l = settings.language.toLowerCase();
-        if (l === "korean" || l === "ko")
-          lang = "ko";
-      }
-    } catch {}
-  }
-  const helpDir = join7(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join7(helpDir, `${lang}.txt`));
+  const detectedLang = await AgentRegistry.readLanguage();
+  if (detectedLang) {
+    const l = detectedLang.toLowerCase();
+    if (l === "korean" || l === "ko")
+      lang = "ko";
+  }
+  const helpDir = join8(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join8(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join7(helpDir, "en.txt"));
+    helpText = await readTextFile(join8(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;