@tdsoft-tech/aikit 0.1.16 → 0.1.18

package/dist/cli.js

@@ -122,6 +122,34 @@ var init_paths = __esm({
        */
       memory(configPath) {
         return join(configPath, "memory");
+      },
+      /**
+       * Get the Claude Code CLI configuration directory
+       */
+      claudeConfig(scope) {
+        if (scope === "project") {
+          return join(process.cwd(), ".claude");
+        }
+        const base = process.platform === "win32" ? process.env.APPDATA || join(homedir(), "AppData", "Roaming") : join(homedir(), ".claude");
+        return base;
+      },
+      /**
+       * Get Claude Code CLI commands directory
+       */
+      claudeCommands(project) {
+        return join(this.claudeConfig(project ? "project" : "user"), "commands");
+      },
+      /**
+       * Get Claude Code CLI skills directory
+       */
+      claudeSkills(project) {
+        return join(this.claudeConfig(project ? "project" : "user"), "skills");
+      },
+      /**
+       * Get Claude Code CLI agents directory
+       */
+      claudeAgents(project) {
+        return join(this.claudeConfig(project ? "project" : "user"), "agents");
       }
     };
   }
@@ -375,8 +403,8 @@ var init_memory = __esm({
         for (const subDir of subDirs) {
           const dirPath = join6(memoryPath, subDir);
           try {
-            const { readdir: readdir10 } = await import("fs/promises");
-            const files = await readdir10(dirPath);
+            const { readdir: readdir11 } = await import("fs/promises");
+            const files = await readdir11(dirPath);
             for (const file of files) {
               if (!file.endsWith(".md")) continue;
               const content = await readFile4(join6(dirPath, file), "utf-8");
@@ -1113,6 +1141,7 @@ __export(beads_exports, {
   BeadsIntegration: () => BeadsIntegration
 });
 import { readFile as readFile6, writeFile as writeFile5, readdir as readdir4, access as access3, constants as constants3, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
 import { join as join9 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -1227,6 +1256,68 @@ bd init
           return false;
         }
       }
+      /**
+       * Setup git hooks
+       */
+      async setupGitHooks() {
+        try {
+          const gitHooksDir = join9(this.projectPath, ".git", "hooks");
+          if (!existsSync4(gitHooksDir)) {
+            logger.info("Not a git repository, skipping git hooks setup");
+            return true;
+          }
+          const preCommitHook = join9(gitHooksDir, "pre-commit");
+          const hookContent = `#!/bin/sh
+#
+# bd (beads) pre-commit hook
+#
+# This hook ensures that any pending bd issue changes are flushed to
+# .beads/issues.jsonl before the commit is created, preventing a
+# race condition where daemon auto-flush fires after the commit.
+#
+
+# Check if bd is available
+if ! command -v bd >/dev/null 2>&1; then
+  echo "Warning: bd command not found, skipping pre-commit flush" >&2
+  exit 0
+fi
+
+# Check if we're in a bd workspace
+BEADS_DIR=""
+if [ -d ".beads" ]; then
+  BEADS_DIR=".beads"
+fi
+
+if [ -z "$BEADS_DIR" ]; then
+  # Not a bd workspace, nothing to do
+  exit 0
+fi
+
+# Check if bd is actually initialized (has beads.db or config.yaml)
+# This prevents errors if .beads/ exists but bd was never initialized
+if [ ! -f "$BEADS_DIR/beads.db" ] && [ ! -f "$BEADS_DIR/config.yaml" ]; then
+  # .beads/ exists but bd is not initialized, skip bd operations
+  exit 0
+fi
+
+# Flush pending changes to JSONL
+# Use --flush-only to skip git operations (we're already in a git hook)
+# Suppress output unless there's an error
+if ! bd sync --flush-only >/dev/null 2>&1; then
+  echo "Error: Failed to flush bd changes to JSONL" >&2
+  echo "Run 'bd sync --flush-only' manually to diagnose" >&2
+  exit 1
+fi
+
+exit 0
+`;
+          await writeFile5(preCommitHook, hookContent, { mode: 493 });
+          return true;
+        } catch (error) {
+          logger.error("Failed to setup git hooks:", error);
+          return false;
+        }
+      }
       /**
        * Get current status
        */
@@ -1500,13 +1591,437 @@ type: ${type}
   }
 });
 
+// src/core/sessions.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  SessionManager: () => SessionManager,
+  formatSession: () => formatSession
+});
+import { readFile as readFile7, writeFile as writeFile8, readdir as readdir7, mkdir as mkdir8 } from "fs/promises";
+import { join as join13 } from "path";
+import matter3 from "gray-matter";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+function formatSession(session) {
+  const startDate = new Date(session.startTime);
+  const endDate = session.endTime ? new Date(session.endTime) : null;
+  return `
+${session.id}
+  Name: ${session.name}
+  Status: ${session.status}
+  Started: ${startDate.toLocaleString()}
+  ${endDate ? `Ended: ${endDate.toLocaleString()}` : ""}
+  Goals: ${session.goals.length}
+  Updates: ${session.updates.length}
+`;
+}
+var execAsync2, SessionManager;
+var init_sessions = __esm({
+  "src/core/sessions.ts"() {
+    "use strict";
+    init_esm_shims();
+    execAsync2 = promisify2(exec2);
+    SessionManager = class {
+      sessionsDir;
+      projectPath;
+      constructor(projectPath) {
+        this.projectPath = projectPath || process.cwd();
+        this.sessionsDir = join13(this.projectPath, ".aikit", "sessions");
+      }
+      /**
+       * Initialize sessions directory
+       */
+      async init() {
+        await mkdir8(this.sessionsDir, { recursive: true });
+      }
+      /**
+       * Start a new session
+       */
+      async startSession(name, goals) {
+        await this.init();
+        const now = /* @__PURE__ */ new Date();
+        const date = now.toISOString().split("T")[0].replace(/-/g, "");
+        const time = now.toTimeString().split(" ")[0].replace(/:/g, "");
+        const nameSuffix = name ? `-${name.replace(/\s+/g, "-").toLowerCase()}` : "";
+        const id = `${date}-${time}${nameSuffix}`;
+        const session = {
+          id,
+          name: name || "Untitled Session",
+          startTime: now.toISOString(),
+          goals: goals || [],
+          updates: [],
+          status: "active"
+        };
+        const gitState = await this.getGitState();
+        session.updates.push({
+          timestamp: now.toISOString(),
+          notes: name ? `Started session: ${name}` : "Started new session",
+          gitBranch: gitState.branch,
+          gitCommits: 0
+        });
+        await this.saveSession(session);
+        await this.setActiveSession(id);
+        return session;
+      }
+      /**
+       * Update current session with notes
+       */
+      async updateSession(notes) {
+        const sessionId = await this.getActiveSessionId();
+        if (!sessionId) {
+          throw new Error("No active session. Use startSession() first.");
+        }
+        const session = await this.getSession(sessionId);
+        if (!session) {
+          throw new Error(`Session not found: ${sessionId}`);
+        }
+        const gitState = await this.getGitState();
+        const modifiedFiles = await this.getModifiedFiles();
+        const update = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          notes: notes || "Session updated",
+          gitBranch: gitState.branch,
+          gitCommits: gitState.commits || 0,
+          modifiedFiles
+        };
+        const beadsTask = await this.getCurrentBeadsTask();
+        if (beadsTask) {
+          update.beadsTask = beadsTask;
+        }
+        session.updates.push(update);
+        await this.saveSession(session);
+        return session;
+      }
+      /**
+       * End current session and generate summary
+       */
+      async endSession() {
+        const sessionId = await this.getActiveSessionId();
+        if (!sessionId) {
+          throw new Error("No active session. Use startSession() first.");
+        }
+        const session = await this.getSession(sessionId);
+        if (!session) {
+          throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.endTime = (/* @__PURE__ */ new Date()).toISOString();
+        session.status = "ended";
+        const gitState = await this.getGitState();
+        const modifiedFiles = await this.getModifiedFiles();
+        session.updates.push({
+          timestamp: session.endTime,
+          notes: "Session ended",
+          gitBranch: gitState.branch,
+          gitCommits: gitState.commits || 0,
+          modifiedFiles
+        });
+        await this.saveSession(session);
+        await this.clearActiveSession();
+        return session;
+      }
+      /**
+       * Get current active session
+       */
+      async getCurrentSession() {
+        const sessionId = await this.getActiveSessionId();
+        if (!sessionId) return null;
+        return this.getSession(sessionId);
+      }
+      /**
+       * Get all sessions
+       */
+      async listSessions() {
+        try {
+          const files = await readdir7(this.sessionsDir);
+          const sessions = [];
+          for (const file of files) {
+            if (file === ".current-session" || !file.endsWith(".md")) continue;
+            const sessionId = file.replace(".md", "");
+            const session = await this.getSession(sessionId);
+            if (session) {
+              sessions.push(session);
+            }
+          }
+          return sessions.sort(
+            (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
+          );
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Get specific session
+       */
+      async getSession(id) {
+        const filePath = join13(this.sessionsDir, `${id}.md`);
+        try {
+          const content = await readFile7(filePath, "utf-8");
+          const { data, content: body } = matter3(content);
+          const updates = this.parseUpdates(body);
+          return {
+            id: data.id || id,
+            name: data.name || "Untitled",
+            startTime: data.startTime,
+            endTime: data.endTime,
+            goals: data.goals || [],
+            updates,
+            status: data.status || "active"
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Search sessions by keyword
+       */
+      async searchSessions(query) {
+        const sessions = await this.listSessions();
+        const lowerQuery = query.toLowerCase();
+        return sessions.filter(
+          (session) => session.name.toLowerCase().includes(lowerQuery) || session.id.toLowerCase().includes(lowerQuery) || session.goals.some((g) => g.toLowerCase().includes(lowerQuery)) || session.updates.some((u) => u.notes?.toLowerCase().includes(lowerQuery))
+        );
+      }
+      /**
+       * Get active session ID
+       */
+      async getActiveSessionId() {
+        const trackerPath = join13(this.sessionsDir, ".current-session");
+        try {
+          const content = await readFile7(trackerPath, "utf-8");
+          return content.trim();
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Set active session
+       */
+      async setActiveSession(id) {
+        const trackerPath = join13(this.sessionsDir, ".current-session");
+        await writeFile8(trackerPath, id);
+      }
+      /**
+       * Clear active session
+       */
+      async clearActiveSession() {
+        const trackerPath = join13(this.sessionsDir, ".current-session");
+        try {
+          await writeFile8(trackerPath, "");
+        } catch {
+        }
+      }
+      /**
+       * Save session to file
+       */
+      async saveSession(session) {
+        const filePath = join13(this.sessionsDir, `${session.id}.md`);
+        const updatesMarkdown = session.updates.map((update) => {
+          const date = new Date(update.timestamp);
+          const dateStr = date.toLocaleString();
+          const sections = [`### ${dateStr}`];
+          if (update.notes) {
+            sections.push(update.notes);
+          }
+          if (update.gitBranch) {
+            sections.push(`**Git Branch:** ${update.gitBranch}`);
+          }
+          if (update.modifiedFiles && update.modifiedFiles.length > 0) {
+            sections.push(
+              `**Modified Files:** ${update.modifiedFiles.length} files`,
+              update.modifiedFiles.map((f) => `  - ${f}`).join("\n")
+            );
+          }
+          if (update.beadsTask) {
+            sections.push(`**Beads Task:** ${update.beadsTask.id} (${update.beadsTask.status})`);
+          }
+          return sections.join("\n");
+        }).join("\n\n");
+        const frontmatter = {
+          id: session.id,
+          name: session.name,
+          startTime: session.startTime,
+          status: session.status,
+          goals: session.goals
+        };
+        if (session.endTime) {
+          frontmatter.endTime = session.endTime;
+        }
+        const content = `# Development Session - ${session.name}
+
+**Started:** ${new Date(session.startTime).toLocaleString()}
+**Status:** ${session.status}
+${session.endTime ? `**Ended:** ${new Date(session.endTime).toLocaleString()}` : ""}
+
+## Goals
+${session.goals.map((g, i) => `- [ ] ${g}`).join("\n")}
+
+## Progress
+
+${updatesMarkdown}
+
+## Summary
+${this.generateSummary(session)}
+`;
+        const fileContent = matter3.stringify(content, frontmatter);
+        await writeFile8(filePath, fileContent);
+      }
+      /**
+       * Generate session summary
+       */
+      generateSummary(session) {
+        if (session.status === "active") {
+          return "*Session in progress...*";
+        }
+        const duration = session.endTime ? new Date(session.endTime).getTime() - new Date(session.startTime).getTime() : 0;
+        const durationMinutes = Math.floor(duration / 6e4);
+        const hours = Math.floor(durationMinutes / 60);
+        const minutes = durationMinutes % 60;
+        let summary = `**Duration:** ${hours}h ${minutes}m
+
+`;
+        const totalGoals = session.goals.length;
+        summary += `**Goals:** ${totalGoals} defined
+
+`;
+        summary += `**Updates:** ${session.updates.length} progress notes
+
+`;
+        const lastUpdate = session.updates[session.updates.length - 1];
+        if (lastUpdate?.gitCommits !== void 0) {
+          summary += `**Git Commits:** ${lastUpdate.gitCommits} commits
+
+`;
+        }
+        if (lastUpdate?.modifiedFiles && lastUpdate.modifiedFiles.length > 0) {
+          summary += `**Files Modified:** ${lastUpdate.modifiedFiles.length} files
+
+`;
+        }
+        summary += `**Total Updates:** ${session.updates.length}`;
+        return summary;
+      }
+      /**
+       * Parse updates from markdown body
+       */
+      parseUpdates(body) {
+        const updates = [];
+        const lines = body.split("\n");
+        let currentUpdate = null;
+        let notesLines = [];
+        for (const line of lines) {
+          const updateMatch = line.match(/^### (\d{4}-\d{2}-\d{2} \d{2}:\d{2})/);
+          if (updateMatch) {
+            if (currentUpdate) {
+              currentUpdate.notes = notesLines.join("\n").trim();
+              updates.push(currentUpdate);
+            }
+            currentUpdate = {
+              timestamp: updateMatch[1]
+            };
+            notesLines = [];
+            continue;
+          }
+          if (!currentUpdate) continue;
+          const gitBranchMatch = line.match(/\*\*Git Branch:\*\* (.+)/);
+          if (gitBranchMatch) {
+            currentUpdate.gitBranch = gitBranchMatch[1];
+            continue;
+          }
+          const commitsMatch = line.match(/\*\*Git Commits:\*\* (\d+)/);
+          if (commitsMatch) {
+            currentUpdate.gitCommits = parseInt(commitsMatch[1], 10);
+            continue;
+          }
+          if (line.includes("**Modified Files:**")) {
+            continue;
+          }
+          if (line.trim().startsWith("- ") && currentUpdate) {
+            if (!currentUpdate.modifiedFiles) {
+              currentUpdate.modifiedFiles = [];
+            }
+            currentUpdate.modifiedFiles.push(line.trim().substring(2));
+            continue;
+          }
+          const beadsMatch = line.match(/\*\*Beads Task:\*\* ([\w-]+) \((\w+)\)/);
+          if (beadsMatch) {
+            currentUpdate.beadsTask = {
+              id: beadsMatch[1],
+              status: beadsMatch[2]
+            };
+            continue;
+          }
+          if (!line.startsWith("**") && !line.startsWith("#")) {
+            notesLines.push(line);
+          }
+        }
+        if (currentUpdate) {
+          currentUpdate.notes = notesLines.join("\n").trim();
+          updates.push(currentUpdate);
+        }
+        return updates;
+      }
+      /**
+       * Get git state
+       */
+      async getGitState() {
+        try {
+          const { stdout: branch } = await execAsync2("git rev-parse --abbrev-ref HEAD");
+          const { stdout: log } = await execAsync2("git log --oneline | wc -l");
+          return {
+            branch: branch.trim(),
+            commits: parseInt(log.trim(), 10)
+          };
+        } catch {
+          return { branch: "main" };
+        }
+      }
+      /**
+       * Get modified files
+       */
+      async getModifiedFiles() {
+        try {
+          const { stdout } = await execAsync2("git status --porcelain");
+          const lines = stdout.trim().split("\n");
+          return lines.filter((line) => line.trim()).map((line) => line.substring(3));
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Get current Beads task
+       */
+      async getCurrentBeadsTask() {
+        const beadsDir = join13(this.projectPath, ".beads");
+        try {
+          const files = await readdir7(beadsDir);
+          const beadFiles = files.filter((f) => f.startsWith("bead-") && f.endsWith(".md"));
+          for (const file of beadFiles) {
+            const content = await readFile7(join13(beadsDir, file), "utf-8");
+            const statusMatch = content.match(/^status:\s*(\w+)/m);
+            const id = file.replace(".md", "");
+            if (statusMatch && (statusMatch[1] === "in-progress" || statusMatch[1] === "todo")) {
+              return {
+                id,
+                status: statusMatch[1]
+              };
+            }
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
 // src/core/tool-config.ts
 var tool_config_exports = {};
 __export(tool_config_exports, {
   ToolConfigManager: () => ToolConfigManager
 });
-import { readFile as readFile12, writeFile as writeFile13, mkdir as mkdir11, access as access5, constants as constants4 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile14, writeFile as writeFile16, mkdir as mkdir14, access as access7, constants as constants4 } from "fs/promises";
+import { join as join21 } from "path";
 import { z as z3 } from "zod";
 var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
 var init_tool_config = __esm({
@@ -1534,7 +2049,7 @@ var init_tool_config = __esm({
       toolsConfigPath;
       constructor(config) {
         this.config = config;
-        this.toolsConfigPath = join18(this.config.configPath, "config", "tools.json");
+        this.toolsConfigPath = join21(this.config.configPath, "config", "tools.json");
       }
       /**
        * Get all registered tools with their current status
@@ -1617,8 +2132,8 @@ var init_tool_config = __esm({
        */
       async loadConfigs() {
         try {
-          await access5(this.toolsConfigPath, constants4.R_OK);
-          const content = await readFile12(this.toolsConfigPath, "utf-8");
+          await access7(this.toolsConfigPath, constants4.R_OK);
+          const content = await readFile14(this.toolsConfigPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -1628,9 +2143,9 @@ var init_tool_config = __esm({
        * Save configurations
        */
       async saveConfigs(configs) {
-        const configDir = join18(this.config.configPath, "config");
-        await mkdir11(configDir, { recursive: true });
-        await writeFile13(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+        const configDir = join21(this.config.configPath, "config");
+        await mkdir14(configDir, { recursive: true });
+        await writeFile16(this.toolsConfigPath, JSON.stringify(configs, null, 2));
       }
     };
   }
@@ -1677,8 +2192,8 @@ var init_figma_oauth = __esm({
         console.log('3. Give it a name (e.g., "AIKit")');
         console.log("4. Copy the token (you won't see it again!)");
         console.log("5. Paste it here when prompted\n");
-        const { default: inquirer3 } = await import("inquirer");
-        const { token } = await inquirer3.prompt([
+        const { default: inquirer4 } = await import("inquirer");
+        const { token } = await inquirer4.prompt([
           {
             type: "password",
             name: "token",
@@ -1708,14 +2223,14 @@ var init_figma_oauth = __esm({
        * Alternative: Manual token input
        */
       async authenticateManual() {
-        const { default: inquirer3 } = await import("inquirer");
+        const { default: inquirer4 } = await import("inquirer");
         console.log("\n\u{1F510} Figma Authentication (Manual)\n");
         console.log("To get your Figma Personal Access Token:");
         console.log("1. Visit: https://www.figma.com/developers/api#access-tokens");
         console.log('2. Scroll to "Personal access tokens"');
         console.log('3. Click "Create new token"');
         console.log("4. Copy the token and paste it below\n");
-        const { token } = await inquirer3.prompt([
+        const { token } = await inquirer4.prompt([
           {
             type: "password",
             name: "token",
@@ -1770,7 +2285,7 @@ init_esm_shims();
 
 // src/cli/index.ts
 init_esm_shims();
-import { Command } from "commander";
+import { Command as Command3 } from "commander";
 
 // src/index.ts
 init_esm_shims();
@@ -2345,12 +2860,20 @@ ${agent.delegatesTo.map((a) => `- @${a}`).join("\n")}` : ""}
 
 // src/core/commands.ts
 init_esm_shims();
+
+// src/core/commands/index.ts
+init_esm_shims();
 init_paths();
 import { readFile as readFile3, readdir as readdir2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join5, basename as basename2, extname as extname2 } from "path";
 import matter2 from "gray-matter";
-var DEFAULT_COMMANDS = [
-  // Core Workflow Commands (Beads integration)
+
+// src/core/commands/types.ts
+init_esm_shims();
+
+// src/core/commands/core.ts
+init_esm_shims();
+var CORE_COMMANDS = [
   {
     name: "create",
     description: "Create a new Beads task for tracking",
@@ -2602,8 +3125,12 @@ Task description: $ARGUMENTS
 \u2713 Use for straightforward tasks first
 \u2713 Consider /plan + /implement for complex features
 \u2713 Review changes before final approval`
-  },
-  // Quick Actions
+  }
+];
+
+// src/core/commands/quick.ts
+init_esm_shims();
+var QUICK_COMMANDS = [
   {
     name: "fix",
     description: "Quick fix for an issue",
@@ -2698,7 +3225,47 @@ Optional PR title: $ARGUMENTS
    - Screenshots if UI changes
 3. Create PR via GitHub CLI or provide URL`
   },
-  // Research & Analysis
+  {
+    name: "refactor",
+    description: "Refactor code to improve structure without changing behavior",
+    category: "quick",
+    usage: "/refactor [file or pattern]",
+    examples: ["/refactor src/utils.ts", "/refactor duplicate code"],
+    content: `Refactor code following best practices.
+
+## Workflow
+
+Optional file or pattern: $ARGUMENTS
+
+1. Ensure tests are in place
+2. Identify refactoring opportunities
+3. Apply refactoring incrementally
+4. Run tests after each change
+5. Verify no behavior changes`
+  },
+  {
+    name: "lint",
+    description: "Run linter and fix issues",
+    category: "quick",
+    usage: "/lint [--fix]",
+    examples: ["/lint", "/lint --fix"],
+    content: `Run linter and optionally fix issues.
+
+## Workflow
+
+Optional flags: $ARGUMENTS
+
+1. Run linter: \`npm run lint\`
+2. Parse errors and warnings
+3. If --fix flag, run auto-fix
+4. Report remaining issues
+5. Suggest manual fixes if needed`
+  }
+];
+
+// src/core/commands/research.ts
+init_esm_shims();
+var RESEARCH_COMMANDS = [
   {
     name: "research",
     description: "Deep research on a topic",
@@ -2759,8 +3326,12 @@ Optional path: $ARGUMENTS
    - Test coverage gaps
 3. Prioritize findings
 4. Suggest improvements`
-  },
-  // Design & Planning
+  }
+];
+
+// src/core/commands/design.ts
+init_esm_shims();
+var DESIGN_COMMANDS = [
   {
     name: "design",
     description: "Design a feature or system",
@@ -2802,76 +3373,6 @@ Problem to brainstorm: $ARGUMENTS
 3. Group related ideas
 4. Evaluate feasibility
 5. Select top candidates`
-  },
-  // Git & Version Control
-  {
-    name: "branch",
-    description: "Create a new feature branch",
-    category: "git",
-    usage: "/branch <name>",
-    examples: ["/branch feat/auth", "/branch fix/navigation-bug"],
-    content: `Create and switch to a new branch.
-
-## Workflow
-
-Branch name: $ARGUMENTS
-
-1. Ensure clean working directory
-2. Pull latest main/master
-3. Create branch with naming convention:
-   - feat/* for features
-   - fix/* for bug fixes
-   - refactor/* for refactoring
-   - docs/* for documentation
-4. Switch to new branch`
-  },
-  {
-    name: "merge",
-    description: "Merge current branch to target",
-    category: "git",
-    usage: "/merge [target]",
-    examples: ["/merge", "/merge main"],
-    content: `Merge current branch to target.
-
-## Workflow
-
-Optional target branch: $ARGUMENTS
-
-1. Run quality gates first
-2. Commit any pending changes
-3. Switch to target branch
-4. Pull latest
-5. Merge feature branch
-6. Resolve conflicts if any
-7. Push`
-  },
-  // Utilities
-  {
-    name: "status",
-    description: "Show current status overview",
-    category: "utility",
-    usage: "/status",
-    examples: ["/status"],
-    content: `Display comprehensive status.
-
-## Shows
-- Current task (from Beads)
-- Git status
-- Active branch
-- Pending changes
-- Test status
-- Recent activity`
-  },
-  {
-    name: "help",
-    description: "Show available commands",
-    category: "utility",
-    usage: "/help [command]",
-    examples: ["/help", "/help plan"],
-    content: `Display help information.
-
-If no command specified, list all available commands.
-If command specified, show detailed help for that command.`
   },
   {
     name: "analyze-figma",
@@ -3017,24 +3518,179 @@ Summarize what was extracted:
 - If the tool returns an error about access, verify the file is accessible with your token
 
 The analysis will be saved automatically for later reference.`
+  }
+];
+
+// src/core/commands/git.ts
+init_esm_shims();
+var GIT_COMMANDS = [
+  {
+    name: "branch",
+    description: "Create a new feature branch",
+    category: "git",
+    usage: "/branch <name>",
+    examples: ["/branch feat/auth", "/branch fix/navigation-bug"],
+    content: `Create and switch to a new branch.
+
+## Workflow
+
+Branch name: $ARGUMENTS
+
+1. Ensure clean working directory
+2. Pull latest main/master
+3. Create branch with naming convention:
+   - feat/* for features
+   - fix/* for bug fixes
+   - refactor/* for refactoring
+   - docs/* for documentation
+4. Switch to new branch`
   },
   {
-    name: "refactor",
-    description: "Refactor code to improve structure without changing behavior",
-    category: "quick",
-    usage: "/refactor [file or pattern]",
-    examples: ["/refactor src/utils.ts", "/refactor duplicate code"],
-    content: `Refactor code following best practices.
+    name: "merge",
+    description: "Merge current branch to target",
+    category: "git",
+    usage: "/merge [target]",
+    examples: ["/merge", "/merge main"],
+    content: `Merge current branch to target.
 
 ## Workflow
 
-Optional file or pattern: $ARGUMENTS
+Optional target branch: $ARGUMENTS
 
-1. Ensure tests are in place
-2. Identify refactoring opportunities
-3. Apply refactoring incrementally
-4. Run tests after each change
-5. Verify no behavior changes`
+1. Run quality gates first
+2. Commit any pending changes
+3. Switch to target branch
+4. Pull latest
+5. Merge feature branch
+6. Resolve conflicts if any
+7. Push`
+  },
+  {
+    name: "git:ignore-init",
+    description: "Initialize AI-safe .gitignore patterns",
+    category: "git",
+    usage: "/git:ignore-init",
+    examples: ["/git:ignore-init"],
+    content: `Initialize AI-safe .gitignore patterns to prevent AI from accessing sensitive files.
+
+## Workflow
+
+1. **Check Existing .gitignore**: See if .gitignore exists
+2. **Backup**: Create .gitignore.backup if file exists
+3. **Append Patterns**: Add AI-specific ignore patterns
+4. **Verify**: Confirm patterns added successfully
+
+## Patterns Added
+
+**AI-Sensitive Files:**
+\`\`\`
+# AIKit - AI Agent Protection
+.env
+.env.local
+.env.*.local
+*.key
+*.pem
+secrets/
+credentials/
+.aws/
+.ssh/
+config/secrets.json
+
+# AI Working Directories
+.aikit/memory/
+.aikit/checkpoints/
+.aikit/sessions/
+
+# Claude Code
+.claude/settings.json
+.claude/local_history.json
+
+# OpenCode
+.opencode/config.json
+.opencode/state.json
+
+# Agent-Specific
+.agentignore
+.aiignore
+
+# Logs and Debug
+*.log
+logs/
+debug.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Temporary Files
+*.tmp
+*.temp
+.cache/
+temp/
+tmp/
+\`\`\`
+
+**Explanation of Each Pattern:**
+- **Credentials**: API keys, tokens, certificates
+- **Config**: Sensitive configuration files
+- **Memory**: AI conversation history and context
+- **Sessions**: Active AI session data
+- **Logs**: Debug and error logs
+- **Temp**: Temporary processing files
+
+**Why These Patterns?**
+- Prevent AI from reading API keys and secrets
+- Avoid exposing sensitive user data
+- Reduce AI context noise (logs, cache)
+- Protect privacy
+- Comply with security best practices
+
+## Verification
+
+**After Running Command:**
+\`\`\`
+\u2713 AI-safe patterns added to .gitignore
+\u2713 Backup created: .gitignore.backup
+\u2713 Protected: API keys, secrets, memory, logs
+\u2713 Safe to commit code
+\`\`\`
+
+## Notes
+- Patterns appended to existing .gitignore
+- Doesn't remove existing patterns
+- Can be manually customized after creation
+- Recommend reviewing before committing`
+  }
+];
+
+// src/core/commands/utility.ts
+init_esm_shims();
+var UTILITY_COMMANDS = [
+  {
+    name: "status",
+    description: "Show current status overview",
+    category: "utility",
+    usage: "/status",
+    examples: ["/status"],
+    content: `Display comprehensive status.
+
+## Shows
+- Current task (from Beads)
+- Git status
+- Active branch
+- Pending changes
+- Test status
+- Recent activity`
+  },
+  {
+    name: "help",
+    description: "Show available commands",
+    category: "utility",
+    usage: "/help [command]",
+    examples: ["/help", "/help plan"],
+    content: `Display help information.
+
+If no command specified, list all available commands.
+If command specified, show detailed help for that command.`
   },
   {
     name: "test",
@@ -3053,24 +3709,6 @@ Optional pattern: $ARGUMENTS
 3. Show coverage if available
 4. Highlight failures
 5. Suggest fixes for failures`
-  },
-  {
-    name: "lint",
-    description: "Run linter and fix issues",
-    category: "quick",
-    usage: "/lint [--fix]",
-    examples: ["/lint", "/lint --fix"],
-    content: `Run linter and optionally fix issues.
-
-## Workflow
-
-Optional flags: $ARGUMENTS
-
-1. Run linter: \`npm run lint\`
-2. Parse errors and warnings
-3. If --fix flag, run auto-fix
-4. Report remaining issues
-5. Suggest manual fixes if needed`
   },
   {
     name: "deploy",
@@ -3118,15 +3756,1196 @@ Optional version: $ARGUMENTS
 
 ## Workflow
 
-Optional flags: $ARGUMENTS
+Optional flags: $ARGUMENTS
+
+1. Determine log location
+2. Apply filters if specified
+3. Display logs
+4. If --follow, stream updates
+5. Format for readability`
+  },
+  {
+    name: "create-agent",
+    description: "Create a custom AI agent with specific capabilities",
+    category: "utility",
+    usage: "/create-agent <name> [description]",
+    examples: ['/create-agent security "Security audit agent"', "/create-agent writer"],
+    content: `Create a custom AI agent for specialized tasks.
+
+## Workflow
+
+Agent name: $ARGUMENTS
+
+1. **Determine Agent Purpose**: Ask user clarifying questions:
+   - What specific tasks will this agent handle?
+   - What expertise should it have?
+   - What tools should it have access to?
+   - Any specific behaviors or constraints?
+
+2. **Generate Agent Configuration**:
+   - System prompt with instructions
+   - Recommended tools/skills
+   - Preferred models
+   - Interaction patterns
+
+3. **Create Agent File**: Save to .aikit/agents/<name>.md
+   - Frontmatter with metadata
+   - System prompt
+   - Tool recommendations
+   - Usage examples
+
+4. **Verify Creation**: Confirm agent created successfully
+
+## Agent Template
+
+**Frontmatter:**
+\`\`\`yaml
+---
+name: <agent-name>
+description: <what this agent does>
+useWhen: <when to use this agent>
+mode: subagent
+tools: [list of tools]
+skills: [list of skills]
+---
+\`\`\`
+
+**System Prompt:**
+\`\`\`
+# Agent Name
+
+You are a specialized AI agent for <specific domain>.
+
+## Your Expertise
+- Expertise area 1
+- Expertise area 2
+- Expertise area 3
+
+## Your Role
+1. Primary responsibility
+2. Secondary tasks
+3. Collaboration with other agents
+
+## Guidelines
+- How to approach tasks
+- What to focus on
+- What to avoid
+
+## Tools You Have Access To
+- Tool 1: description
+- Tool 2: description
+
+## Output Format
+- Preferred response format
+- Code style (if applicable)
+- Explanation style
+\`\`\`
+
+## Example Agents
+
+**Security Agent:**
+- Focuses on code security vulnerabilities
+- Tools: static analysis, dependency checker
+- Skills: security-audit, code-review
+
+**Performance Agent:**
+- Focuses on optimization
+- Tools: profiler, benchmark
+- Skills: performance-optimization
+
+**Documentation Agent:**
+- Focuses on writing clear docs
+- Tools: markdown formatter
+- Skills: documentation
+
+## Notes
+- Agents are saved as markdown files
+- Can be customized after creation
+- Used with /agent or agent delegation
+- Appear in agent selector in OpenCode`
+  },
+  {
+    name: "list-agents",
+    description: "List all available custom agents",
+    category: "utility",
+    usage: "/list-agents",
+    examples: ["/list-agents"],
+    content: `List all available custom agents with descriptions.
+
+## Workflow
+
+1. **Scan Agents Directory**: Find all agent files in .aikit/agents/
+2. **Parse Metadata**: Extract agent descriptions and use cases
+3. **Categorize**: Group by type/purpose
+4. **Display**: Show formatted list with details
+
+## Output Format
+
+\`\`\`
+Available Agents:
+
+### Development Agents
+\u2022 security - Security vulnerability scanner
+  Use when: Reviewing code for security issues
+  Skills: security-audit, code-review
+  Tools: static-analysis, dependency-checker
+
+\u2022 performance - Performance optimization specialist
+  Use when: Optimizing slow code or databases
+  Skills: performance-optimization, database-design
+  Tools: profiler, query-analyzer
+
+### Documentation Agents
+\u2022 writer - Technical documentation writer
+  Use when: Creating or updating docs
+  Skills: documentation
+  Tools: markdown-formatter
+
+### Design Agents
+\u2022 ui-ux - UI/UX design reviewer
+  Use when: Reviewing interface designs
+  Skills: accessibility, frontend-aesthetics
+
+Total: 4 agents
+
+Create a new agent: /create-agent <name>
+\`\`\`
+
+## Agent Information Shown
+- Agent name
+- Description
+- When to use it
+- Required skills
+- Available tools
+- Category/type
+
+## Notes
+- Built-in agents (plan, build, review, etc.) also shown
+- Custom agents appear after built-in ones
+- Use /agent <name> to invoke specific agent
+- Can view full agent file for details`
+  }
+];
+
+// src/core/commands/checkpoint.ts
+init_esm_shims();
+var CHECKPOINT_COMMANDS = [
+  {
+    name: "checkpoint:create",
+    description: "Save current state as a checkpoint",
+    category: "checkpoint",
+    usage: "/checkpoint:create [message]",
+    examples: ["/checkpoint:create", '/checkpoint:create "Before refactoring"'],
+    content: `Create a checkpoint of the current working state.
+
+## Workflow
+
+Optional message: $ARGUMENTS
+
+1. **Check Git Status**: Verify clean or staged state
+2. **Create Checkpoint**:
+   - Generate checkpoint ID (timestamp-based)
+   - Save git diff or uncommitted changes
+   - Save current branch name
+   - Save list of modified files
+   - Save user's message (if provided)
+3. **Store Checkpoint**: Save to .aikit/checkpoints/checkpoint-{id}.json
+4. **Confirm**: Display checkpoint ID and summary
+
+## Checkpoint Contents
+- Timestamp
+- Git branch
+- Git commit hash (if any)
+- Uncommitted changes (diff)
+- Modified files list
+- User message
+- Beads task state (if active)
+
+## Example Output
+\`\`\`
+Checkpoint created: checkpoint-20250102-143022
+Message: Before refactoring
+Files modified: 5 files
+\`\`\`
+
+## Notes
+- Checkpoints are stored locally in .aikit/checkpoints/
+- Git changes are preserved (not committed)
+- Use for experimentation - safely restore if things go wrong
+- Checkpoints include full state, not just git`
+  },
+  {
+    name: "checkpoint:restore",
+    description: "Restore to a previous checkpoint",
+    category: "checkpoint",
+    usage: "/checkpoint:restore [checkpoint-id]",
+    examples: ["/checkpoint:restore", "/checkpoint:restore checkpoint-20250102-143022", "/checkpoint:restore latest"],
+    content: `Restore the project state from a checkpoint.
+
+## Workflow
+
+Checkpoint ID: $ARGUMENTS (default: latest)
+
+1. **Find Checkpoint**:
+   - If no ID provided, find latest checkpoint
+   - Verify checkpoint file exists
+2. **Display Summary**: Show what will be restored
+3. **Confirm with User**: Ask for confirmation before proceeding
+4. **Restore State**:
+   - Clean working directory (remove uncommitted changes)
+   - Checkout git commit from checkpoint
+   - Apply uncommitted changes from checkpoint
+   - Restore Beads task state if available
+5. **Verify**: Confirm restoration successful
+
+## Safety Checks
+- Warn if current changes will be lost
+- Show diff between current and checkpoint
+- Require explicit user confirmation
+- Backup current state before restoring
+
+## Example Output
+\`\`\`
+Restoring checkpoint: checkpoint-20250102-143022
+Message: Before refactoring
+Files modified: 5 files
+
+\u26A0\uFE0F  Warning: Uncommitted changes will be lost
+Proceed? (yes/no)
+
+\u2713 Restored successfully
+\`\`\`
+
+## Notes
+- Current uncommitted changes will be lost
+- Git history is preserved
+- Beads tasks will be restored to checkpointed state`
+  },
+  {
+    name: "checkpoint:list",
+    description: "List all available checkpoints",
+    category: "checkpoint",
+    usage: "/checkpoint:list",
+    examples: ["/checkpoint:list"],
+    content: `List all saved checkpoints with details.
+
+## Workflow
+
+1. **Scan Checkpoints Directory**: Find all checkpoint files in .aikit/checkpoints/
+2. **Sort by Date**: Most recent first
+3. **Display Summary**: Show table/list of checkpoints
+
+## Output Format
+\`\`\`
+Available Checkpoints:
+
+1. checkpoint-20250102-143022
+   Date: 2025-01-02 14:30:22
+   Message: Before refactoring
+   Branch: feature/user-auth
+   Files: 5 modified
+   Size: 2.3MB
+
+2. checkpoint-20250102-120815
+   Date: 2025-01-02 12:08:15
+   Message: Initial implementation
+   Branch: main
+   Files: 12 modified
+   Size: 5.1MB
+
+Total: 2 checkpoints
+\`\`\`
+
+## Filtering Options (future)
+- Filter by branch
+- Filter by date range
+- Filter by message content
+- Show only checkpoints with specific files
+
+## Notes
+- Checkpoints are stored in .aikit/checkpoints/
+- Older checkpoints can be manually deleted
+- Use /checkpoint:restore <id> to restore
+- Use /checkpoint:restore latest for most recent`
+  }
+];
+
+// src/core/commands/sessions.ts
+init_esm_shims();
+var SESSION_COMMANDS = [
+  {
+    name: "session:start",
+    description: "Start a new development session",
+    category: "session",
+    usage: "/session:start [name]",
+    examples: [
+      "/session:start",
+      "/session:start authentication-refactor",
+      '/session:start "Add user profile feature"'
+    ],
+    content: `Start a new development session to track your work.
+
+## Workflow
+
+Session name: $ARGUMENTS
+
+1. **Create Session:**
+   - Generate session ID with timestamp
+   - Create session file in .aikit/sessions/
+   - Track active session in .current-session
+   - Capture initial git state
+
+2. **Set Goals:**
+   - Ask user for session goals if not provided
+   - Document what you want to accomplish
+   - Link to Beads task if active
+
+3. **Session Started:**
+   - Session ID: YYYY-MM-DD-HHMM[-name]
+   - Status: active
+   - Ready for updates
+
+## What Gets Tracked
+- Session start time
+- Git branch and commits
+- Modified files
+- Progress notes
+- Linked Beads task
+
+## Session File Location
+.aikit/sessions/YYYY-MM-DD-HHMM[-name].md
+
+## Examples
+
+Start unnamed session:
+\`\`\`
+/session:start
+\`\`\`
+
+Start with descriptive name:
+\`\`\`
+/session:start auth-refactor
+\`\`\`
+
+Start with goal:
+\`\`\`
+/session:start "Implement OAuth 2.0"
+Goals:
+- Add Google OAuth
+- Add JWT token handling
+\`\`\`
+
+## Notes
+- Session files are markdown with frontmatter
+- Sessions persist across AI conversations
+- Use /session:update to add progress notes
+- Use /session:end to close and summarize`
+  },
+  {
+    name: "session:update",
+    description: "Add progress notes to current session",
+    category: "session",
+    usage: "/session:update [notes]",
+    examples: [
+      "/session:update",
+      "/session:update Fixed authentication bug",
+      '/session:update "Added JWT middleware"'
+    ],
+    content: `Update the current session with progress notes.
+
+## Workflow
+
+Progress notes: $ARGUMENTS
+
+1. **Check Active Session:**
+   - Verify there's an active session
+   - Load session file
+
+2. **Capture Current State:**
+   - Get current git branch
+   - Count git commits
+   - List modified files
+   - Check active Beads task
+
+3. **Add Update:**
+   - Add timestamped update entry
+   - Include your notes (or auto-generate)
+   - Include git state
+   - Include Beads task if active
+
+4. **Save Session:**
+   - Update session file
+   - Confirm update added
+
+## What Gets Captured
+- Timestamp of update
+- Your progress notes
+- Current git branch
+- Number of commits
+- List of modified files
+- Active Beads task (if any)
+
+## Examples
+
+Auto-update (no notes):
+\`\`\`
+/session:update
+\`\`\`
+*Auto-generates summary of recent work*
+
+With specific notes:
+\`\`\`
+/session:update Fixed Next.js params issue
+\`\`\`
+
+With detailed notes:
+\`\`\`
+/session:update "Implemented OAuth flow with Google provider. Added callback handler and token validation."
+\`\`\`
+
+## Notes
+- Must have active session first
+- Updates are timestamped
+- Git state automatically captured
+- Beads task automatically linked`
+  },
+  {
+    name: "session:end",
+    description: "End current session with summary",
+    category: "session",
+    usage: "/session:end",
+    examples: ["/session:end"],
+    content: `End the current session and generate a comprehensive summary.
+
+## Workflow
+
+1. **Check Active Session:**
+   - Verify there's an active session
+   - Load session data
+
+2. **Generate Summary:**
+   - Calculate session duration
+   - Review all progress notes
+   - Check goals completion
+   - Count git commits
+   - List modified files
+   - Identify key accomplishments
+
+3. **Create Summary Section:**
+   - Duration
+   - Goals status
+   - Total updates
+   - Git summary
+   - Key accomplishments
+   - Problems solved
+   - Lessons learned
+
+4. **Close Session:**
+   - Mark session as ended
+   - Set end time
+   - Save session file
+   - Clear .current-session tracker
+
+## Summary Includes
+
+**Session Info:**
+- Duration (hours and minutes)
+- Start and end times
+- Session name
+
+**Goals:**
+- List of all goals
+- Completion status
+
+**Progress:**
+- Number of updates
+- Key accomplishments
+- Problems and solutions
+
+**Git Activity:**
+- Total commits
+- Files modified
+- Branch worked on
+
+**Beads Task:**
+- Linked task ID and status
+
+## Example Output
+\`\`\`
+Session ended: 2025-01-02-1430-auth-refactor
+Duration: 2h 30m
+
+Goals:
+- Refactor OAuth flow \u2705
+- Add JWT support \u2705
+
+Updates: 5
+Commits: 3
+Files Modified: 7
+
+Summary:
+Successfully refactored authentication system with OAuth 2.0
+and JWT token support. Resolved Next.js 15 async issues.
+
+Lessons:
+- Next.js 15 requires await for params
+- JWT middleware order matters
+\`\`\`
+
+## Notes
+- Session cannot be updated after ending
+- Summary is automatically generated
+- Session file persists for future reference
+- Can start new session after ending`
+  },
+  {
+    name: "session:current",
+    description: "Show current active session",
+    category: "session",
+    usage: "/session:current",
+    examples: ["/session:current"],
+    content: `Display information about the current active session.
+
+## Workflow
+
+1. **Check Active Session:**
+   - Read .current-session file
+   - Load session data
+
+2. **Display Session Info:**
+   - Session name and ID
+   - How long session has been active
+   - Session goals
+   - Recent updates (last 3)
+   - Current git state
+   - Active Beads task
+
+3. **Show Actions:**
+   - Available session commands
+   - Quick reminder to update/end
+
+## Example Output
+\`\`\`
+\u{1F4CD} Current Session
+
+Session: authentication-refactor
+ID: 2025-01-02-1430-auth-refactor
+Started: 2 hours ago
+
+Goals:
+- [ ] Refactor OAuth flow
+- [x] Add JWT support
+
+Recent Updates:
+15:45 - Implemented OAuth 2.0 with Google
+16:20 - Added JWT token generation
+
+Git:
+- Branch: feature/auth
+- Commits: 3
+- Modified: 5 files
+
+Beads Task:
+- bead-001 (in-progress)
+
+Commands:
+/session:update [notes] - Add progress
+/session:end - Close session
+\`\`\`
+
+## Notes
+- Shows error if no active session
+- Use to quickly check session status
+- Displays recent progress`
+  },
+  {
+    name: "session:list",
+    description: "List all sessions",
+    category: "session",
+    usage: "/session:list",
+    examples: ["/session:list"],
+    content: `List all development sessions with summaries.
+
+## Workflow
+
+1. **Scan Sessions Directory:**
+   - Find all .md files in .aikit/sessions/
+   - Exclude .current-session
+
+2. **Sort by Date:**
+   - Newest sessions first
+
+3. **Display Summary:**
+   - Session ID and name
+   - Start and end times
+   - Status (active/ended)
+   - Number of updates
+   - Session goals
+
+## Example Output
+\`\`\`
+\u{1F4DA} All Sessions
+
+1. 2025-01-02-1430-auth-refactor
+   Status: Active
+   Started: 2 hours ago
+   Updates: 5
+   Goals: Refactor OAuth, Add JWT
+
+2. 2025-01-02-1200-bug-fix
+   Status: Ended
+   Started: Today 12:00
+   Ended: Today 13:30 (1h 30m)
+   Updates: 3
+   Goals: Fix email bounce handling
+
+3. 2025-01-01-1530-feature-user-profile
+   Status: Ended
+   Started: Yesterday 15:30
+   Ended: Yesterday 18:45 (3h 15m)
+   Updates: 8
+   Goals: Add user profile page
+
+Total: 3 sessions
+\`\`\`
+
+## Notes
+- Shows both active and ended sessions
+- Most recent sessions first
+- Active session highlighted
+- Use /session:show <id> for details`
+  },
+  {
+    name: "session:show",
+    description: "Show details of a specific session",
+    category: "session",
+    usage: "/session:show <session-id>",
+    examples: [
+      "/session:show 2025-01-02-1430",
+      "/session:show 2025-01-02-1430-auth-refactor"
+    ],
+    content: `Display full details of a specific session.
+
+## Workflow
+
+Session ID: $ARGUMENTS
+
+1. **Load Session:**
+   - Find session file
+   - Parse session data
+
+2. **Display Details:**
+   - Session metadata
+   - All progress notes
+   - Git activity timeline
+   - Summary (if ended)
+
+3. **Format Output:**
+   - Readable markdown format
+   - Chronological updates
+   - Key accomplishments
+
+## Example Output
+\`\`\`
+\u{1F4C4} Session: 2025-01-02-1430-auth-refactor
+
+Status: Ended
+Started: 2025-01-02 14:30
+Ended: 2025-01-02 17:00
+Duration: 2h 30m
+
+Goals:
+- [x] Refactor OAuth flow
+- [x] Add JWT support
+
+## Progress
+
+### 2025-01-02 14:30
+Started session: authentication-refactor
+Git Branch: feature/auth
+
+### 2025-01-02 15:45
+Implemented OAuth 2.0 flow with Google provider
+Added callback handler and token validation
+Git Branch: feature/auth
+
+### 2025-01-02 16:20
+Added JWT token generation and validation
+Created middleware for protected routes
+Git Branch: feature/auth
+
+### 2025-01-02 17:00
+Session ended
+
+## Summary
+Duration: 2h 30m
+Goals: 2
+Updates: 4
+Git Commits: 3
+Files Modified: 7
+
+Successfully refactored authentication system...
+\`\`\`
+
+## Notes
+- Use session ID or partial ID
+- Shows all updates chronologically
+- Full session details displayed`
+  },
+  {
+    name: "session:search",
+    description: "Search sessions by keyword",
+    category: "session",
+    usage: "/session:search <query>",
+    examples: [
+      "/session:search oauth",
+      '/session:search "jwt"',
+      "/session:search authentication"
+    ],
+    content: `Search for sessions matching a keyword.
+
+## Workflow
+
+Search query: $ARGUMENTS
+
+1. **Search Sessions:**
+   - Search in session names
+   - Search in session IDs
+   - Search in goals
+   - Search in update notes
+
+2. **Display Results:**
+   - Matching sessions
+   - Highlight match context
+   - Sort by date
+
+3. **Show Actions:**
+   - List matching sessions
+   - Suggest /session:show for details
+
+## Example Output
+\`\`\`
+\u{1F50D} Search Results: "oauth"
+
+Found 2 sessions:
+
+1. 2025-01-02-1430-auth-refactor
+   Match: Name contains "oauth" (case-insensitive)
+   Started: 2 hours ago
+   Status: Active
+   Goals: Refactor OAuth flow, Add JWT
+
+2. 2025-01-01-1200-oauth-fix
+   Match: Goals contain "OAuth"
+   Started: Yesterday
+   Status: Ended
+   Goals: Fix OAuth callback
+
+Total: 2 matching sessions
+\`\`\`
+
+## Notes
+- Case-insensitive search
+- Searches name, goals, and notes
+- Shows matching context
+- Use partial IDs too`
+  },
+  {
+    name: "session:resume",
+    description: "Resume a past session (load context)",
+    category: "session",
+    usage: "/session:resume <session-id>",
+    examples: [
+      "/session:resume latest",
+      "/session:resume 2025-01-02-1430",
+      "/session:resume 2025-01-02-1430-auth-refactor"
+    ],
+    content: `Load context from a past session to resume work.
+
+## Workflow
+
+Session ID: $ARGUMENTS (or "latest")
+
+1. **Find Session:**
+   - If "latest", load most recent session
+   - Otherwise, load specified session
+
+2. **Load Context:**
+   - Display session summary
+   - Show what was accomplished
+   - Show what's remaining
+   - List key decisions made
+
+3. **Suggest Next Actions:**
+   - Based on session goals
+   - Based on remaining tasks
+   - Based on session end notes
+
+4. **Display Session:**
+   - Full session details
+   - All progress notes
+   - Git activity
+   - Summary and lessons
+
+## Example Output
+\`\`\`
+\u{1F504} Resuming Session: 2025-01-02-1430-auth-refactor
+
+## What Was Done
+\u2713 Refactored OAuth flow
+\u2713 Added JWT middleware
+\u2713 Fixed Next.js 15 issues
+
+## What Remains
+\u25CB Add refresh token support
+\u25CB Write tests for auth module
+\u25CB Update documentation
+
+## Key Decisions
+- Used next-auth for OAuth
+- JWT middleware order: auth \u2192 validate \u2192 route
+- Next.js 15 requires async params
+
+## Problems Solved
+- Next.js 15 params Promise issue
+- Cookie domain configuration
+- JWT secret from env var
+
+## Suggested Next Steps
+1. Add refresh token rotation
+2. Write unit tests for auth
+3. Update API documentation
+4. Deploy to staging for testing
+
+Session context loaded! Ready to continue.
+\`\`\`
+
+## Notes
+- Use "latest" for most recent session
+- Loads full context for continuity
+- Suggests next actions based on goals
+- Great for picking up after a break`
+  }
+];
+
+// src/core/commands/drawio.ts
+init_esm_shims();
+var DRAWIO_COMMANDS = [
+  {
+    name: "drawio-interact",
+    description: "Create/edit diagrams with AI + Draw.io + auto-sync",
+    category: "design",
+    usage: "/drawio-interact <create|modify|list|start-sync|stop-sync> [diagram-name]",
+    examples: [
+      "/drawio-interact create login-flow",
+      "/drawio-interact modify login-flow",
+      "/drawio-interact list",
+      "/drawio-interact start-sync",
+      "/drawio-interact stop-sync"
+    ],
+    content: `Interactive diagram workflow with AI + Draw.io + background sync.
+
+**User provided**: $ARGUMENTS
+
+## File Locations
+
+**NEW STRUCTURE**:
+- **Mermaid files**: \`mermaid/[name].mmd\` (project root, version control)
+- **Draw.io files**: \`.aikit/assets/drawio/[name].drawio\` (visual editing)
+
+**Background Sync**:
+- Auto-syncs changes between both formats
+- Runs as background service
+- Detects changes in real-time
+
+## Workflow
+
+### Step 1: Parse User Intent
+
+Check if user wants to:
+- **create** - Generate new diagram and open in Draw.io
+- **modify** - Manual sync (if background sync not running)
+- **list** - Show all existing diagrams
+- **start-sync** - Start background sync service
+- **stop-sync** - Stop background sync service
+
+### Step 2: Create Diagram (if "create")
+
+**Action**: Generate diagram from description, create files, open in Draw.io
+
+1. **Extract diagram name** from arguments
+   - "create login-flow" \u2192 name = "login-flow"
+   - If no name provided, ask user
+
+2. **Generate Mermaid code** based on description:
+   - Login/auth \u2192 Flowchart with authentication
+   - Order/purchase \u2192 Flowchart with payment
+   - API/request \u2192 Sequence diagram
+   - Generic \u2192 Basic flowchart
+
+3. **Create files**:
+   - \`mermaid/[name].mmd\` - Mermaid source
+   - \`.aikit/assets/drawio/[name].drawio\` - Draw.io XML
+
+4. **Open in Draw.io with auto-sync**:
+   - Use lifecycle manager for automatic sync start/stop
+   - Sync starts when Draw.io opens
+   - Sync stops when Draw.io closes
+   - No manual intervention needed!
+
+**Implementation**: Use lifecycle manager
+
+\`\`\`javascript
+import { openDrawioWithAutoSync } from '.aikit/tools/drawio-sync/lifecycle-manager.js';
+import { join } from 'path';
+
+const projectRoot = process.cwd();
+const drawioPath = join(projectRoot, '.aikit/assets/drawio', \`\${name}.drawio\`);
+
+// This will:
+// 1. Start sync service automatically
+// 2. Open Draw.io app
+// 3. Monitor Draw.io process
+// 4. Stop sync when Draw.io closes
+await openDrawioWithAutoSync(drawioPath);
+\`\`\`
+
+**What happens**:
+- \u2705 Sync service starts automatically
+- \u2705 Draw.io opens
+- \u2705 Files stay in sync while editing
+- \u2705 Sync stops automatically when Draw.io closes
+- \u2705 Zero manual intervention!
+
+5. **Report success**:
+   - Show generated Mermaid code
+   - Confirm file locations
+   - Confirm Draw.io opened with auto-sync
+   - Inform user: "Sync will stop automatically when you close Draw.io"
+
+### Step 3: Modify Diagram (if "modify")
+
+**Action**: Manual one-time sync (use if background sync not running)
+
+1. **Extract diagram name**
+2. **Read files**:
+   - \`mermaid/[name].mmd\`
+   - \`.aikit/assets/drawio/[name].drawio\`
+
+3. **Convert Draw.io \u2192 Mermaid**
+4. **Detect changes**
+5. **Update Mermaid file**
+6. **Report changes**
+
+**Note**: If background sync is running, this is automatic!
+
+### Step 4: List Diagrams (if "list")
+
+**Action**: Show all diagrams
+
+\`\`\`bash
+ls mermaid/*.mmd 2>/dev/null | sed 's/mermaid\\///' | sed 's/.mmd$//'
+\`\`\`
+
+Format as numbered list with file info.
+
+### Step 5: Start Sync (if "start-sync")
+
+**Action**: Start background sync service
+
+1. **Check if service already running**
+2. **Start Chokidar file watcher**:
+   - Watch \`mermaid/*.mmd\`
+   - Watch \`.aikit/assets/drawio/*.drawio\`
+3. **Auto-sync on change**:
+   - Debounce: 500ms
+   - Lock files during sync to prevent loops
+   - Log all changes
+4. **Report**: "Background sync running"
+
+**Implementation**: Use .aikit/tools/drawio-sync/sync-service.js
+
+\`\`\`javascript
+import { startSyncService } from '.aikit/tools/drawio-sync/sync-service.js';
+startSyncService();
+\`\`\`
+
+### Step 6: Stop Sync (if "stop-sync")
+
+**Action**: Stop background sync service
+
+\`\`\`javascript
+import { stopSyncService } from '.aikit/tools/drawio-sync/sync-service.js';
+stopSyncService();
+\`\`\`
+
+## Conversion Tools
+
+**Location**: \`.aikit/tools/drawio-sync/\`
+
+**Modules**:
+- \`mermaid-to-drawio.js\` - Mermaid \u2192 Draw.io conversion
+- \`drawio-to-mermaid.js\` - Draw.io \u2192 Mermaid conversion
+- \`sync-service.js\` - Background sync service
+- \`lifecycle-manager.js\` - **NEW!** Automatic lifecycle (start/stop sync with Draw.io)
+
+**Lifecycle Manager Usage** (recommended for "create" command):
+\`\`\`javascript
+import { openDrawioWithAutoSync } from '.aikit/tools/drawio-sync/lifecycle-manager.js';
+import { join } from 'path';
+
+const drawioPath = join(process.cwd(), '.aikit/assets/drawio', name + '.drawio');
+
+// Automatically:
+// - Starts sync when Draw.io opens
+// - Stops sync when Draw.io closes
+await openDrawioWithAutoSync(drawioPath);
+\`\`\`
+
+**Manual Conversion** (for "modify" command):
+\`\`\`javascript
+import { convertMermaidToDrawio } from '.aikit/tools/drawio-sync/mermaid-to-drawio.js';
+import { convertDrawioToMermaid } from '.aikit/tools/drawio-sync/drawio-to-mermaid.js';
+
+// Mermaid \u2192 Draw.io
+const result = convertMermaidToDrawio(mermaidCode, diagramName);
+fs.writeFileSync('.aikit/assets/drawio/name.drawio', result.xml, 'utf-8');
+
+// Draw.io \u2192 Mermaid
+const result = convertDrawioToMermaid(drawioXML);
+fs.writeFileSync('mermaid/name.mmd', result.code, 'utf-8');
+\`\`\`
+
+## Error Handling
+
+**If sync fails**:
+1. Log error to console
+2. Show notification: "Sync failed for [name]"
+3. **Ask user**:
+   - Ignore this error?
+   - Retry sync?
+   - Let AI fix it?
+
+**AI Fix Option**:
+- Analyze error
+- Attempt to fix common issues:
+  - Malformed Mermaid syntax
+  - Invalid XML characters
+  - Encoding issues
+  - Missing nodes
+- Retry sync after fix
+- Report result
+
+## Example Session
+
+\`\`\`
+User: /drawio-interact create user-authentication
+
+AI: Creating diagram: user-authentication
+
+\u{1F4C4} Generated Mermaid Code:
+graph TD
+    User[User] -->|Login| Login[Login Page]
+    Login -->|Success| Dashboard[Dashboard]
+
+\u2705 Files created:
+   - mermaid/user-authentication.mmd
+   - .aikit/assets/drawio/user-authentication.drawio
+
+\u{1F504} Starting background sync service...
+\u2705 Sync service running
+
+\u{1F3A8} Opening Draw.io...
+\u{1F440} Monitoring Draw.io app (sync will stop when Draw.io closes)
+
+---
+
+[User edits in Draw.io, adds "Password Recovery", saves]
+
+\u{1F504} Background sync detected changes:
+   \u2022 Added nodes: Recovery, ResetEmail
+   \u2022 Modified connections: Login \u2192 Recovery
+
+\u2705 Updated: mermaid/user-authentication.mmd
+
+[Or user edits mermaid/user-authentication.mmd directly]
+
+\u{1F504} Background sync detected changes:
+   \u2022 Modified Mermaid syntax
+
+\u2705 Updated: .aikit/assets/drawio/user-authentication.drawio
+
+---
+
+[User closes Draw.io app]
+
+\u{1F3A8} Draw.io closed - stopping sync service
+\u2705 Sync service stopped
+\`\`\`
+
+**Key Point**: Sync starts automatically when Draw.io opens, and stops automatically when Draw.io closes. No manual commands needed!
+
+## Important Notes
+
+- **Auto-sync lifecycle** - Sync starts when Draw.io opens, stops when it closes
+- **Zero manual intervention** - No need to run start/stop commands
+- **Draw.io app** opens automatically on "create"
+- **Both formats** stay in sync automatically while Draw.io is open
+- **Mermaid files** are in project root for version control
+- **Draw.io files** are in .aikit/assets (can be .gitignored)
+- **Manual commands** (start-sync/stop-sync) only needed for special cases
+
+## Auto-Open Commands
+
+**IMPORTANT**: Always use absolute paths!
+
+**Example code**:
+\`\`\`javascript
+const platform = process.platform;
+const projectRoot = process.cwd();  // Get absolute project root
+const filePath = join(projectRoot, '.aikit/assets/drawio', name + '.drawio');
+
+if (platform === 'darwin') {
+  // macOS: Use double quotes for path with spaces
+  execSync('open -a "Draw.io" "' + filePath + '"');
+} else if (platform === 'linux') {
+  // Linux
+  execSync('xdg-open "' + filePath + '"');
+} else if (platform === 'win32') {
+  // Windows
+  execSync('start "" "' + filePath + '"', { shell: true });
+}
+\`\`\`
+
+**Why absolute paths?**
+- Relative paths depend on current working directory
+- Claude/AI might execute from wrong directory
+- Absolute paths always work correctly
+
+**Fallback**: If Draw.io app not found, open https://app.diagrams.net/
+
+## Directory Setup
 
-1. Determine log location
-2. Apply filters if specified
-3. Display logs
-4. If --follow, stream updates
-5. Format for readability`
+Ensure directories exist:
+\`\`\`bash
+mkdir -p mermaid
+mkdir -p .aikit/assets/drawio
+\`\`\``
   }
 ];
+
+// src/core/commands/index.ts
+var DEFAULT_COMMANDS = [
+  ...CORE_COMMANDS,
+  ...QUICK_COMMANDS,
+  ...RESEARCH_COMMANDS,
+  ...DESIGN_COMMANDS,
+  ...GIT_COMMANDS,
+  ...UTILITY_COMMANDS,
+  ...CHECKPOINT_COMMANDS,
+  ...SESSION_COMMANDS,
+  ...DRAWIO_COMMANDS
+];
 var CommandRunner = class {
   config;
   commandsCache = /* @__PURE__ */ new Map();
@@ -4591,17 +6410,17 @@ export default ${toPascalCase(name)}Plugin;
           event: async (event) => {
             if (event.type === "session.idle") {
               try {
-                const { exec: exec2 } = await import("child_process");
-                const { promisify: promisify2 } = await import("util");
-                const execAsync2 = promisify2(exec2);
+                const { exec: exec3 } = await import("child_process");
+                const { promisify: promisify3 } = await import("util");
+                const execAsync3 = promisify3(exec3);
                 const platform = process.platform;
                 const summary = event.properties?.summary || "Session completed";
                 if (platform === "darwin") {
-                  await execAsync2(`osascript -e 'display notification "${summary}" with title "OpenCode Session Complete"'`);
+                  await execAsync3(`osascript -e 'display notification "${summary}" with title "OpenCode Session Complete"'`);
                 } else if (platform === "linux") {
-                  await execAsync2(`notify-send "OpenCode Session Complete" "${summary}"`);
+                  await execAsync3(`notify-send "OpenCode Session Complete" "${summary}"`);
                 } else if (platform === "win32") {
-                  await execAsync2(`powershell -Command "New-BurntToastNotification -Text 'OpenCode Session Complete', '${summary}'"`);
+                  await execAsync3(`powershell -Command "New-BurntToastNotification -Text 'OpenCode Session Complete', '${summary}'"`);
                 }
               } catch (error) {
                 logger.warn(`[Notification] Failed to send notification: ${error instanceof Error ? error.message : String(error)}`);
@@ -4652,9 +6471,15 @@ init_beads();
 // src/utils/cli-detector.ts
 init_esm_shims();
 import { execSync } from "child_process";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { join as join12 } from "path";
 import { homedir as homedir2 } from "os";
+var CliPlatform = /* @__PURE__ */ ((CliPlatform2) => {
+  CliPlatform2["OPENCODE"] = "opencode";
+  CliPlatform2["CLAUDE"] = "claude";
+  CliPlatform2["CODEX"] = "codex";
+  return CliPlatform2;
+})(CliPlatform || {});
 var CliDetector = class {
   /**
    * Check if OpenCode is installed
@@ -4663,14 +6488,14 @@ var CliDetector = class {
     try {
       const opencodePath = process.platform === "win32" ? process.env.APPDATA || join12(homedir2(), "AppData", "Roaming") : join12(homedir2(), ".config");
       const opencodeConfig = join12(opencodePath, "opencode", "opencode.json");
-      let installed = existsSync4(opencodeConfig);
+      let installed = existsSync5(opencodeConfig);
       let version;
       if (installed) {
         try {
           execSync("opencode --version", { stdio: "ignore" });
           version = "installed";
         } catch (error) {
-          if (existsSync4(opencodeConfig)) {
+          if (existsSync5(opencodeConfig)) {
             version = "installed (config exists)";
           } else {
             installed = false;
@@ -4762,6 +6587,47 @@ var CliDetector = class {
   static filterInstallable(tools) {
     return tools.filter((t) => t.detected && !t.installed);
   }
+  /**
+   * Detect available platforms
+   */
+  static async detectPlatforms() {
+    const platforms = [];
+    const opencodePath = process.platform === "win32" ? process.env.APPDATA || join12(homedir2(), "AppData", "Roaming") : join12(homedir2(), ".config");
+    platforms.push({
+      platform: "opencode" /* OPENCODE */,
+      displayName: "OpenCode",
+      installed: existsSync5(join12(opencodePath, "opencode", "opencode.json")),
+      configPath: opencodePath
+    });
+    const claudePath = process.platform === "win32" ? process.env.APPDATA || join12(homedir2(), "AppData", "Roaming") : join12(homedir2(), ".claude");
+    platforms.push({
+      platform: "claude" /* CLAUDE */,
+      displayName: "Claude Code CLI",
+      installed: existsSync5(claudePath),
+      configPath: claudePath
+    });
+    return platforms;
+  }
+  /**
+   * Filter installed platforms
+   */
+  static filterInstalledPlatforms(platforms) {
+    return platforms.filter((p) => p.installed);
+  }
+  /**
+   * Match platform name to CliPlatform enum
+   */
+  static matchPlatform(name) {
+    const normalized = name.toLowerCase();
+    if (normalized === "opencode" || normalized === "open-code") {
+      return "opencode" /* OPENCODE */;
+    } else if (normalized === "claude" || normalized === "claude-code" || normalized === "claude-code-cli") {
+      return "claude" /* CLAUDE */;
+    } else if (normalized === "codex") {
+      return "codex" /* CODEX */;
+    }
+    throw new Error(`Unknown platform: ${name}`);
+  }
 };
 
 // src/cli/commands/init.ts
@@ -4770,9 +6636,9 @@ init_paths();
 
 // src/cli/helpers.ts
 init_esm_shims();
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir8, writeFile as writeFile8, readFile as readFile7, access as access4 } from "fs/promises";
-import { join as join13, dirname as dirname2 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir9, writeFile as writeFile9, readFile as readFile8, access as access5 } from "fs/promises";
+import { join as join14, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execSync as execSync2 } from "child_process";
@@ -4798,7 +6664,7 @@ async function initializeConfig(configDir, _isGlobal) {
     "memory/research"
   ];
   for (const dir of dirs) {
-    await mkdir8(join13(configDir, dir), { recursive: true });
+    await mkdir9(join14(configDir, dir), { recursive: true });
   }
   const defaultConfig = {
     version: getVersion(),
@@ -4811,8 +6677,8 @@ async function initializeConfig(configDir, _isGlobal) {
     beads: { enabled: true },
     antiHallucination: { enabled: true }
   };
-  await writeFile8(
-    join13(configDir, "aikit.json"),
+  await writeFile9(
+    join14(configDir, "aikit.json"),
     JSON.stringify(defaultConfig, null, 2)
   );
   const agentsMd = `# AIKit Agent Rules
@@ -4835,20 +6701,20 @@ async function initializeConfig(configDir, _isGlobal) {
 ## Project-Specific Rules
 Add your project-specific rules here.
 `;
-  await writeFile8(join13(configDir, "AGENTS.md"), agentsMd);
+  await writeFile9(join14(configDir, "AGENTS.md"), agentsMd);
 }
 async function configureMcpServer(projectPath) {
   const currentFile = fileURLToPath3(import.meta.url);
   const currentDir = dirname2(currentFile);
-  const aikitPath = join13(currentDir, "..", "..");
-  const mcpServerPath = join13(aikitPath, "dist", "mcp-server.js");
+  const aikitPath = join14(currentDir, "..", "..");
+  const mcpServerPath = join14(aikitPath, "dist", "mcp-server.js");
   const configLocations = [
     // Global config (most common)
-    join13(homedir3(), ".config", "opencode", "opencode.json"),
+    join14(homedir3(), ".config", "opencode", "opencode.json"),
     // Project-level config
-    join13(projectPath, ".opencode", "opencode.json"),
+    join14(projectPath, ".opencode", "opencode.json"),
     // Alternative global location
-    join13(homedir3(), ".opencode", "opencode.json")
+    join14(homedir3(), ".opencode", "opencode.json")
   ];
   const mcpServerConfig = {
     type: "local",
@@ -4857,12 +6723,12 @@ async function configureMcpServer(projectPath) {
   };
   for (const configPath of configLocations) {
     try {
-      const configDir = join13(configPath, "..");
-      await mkdir8(configDir, { recursive: true });
+      const configDir = join14(configPath, "..");
+      await mkdir9(configDir, { recursive: true });
       let config = {};
-      if (existsSync5(configPath)) {
+      if (existsSync6(configPath)) {
         try {
-          const existing = await readFile7(configPath, "utf-8");
+          const existing = await readFile8(configPath, "utf-8");
           config = JSON.parse(existing);
         } catch {
           config = {};
@@ -4872,7 +6738,7 @@ async function configureMcpServer(projectPath) {
         config.mcp = {};
       }
       config.mcp.aikit = mcpServerConfig;
-      await writeFile8(configPath, JSON.stringify(config, null, 2));
+      await writeFile9(configPath, JSON.stringify(config, null, 2));
       logger.success(`
 \u2705 MCP server configured: ${configPath}`);
       logger.info(`   Server: node ${mcpServerPath}`);
@@ -4881,9 +6747,9 @@ async function configureMcpServer(projectPath) {
       continue;
     }
   }
-  const instructionsPath = join13(projectPath, ".opencode", "MCP_SETUP.md");
-  await mkdir8(join13(projectPath, ".opencode"), { recursive: true });
-  await writeFile8(instructionsPath, `# AIKit MCP Server Configuration
+  const instructionsPath = join14(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir9(join14(projectPath, ".opencode"), { recursive: true });
+  await writeFile9(instructionsPath, `# AIKit MCP Server Configuration
 
 ## Automatic Setup Failed
 
@@ -4930,13 +6796,24 @@ async function installCliTool(tool) {
         await installToOpenCode(paths.opencodeConfig());
         break;
       case "claude" /* CLAUDE */:
-        execSync2("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+        let platform;
+        try {
+          platform = process.platform;
+        } catch {
+          platform = "darwin";
+        }
+        if (platform === "darwin") {
+          execSync2("curl -fsSL https://claude.ai/install.sh | bash", { stdio: "inherit" });
+        } else if (platform === "win32") {
+          execSync2('powershell -Command "irm https://claude.ai/install.ps1 | iex"', { stdio: "inherit" });
+        } else {
+          execSync2("curl -fsSL https://claude.ai/install.sh | bash", { stdio: "inherit" });
+        }
         break;
       case "github" /* GITHUB */:
         execSync2("npm install -g gh", { stdio: "inherit" });
         break;
     }
-    logger.success(`\u2713 ${tool.displayName} installed`);
     return true;
   } catch (error) {
     logger.error(`Failed to install ${tool.displayName}:`, error);
@@ -5125,26 +7002,26 @@ Report what was extracted:
 }
 async function installToOpenCode(_opencodePath) {
   const projectPath = process.cwd();
-  const opencodeCommandDir = join13(projectPath, ".opencode", "command");
-  const aikitDir = join13(projectPath, ".aikit");
-  const opencodeAgentDir = join13(paths.opencodeConfig(), "agent");
-  await mkdir8(opencodeCommandDir, { recursive: true });
-  await mkdir8(join13(aikitDir, "skills"), { recursive: true });
-  await mkdir8(opencodeAgentDir, { recursive: true });
+  const opencodeCommandDir = join14(projectPath, ".opencode", "command");
+  const aikitDir = join14(projectPath, ".aikit");
+  const opencodeAgentDir = join14(paths.opencodeConfig(), "agent");
+  await mkdir9(opencodeCommandDir, { recursive: true });
+  await mkdir9(join14(aikitDir, "skills"), { recursive: true });
+  await mkdir9(opencodeAgentDir, { recursive: true });
   for (const [name, content] of Object.entries(AGENT_FILES)) {
-    const filePath = join13(opencodeAgentDir, `${name}.md`);
+    const filePath = join14(opencodeAgentDir, `${name}.md`);
     try {
-      await access4(filePath);
-      const existingContent = await readFile7(filePath, "utf8");
+      await access5(filePath);
+      const existingContent = await readFile8(filePath, "utf8");
       if (!existingContent.includes("mode: subagent")) {
-        const matter3 = await import("gray-matter");
-        const { data: frontmatter, content: body } = matter3.default(existingContent);
+        const matter5 = await import("gray-matter");
+        const { data: frontmatter, content: body } = matter5.default(existingContent);
         frontmatter.mode = "subagent";
-        const updatedContent = matter3.default.stringify(body, frontmatter);
-        await writeFile8(filePath, updatedContent, "utf8");
+        const updatedContent = matter5.default.stringify(body, frontmatter);
+        await writeFile9(filePath, updatedContent, "utf8");
       }
     } catch {
-      await writeFile8(filePath, content, "utf8");
+      await writeFile9(filePath, content, "utf8");
     }
   }
   const config = await loadConfig();
@@ -5236,8 +7113,8 @@ ${cmd.content}
   }
   let count = 0;
   for (const [name, content] of Object.entries(opencodeCommands)) {
-    const filePath = join13(opencodeCommandDir, `${name}.md`);
-    await writeFile8(filePath, content.trim());
+    const filePath = join14(opencodeCommandDir, `${name}.md`);
+    await writeFile9(filePath, content.trim());
     logger.info(`  \u2713 Created /${name} command`);
     count++;
   }
@@ -5258,10 +7135,541 @@ function groupBy(array, keyFn) {
     return acc;
   }, {});
 }
+async function startSession(name, goals) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.startSession(name, goals);
+    logger.success("\u2713 Session started");
+    console.log(`  ID: ${session.id}`);
+    console.log(`  Name: ${session.name}`);
+    console.log(`  Started: ${new Date(session.startTime).toLocaleString()}`);
+    if (session.goals.length > 0) {
+      console.log(`  Goals:`);
+      session.goals.forEach((goal) => console.log(`    - ${goal}`));
+    }
+    console.log("\nCommands:");
+    console.log("  /session:update [notes] - Add progress notes");
+    console.log("  /session:end - End session with summary");
+    console.log("  /session:current - Show session status\n");
+  } catch (error) {
+    logger.error("Failed to start session:", error);
+  }
+}
+async function updateSession(notes) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.updateSession(notes);
+    if (session) {
+      logger.success("\u2713 Session updated");
+      console.log(`  Session: ${session.id}`);
+      console.log(`  Notes: ${notes || "Auto-generated"}`);
+      console.log(`  Time: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+      if (session.updates[session.updates.length - 1]?.modifiedFiles) {
+        const files = session.updates[session.updates.length - 1].modifiedFiles;
+        console.log(`  Modified: ${files?.length} files`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("No active session")) {
+      logger.error("No active session. Use /session:start first");
+    } else {
+      logger.error("Failed to update session:", error);
+    }
+  }
+}
+async function endSession() {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.endSession();
+    if (session) {
+      const duration = session.endTime ? Math.floor((new Date(session.endTime).getTime() - new Date(session.startTime).getTime()) / 6e4) : 0;
+      logger.success("\u2713 Session ended");
+      console.log(`
+Session: ${session.id}`);
+      console.log(`Name: ${session.name}`);
+      console.log(`Duration: ${Math.floor(duration / 60)}h ${duration % 60}m`);
+      console.log(`Updates: ${session.updates.length}`);
+      if (session.goals.length > 0) {
+        console.log(`
+Goals:`);
+        session.goals.forEach((goal) => console.log(`  - ${goal}`));
+      }
+      const lastUpdate = session.updates[session.updates.length - 1];
+      if (lastUpdate?.gitCommits) {
+        console.log(`
+Git Activity:`);
+        console.log(`  Commits: ${lastUpdate.gitCommits}`);
+        if (lastUpdate.modifiedFiles && lastUpdate.modifiedFiles.length > 0) {
+          console.log(`  Files Modified: ${lastUpdate.modifiedFiles.length}`);
+        }
+      }
+      console.log(`
+Use /session:show ${session.id} for details
+`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("No active session")) {
+      logger.error("No active session. Use /session:start first");
+    } else {
+      logger.error("Failed to end session:", error);
+    }
+  }
+}
+async function showCurrentSession() {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.getCurrentSession();
+    if (!session) {
+      logger.info("No active session");
+      console.log("Start a session: /session:start [name]\n");
+      return;
+    }
+    const duration = Math.floor((Date.now() - new Date(session.startTime).getTime()) / 6e4);
+    console.log("\n\u{1F4CD} Current Session");
+    console.log("\u2501".repeat(60));
+    console.log(`
+Session: ${session.name}`);
+    console.log(`ID: ${session.id}`);
+    console.log(`Started: ${Math.floor(duration / 60)}h ${duration % 60}m ago`);
+    if (session.goals.length > 0) {
+      console.log(`
+Goals:`);
+      session.goals.forEach((goal) => console.log(`  - ${goal}`));
+    }
+    if (session.updates.length > 0) {
+      console.log(`
+Recent Updates (last 3):`);
+      const recent = session.updates.slice(-3);
+      recent.forEach((update) => {
+        const date = new Date(update.timestamp);
+        console.log(`  ${date.toLocaleTimeString()} - ${update.notes || "Update"}`);
+      });
+    }
+    const lastUpdate = session.updates[session.updates.length - 1];
+    if (lastUpdate?.gitBranch || lastUpdate?.gitCommits) {
+      console.log(`
+Git:`);
+      if (lastUpdate.gitBranch) console.log(`  Branch: ${lastUpdate.gitBranch}`);
+      if (lastUpdate.gitCommits) console.log(`  Commits: ${lastUpdate.gitCommits}`);
+      if (lastUpdate.modifiedFiles && lastUpdate.modifiedFiles.length > 0) {
+        console.log(`  Modified: ${lastUpdate.modifiedFiles.length} files`);
+      }
+    }
+    if (lastUpdate?.beadsTask) {
+      console.log(`
+Beads Task:`);
+      console.log(`  ${lastUpdate.beadsTask.id} (${lastUpdate.beadsTask.status})`);
+    }
+    console.log("\nCommands:");
+    console.log("  /session:update [notes] - Add progress");
+    console.log("  /session:end - Close session");
+    console.log("\u2501".repeat(60) + "\n");
+  } catch (error) {
+    logger.error("Failed to show current session:", error);
+  }
+}
+async function listSessions() {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const sessions = await manager.listSessions();
+    if (sessions.length === 0) {
+      logger.info("No sessions found");
+      console.log("Start a session: /session:start [name]\n");
+      return;
+    }
+    console.log("\n\u{1F4DA} All Sessions");
+    console.log("\u2501".repeat(60));
+    sessions.forEach((session, index) => {
+      const startDate = new Date(session.startTime);
+      const endDate = session.endTime ? new Date(session.endTime) : null;
+      const duration = endDate ? Math.floor((endDate.getTime() - startDate.getTime()) / 6e4) : null;
+      console.log(`
+${index + 1}. ${session.id}`);
+      console.log(`   Status: ${session.status === "active" ? "\u{1F7E2} Active" : "Ended"}`);
+      console.log(`   Name: ${session.name}`);
+      console.log(`   Started: ${startDate.toLocaleString()}`);
+      if (endDate && duration) {
+        console.log(`   Ended: ${endDate.toLocaleString()} (${Math.floor(duration / 60)}h ${duration % 60}m)`);
+      }
+      if (session.goals.length > 0) {
+        console.log(`   Goals: ${session.goals.slice(0, 2).join(", ")}${session.goals.length > 2 ? "..." : ""}`);
+      }
+      console.log(`   Updates: ${session.updates.length}`);
+    });
+    console.log("\n" + "\u2501".repeat(60));
+    console.log(`
+Total: ${sessions.length} session${sessions.length > 1 ? "s" : ""}
+`);
+    console.log("Commands:");
+    console.log("  /session:show <id> - View session details");
+    console.log("  /session:resume <id> - Resume session");
+    console.log("  /session:search <query> - Search sessions\n");
+  } catch (error) {
+    logger.error("Failed to list sessions:", error);
+  }
+}
+async function showSession(sessionId) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const sessions = await manager.listSessions();
+    const session = sessions.find((s) => s.id.startsWith(sessionId) || s.id === sessionId);
+    if (!session) {
+      logger.error(`Session not found: ${sessionId}`);
+      console.log("Use /session:list to see all sessions\n");
+      return;
+    }
+    const startDate = new Date(session.startTime);
+    const endDate = session.endTime ? new Date(session.endTime) : null;
+    const duration = endDate ? Math.floor((endDate.getTime() - startDate.getTime()) / 6e4) : null;
+    console.log("\n\u{1F4C4} Session: " + session.id);
+    console.log("\u2501".repeat(60));
+    console.log(`
+Status: ${session.status === "active" ? "\u{1F7E2} Active" : "Ended"}`);
+    console.log(`Name: ${session.name}`);
+    console.log(`Started: ${startDate.toLocaleString()}`);
+    if (endDate && duration) {
+      console.log(`Ended: ${endDate.toLocaleString()}`);
+      console.log(`Duration: ${Math.floor(duration / 60)}h ${duration % 60}m`);
+    }
+    if (session.goals.length > 0) {
+      console.log(`
+Goals:`);
+      session.goals.forEach((goal) => console.log(`  ${session.status === "ended" ? "\u2713" : "\u25CB"} ${goal}`));
+    }
+    console.log(`
+## Progress (${session.updates.length} updates)`);
+    session.updates.forEach((update) => {
+      const date = new Date(update.timestamp);
+      console.log(`
+### ${date.toLocaleString()}`);
+      if (update.notes) console.log(`${update.notes}`);
+      if (update.gitBranch) console.log(`**Git Branch:** ${update.gitBranch}`);
+      if (update.modifiedFiles && update.modifiedFiles.length > 0) {
+        console.log(`**Modified Files:** ${update.modifiedFiles.length} files`);
+      }
+      if (update.beadsTask) {
+        console.log(`**Beads Task:** ${update.beadsTask.id} (${update.beadsTask.status})`);
+      }
+    });
+    if (session.status === "ended") {
+      console.log(`
+## Summary`);
+      console.log(`Duration: ${duration ? Math.floor(duration / 60) + "h " + duration % 60 + "m" : "N/A"}`);
+      console.log(`Updates: ${session.updates.length}`);
+      if (session.updates[session.updates.length - 1]?.gitCommits) {
+        console.log(`Git Commits: ${session.updates[session.updates.length - 1].gitCommits}`);
+      }
+    }
+    console.log("\n" + "\u2501".repeat(60) + "\n");
+  } catch (error) {
+    logger.error("Failed to show session:", error);
+  }
+}
+async function searchSessions(query) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const sessions = await manager.searchSessions(query);
+    if (sessions.length === 0) {
+      logger.info(`No sessions found matching: ${query}`);
+      console.log("Use /session:list to see all sessions\n");
+      return;
+    }
+    console.log(`
+\u{1F50D} Search Results: "${query}"`);
+    console.log("\u2501".repeat(60));
+    console.log(`
+Found ${sessions.length} session${sessions.length > 1 ? "s" : ""}:
+`);
+    sessions.forEach((session, index) => {
+      const startDate = new Date(session.startTime);
+      console.log(`${index + 1}. ${session.id}`);
+      console.log(`   Name: ${session.name}`);
+      console.log(`   Started: ${startDate.toLocaleString()}`);
+      console.log(`   Status: ${session.status === "active" ? "\u{1F7E2} Active" : "Ended"}`);
+      if (session.goals.length > 0) {
+        console.log(`   Goals: ${session.goals.slice(0, 2).join(", ")}${session.goals.length > 2 ? "..." : ""}`);
+      }
+      console.log();
+    });
+    console.log("\u2501".repeat(60));
+    console.log(`
+Total: ${sessions.length} matching session${sessions.length > 1 ? "s" : ""}
+`);
+    console.log("Commands:");
+    console.log("  /session:show <id> - View session details");
+    console.log("  /session:resume <id> - Resume session\n");
+  } catch (error) {
+    logger.error("Failed to search sessions:", error);
+  }
+}
+
+// src/platform/adapters.ts
+init_esm_shims();
+
+// src/platform/opencode-adapter.ts
+init_esm_shims();
+init_paths();
+import { readFile as readFile9, writeFile as writeFile10, mkdir as mkdir10, access as access6 } from "fs/promises";
+import { join as join15 } from "path";
+var OpenCodeAdapter = class {
+  platform = "opencode" /* OPENCODE */;
+  displayName = "OpenCode";
+  getCommandsDir() {
+    return join15(process.cwd(), ".opencode", "command");
+  }
+  getSkillsDir() {
+    return join15(process.cwd(), ".opencode", "skill");
+  }
+  getAgentsDir() {
+    return join15(paths.opencodeConfig(), "agent");
+  }
+  async transformCommand(command) {
+    const name = `ak_cm_${command.name}`;
+    const content = this.generateCommandContent(command);
+    return { name, content };
+  }
+  async transformSkill(skill) {
+    const skillName = `ak_sk_${skill.name}`;
+    const skillContent = this.generateSkillContent(skill);
+    const result = {
+      name: skillName,
+      directory: "",
+      files: { [`${skillName}.md`]: skillContent }
+    };
+    return result;
+  }
+  async transformAgent(agent) {
+    const name = agent.name === "build" || agent.name === "planner" ? `aikit${agent.name}` : agent.name;
+    const content = this.generateAgentContent(agent, name);
+    return { name, content };
+  }
+  async installCommand(name, content) {
+    const dir = this.getCommandsDir();
+    await mkdir10(dir, { recursive: true });
+    await writeFile10(join15(dir, `${name}.md`), content);
+  }
+  async installSkill(_name, directory, files) {
+    const baseDir = this.getSkillsDir();
+    const targetDir = directory ? join15(baseDir, directory) : baseDir;
+    await mkdir10(targetDir, { recursive: true });
+    for (const [filename, content] of Object.entries(files)) {
+      await writeFile10(join15(targetDir, filename), content);
+    }
+  }
+  async installAgent(name, content) {
+    const dir = this.getAgentsDir();
+    await mkdir10(dir, { recursive: true });
+    const filePath = join15(dir, `${name}.md`);
+    try {
+      await access6(filePath);
+      const existingContent = await readFile9(filePath, "utf-8");
+      if (!existingContent.includes("mode: subagent")) {
+        const matter5 = await import("gray-matter");
+        const { data: frontmatter, content: body } = matter5.default(existingContent);
+        frontmatter.mode = "subagent";
+        const updatedContent = matter5.default.stringify(body, frontmatter);
+        await writeFile10(filePath, updatedContent, "utf-8");
+      }
+    } catch {
+      await writeFile10(filePath, content, "utf-8");
+    }
+  }
+  generateCommandContent(command) {
+    const examples = command.examples.map((e) => {
+      const prefixed = e.replace(/\//g, "/ak_cm_");
+      return `- \`${prefixed}\``;
+    }).join("\n");
+    return `# Command: /ak_cm_${command.name}
+
+## Description
+${command.description}
+
+## Usage
+\`${command.usage.replace(/\//g, "/ak_cm_")}\`
+
+## Examples
+${examples}
+
+## \u26A0\uFE0F CRITICAL: The User Has Already Provided Arguments!
+
+**The user has provided arguments with this command!**
+
+The arguments are available in this command response - look at the command workflow below, which now includes explicit instructions to use the provided arguments.
+
+**YOUR JOB**:
+1. Follow the command workflow steps
+2. The workflow will tell you to look at "Arguments Provided" section
+3. Use those arguments - do NOT ask the user for this information!
+4. They have already provided it - extract and use it!
+
+**Example Scenario**:
+- User runs: \`/ak_cm_${command.name} snake game with html & css\`
+- Command: \`/ak_cm_${command.name}\`
+- Arguments to use: \`snake game with html & css\`
+- You must use "snake game with html & css" as provided in the workflow!
+
+**DO NOT**: Ask "Please provide a task description"
+**DO**: Follow the workflow and use the arguments provided in it!
+
+## Workflow
+${command.content}
+
+**Category**: ${command.category}`;
+  }
+  generateSkillContent(skill) {
+    const relativePath = skill.filePath.startsWith(process.cwd()) ? skill.filePath.replace(process.cwd(), "").replace(/\\/g, "/").replace(/^\//, "") : `.aikit/skills/${skill.name}.md`;
+    return `Use the **${skill.name} skill** ${skill.useWhen.toLowerCase()}.
+
+READ ${relativePath}
+
+## Description
+${skill.description}
+
+## When to Use
+${skill.useWhen}
+
+## Workflow
+${skill.content.split("\n").slice(0, 20).join("\n")}${skill.content.split("\n").length > 20 ? "\n\n... (see full skill file for complete workflow)" : ""}
+
+**IMPORTANT**: Follow this skill's workflow step by step. Do not skip steps.
+Complete the checklist at the end of the skill.`;
+  }
+  generateAgentContent(agent, nameOverride) {
+    return `---
+name: ${nameOverride || agent.name}
+mode: subagent
+---
+
+${agent.systemPrompt}`;
+  }
+};
+
+// src/platform/claude-adapter.ts
+init_esm_shims();
+init_paths();
+import { writeFile as writeFile11, mkdir as mkdir11 } from "fs/promises";
+import { join as join16 } from "path";
+import matter4 from "gray-matter";
+var ClaudeAdapter = class {
+  platform = "claude" /* CLAUDE */;
+  displayName = "Claude Code CLI";
+  getCommandsDir() {
+    return paths.claudeCommands(true);
+  }
+  getSkillsDir() {
+    return paths.claudeSkills(true);
+  }
+  getAgentsDir() {
+    return paths.claudeAgents(true);
+  }
+  async transformCommand(command) {
+    const name = command.name;
+    const content = this.generateCommandContent(command);
+    return { name, content };
+  }
+  async transformSkill(skill) {
+    const name = skill.name;
+    const content = this.generateSkillContent(skill);
+    return {
+      name,
+      directory: name,
+      files: { "SKILL.md": content }
+    };
+  }
+  async transformAgent(agent) {
+    const name = agent.name;
+    const content = this.generateAgentContent(agent);
+    return { name, content };
+  }
+  async installCommand(name, content) {
+    const dir = this.getCommandsDir();
+    await mkdir11(dir, { recursive: true });
+    await writeFile11(join16(dir, `${name}.md`), content);
+  }
+  async installSkill(_name, directory, files) {
+    const baseDir = this.getSkillsDir();
+    const targetDir = join16(baseDir, directory);
+    await mkdir11(targetDir, { recursive: true });
+    for (const [filename, content] of Object.entries(files)) {
+      await writeFile11(join16(targetDir, filename), content);
+    }
+  }
+  async installAgent(name, content) {
+    const dir = this.getAgentsDir();
+    await mkdir11(dir, { recursive: true });
+    await writeFile11(join16(dir, `${name}.md`), content);
+  }
+  generateCommandContent(command) {
+    let workflow = command.content;
+    workflow = workflow.replace(/## ⚠️ CRITICAL: The User Has Already Provided Arguments!.*?(?![\n])?.*/gs, "").replace(/\*\*The user has provided arguments with this command!\*\*/g, "").replace(/\*\*The arguments are available in this command response.*?\*\*/g, "").replace(/\*\*YOUR JOB\*\*:.*/gs, "").replace(/1\. Follow command workflow steps.*?\n2\. The workflow will tell you.*?\n3\. Use those arguments.*?\n4\. They have already provided it.*?\n5\. DO NOT ask.*?\n6\. DO: Follow workflow.*?\n+\**Example Scenario\*\*:.*/gs, "").replace(/\*\*User runs:.*?\*\*:\n.*?\n+- Command:.*?\n+- Arguments to use:.*?\n+- You must use.*?\n+- DO NOT:.*?\n+- DO:.*?\n+\*\*\*/g, "").replace(/\*\*\*/g, "");
+    workflow = workflow.replace(/^# Command: \/ak_cm_[\s-]+\n+/g, "");
+    workflow = workflow.replace(/\$ARGUMENTS/g, "$ARGUMENTS").replace(/\$1/g, "$1").replace(/\$2/g, "$2");
+    const frontmatter = {
+      description: command.description,
+      argumentHint: command.usage.replace(/^\//, "").replace(/<[^>]+>/g, "[args]")
+    };
+    return matter4.stringify(workflow, frontmatter);
+  }
+  generateSkillContent(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: `${skill.description}. ${skill.useWhen}`
+    };
+    const content = `# ${skill.name}
+
+## When to Use
+${skill.useWhen}
+
+## Description
+${skill.description}
+
+## Workflow
+${skill.content}
+
+## Tips
+- Use this skill when: ${skill.useWhen.toLowerCase()}
+- Category: ${skill.category}
+- Tags: ${skill.tags.join(", ")}`;
+    return matter4.stringify(content, frontmatter);
+  }
+  generateAgentContent(agent) {
+    const frontmatter = {
+      name: agent.name,
+      description: agent.useWhen,
+      tools: ["Read", "Edit", "Bash", "Grep", "Glob"]
+      // Default tools
+    };
+    return matter4.stringify(agent.systemPrompt, frontmatter);
+  }
+};
+
+// src/platform/adapters.ts
+function createAdapter(platform) {
+  switch (platform) {
+    case "opencode" /* OPENCODE */:
+      return new OpenCodeAdapter();
+    case "claude" /* CLAUDE */:
+      return new ClaudeAdapter();
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+var SUPPORTED_PLATFORMS = [
+  { platform: "opencode" /* OPENCODE */, name: "OpenCode" },
+  { platform: "claude" /* CLAUDE */, name: "Claude Code CLI" }
+];
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize AIKit configuration").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (options) => {
+  program2.command("init [platform]").description("Initialize AIKit configuration for a specific platform").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (platformArg, options) => {
     const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
     console.log(chalk2.bold("\n\u{1F680} AIKit Setup\n"));
     logger.info(`Initializing AIKit in ${configDir}...`);
@@ -5269,91 +7677,54 @@ function registerInitCommand(program2) {
       await initializeConfig(configDir, options.global);
       logger.success("\u2713 Configuration created");
       if (!options.global) {
+        let selectedPlatform;
+        if (platformArg) {
+          selectedPlatform = CliDetector.matchPlatform(platformArg);
+        } else {
+          const platforms = await CliDetector.detectPlatforms();
+          const installed = CliDetector.filterInstalledPlatforms(platforms);
+          console.log(chalk2.bold("\n\u{1F50D} Available CLI Tools\n"));
+          for (const p of platforms) {
+            const status = p.installed ? chalk2.green("\u2713") : chalk2.gray("\u25CB");
+            console.log(`  ${status} ${p.displayName}`);
+          }
+          const { platform } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "platform",
+              message: "Which CLI tool do you want to configure AIKit for?",
+              choices: platforms.map((p) => ({
+                name: p.displayName,
+                value: p.platform
+              })),
+              default: installed[0]?.platform || "opencode" /* OPENCODE */
+            }
+          ]);
+          selectedPlatform = platform;
+        }
+        logger.info(`Selected platform: ${selectedPlatform}`);
         const config = await loadConfig();
         const engine = new SkillEngine(config);
         const result = await engine.syncSkillsToProject();
         if (result.count > 0) {
           logger.success(`\u2713 Synced ${result.count} skills`);
         }
-        console.log(chalk2.bold("\n\u{1F50D} Checking CLI tools...\n"));
-        const cliTools = await CliDetector.checkAll();
-        const installableTools = CliDetector.filterInstallable(cliTools);
-        for (const tool of cliTools) {
-          const status = tool.installed ? chalk2.green("\u2713 Installed") : chalk2.yellow("\u2717 Not installed");
-          const version = tool.version ? chalk2.gray(` (${tool.version})`) : "";
-          console.log(`  ${status} ${chalk2.cyan(tool.displayName)}${version}`);
-        }
-        if (installableTools.length > 0) {
-          console.log();
-          const { action } = await inquirer.prompt([
-            {
-              type: "list",
-              name: "action",
-              message: "How would you like to proceed?",
-              choices: [
-                {
-                  name: "all",
-                  value: "all",
-                  short: "a",
-                  message: "Install all missing CLI tools"
-                },
-                {
-                  name: "select",
-                  value: "select",
-                  short: "s",
-                  message: "Select specific tools to install (use space to select, Enter to confirm)"
-                },
-                {
-                  name: "skip",
-                  value: "skip",
-                  short: "n",
-                  message: "Skip CLI tool installation"
-                }
-              ],
-              default: "all"
-            }
-          ]);
-          if (action === "skip") {
-            console.log();
-            logger.info("Skipping CLI tool installation");
-          } else if (action === "all") {
-            console.log();
-            logger.info(`Installing ${installableTools.length} CLI tool(s)...`);
-            for (const tool of installableTools) {
-              await installCliTool(tool);
-            }
-            console.log();
-            logger.success("\u2713 CLI tools installed");
-          } else {
-            const { installTools } = await inquirer.prompt([
+        if (selectedPlatform === "claude" /* CLAUDE */) {
+          const cliTools = await CliDetector.checkAll();
+          const claudeTool = cliTools.find((t) => t.name === "claude" /* CLAUDE */);
+          if (claudeTool && !claudeTool.installed) {
+            const { installClaude } = await inquirer.prompt([
               {
-                type: "checkbox",
-                name: "installTools",
-                message: "Select CLI tools to install (press Enter to skip):",
-                choices: installableTools.map((tool) => ({
-                  name: tool.name,
-                  value: tool,
-                  checked: true
-                  // Default to install all
-                }))
+                type: "confirm",
+                name: "installClaude",
+                message: "Claude Code CLI is not installed. Install now?",
+                default: true
               }
             ]);
-            if (installTools.length > 0) {
-              console.log();
-              logger.info(`Installing ${installTools.length} CLI tool(s)...`);
-              for (const tool of installTools) {
-                await installCliTool(tool);
-              }
-              console.log();
-              logger.success("\u2713 CLI tools installed");
-            } else {
-              console.log();
-              logger.info("Skipping CLI tool installation");
+            if (installClaude) {
+              await installCliTool(claudeTool);
             }
           }
-        } else {
-          console.log();
-          logger.success("\u2713 All CLI tools already installed");
         }
         const beads = new BeadsIntegration();
         const beadsStatus = await beads.getStatus();
@@ -5367,18 +7738,18 @@ function registerInitCommand(program2) {
         } else {
           logger.info("Beads already initialized");
         }
-        const opencodePath = paths.opencodeConfig();
-        await installToOpenCode(opencodePath);
+        logger.info("Setting up git hooks...");
+        await beads.setupGitHooks();
+        logger.success("\u2713 Git hooks configured");
+        const adapter = createAdapter(selectedPlatform);
+        logger.info(`Installing AIKit for ${adapter.displayName}...`);
+        await installToPlatform(adapter, config);
         console.log(chalk2.bold("\n\u2728 AIKit is ready!\n"));
-        console.log("Usage in OpenCode:");
-        console.log(chalk2.cyan("  /skills") + "  - List all available skills");
-        console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
-        console.log(chalk2.cyan("  /tdd") + "     - Test-driven development");
-        console.log(chalk2.cyan("  /debug") + "   - Systematic debugging");
-        console.log(chalk2.cyan("  /review") + "  - Code review checklist");
-        console.log(chalk2.cyan("  /git") + "     - Git workflow");
-        console.log(chalk2.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
-        console.log("\nPress " + chalk2.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
+        if (selectedPlatform === "opencode" /* OPENCODE */) {
+          showOpenCodeUsage();
+        } else if (selectedPlatform === "claude" /* CLAUDE */) {
+          showClaudeUsage();
+        }
       }
     } catch (error) {
       logger.error("Failed to initialize AIKit:", error);
@@ -5386,18 +7757,121 @@ function registerInitCommand(program2) {
     }
   });
 }
+async function installToPlatform(adapter, config) {
+  const skillEngine = new SkillEngine(config);
+  const commandRunner = new CommandRunner(config);
+  const agentManager = new AgentManager(config);
+  const skills = await skillEngine.listSkills();
+  const commands = await commandRunner.listCommands();
+  const agents = await agentManager.listAgents();
+  logger.info(`Installing ${commands.length} commands...`);
+  for (const command of commands) {
+    const { name, content } = await adapter.transformCommand(command);
+    await adapter.installCommand(name, content);
+    logger.info(`  \u2713 Created ${name} command`);
+  }
+  logger.info(`Installing ${skills.length} skills...`);
+  for (const skill of skills) {
+    const { name, directory, files } = await adapter.transformSkill(skill);
+    await adapter.installSkill(name, directory, files);
+    logger.info(`  \u2713 Created ${name} skill`);
+  }
+  logger.info(`Installing ${agents.length} agents...`);
+  for (const agent of agents) {
+    const { name, content } = await adapter.transformAgent(agent);
+    await adapter.installAgent(name, content);
+    logger.info(`  \u2713 Created ${name} agent`);
+  }
+}
+function showOpenCodeUsage() {
+  console.log("Usage in OpenCode:");
+  console.log(chalk2.cyan("  /skills") + "  - List all available skills");
+  console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
+  console.log(chalk2.cyan("  /tdd") + "     - Test-driven development");
+  console.log(chalk2.cyan("  /debug") + "   - Systematic debugging");
+  console.log(chalk2.cyan("  /review") + "  - Code review checklist");
+  console.log(chalk2.cyan("  /git") + "     - Git workflow");
+  console.log(chalk2.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
+  console.log("\nPress " + chalk2.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
+}
+function showClaudeUsage() {
+  console.log("Usage in Claude Code CLI:");
+  console.log(chalk2.cyan("  /help") + "    - List all available commands");
+  console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
+  console.log(chalk2.cyan("  /implement") + " - Implement a task");
+  console.log(chalk2.cyan("  /test") + "    - Run tests");
+  console.log("\nType " + chalk2.bold('"/help"') + " in Claude to see all commands.\n");
+}
 
 // src/cli/commands/install.ts
 init_esm_shims();
 init_logger();
-init_paths();
+import inquirer2 from "inquirer";
+init_config();
 function registerInstallCommand(program2) {
-  program2.command("install").description("Install AIKit to OpenCode configuration").action(async () => {
-    logger.info("Installing AIKit to OpenCode...");
+  program2.command("install [platform]").description("Install AIKit to specific CLI tool configuration").action(async (platformArg) => {
     try {
-      const opencodePath = paths.opencodeConfig();
-      await installToOpenCode(opencodePath);
-      logger.success("AIKit installed to OpenCode!");
+      let selectedPlatform;
+      if (platformArg) {
+        selectedPlatform = CliDetector.matchPlatform(platformArg);
+        if (!selectedPlatform) {
+          logger.error(`Unknown platform: ${platformArg}`);
+          logger.info(`Supported platforms: ${Object.values(CliPlatform).join(", ")}`);
+          process.exit(1);
+        }
+      } else {
+        const platforms = await CliDetector.detectPlatforms();
+        const installedPlatforms = CliDetector.filterInstalledPlatforms(platforms);
+        const defaultPlatform = installedPlatforms.length > 0 ? installedPlatforms[0].platform : platforms[0]?.platform;
+        const { platform } = await inquirer2.prompt([
+          {
+            type: "list",
+            name: "platform",
+            message: "Which CLI tool do you want to install AIKit for?",
+            choices: platforms.map((p) => ({
+              name: p.displayName,
+              value: p.platform
+            })),
+            default: defaultPlatform
+          }
+        ]);
+        selectedPlatform = platform;
+      }
+      logger.info(`Installing AIKit for ${selectedPlatform}...`);
+      const config = await loadConfig();
+      const adapter = createAdapter(selectedPlatform);
+      const skillEngine = config.skills.enabled ? new SkillEngine(config) : null;
+      const commandRunner = config.commands.enabled ? new CommandRunner(config) : null;
+      const agentManager = config.agents.enabled ? new AgentManager(config) : null;
+      if (commandRunner) {
+        const commands = await commandRunner.listCommands();
+        logger.info(`Installing ${commands.length} commands...`);
+        for (const command of commands) {
+          const { name, content } = await adapter.transformCommand(command);
+          await adapter.installCommand(name, content);
+          logger.info(`  \u2713 Created ${name} command`);
+        }
+      }
+      if (skillEngine) {
+        const skills = await skillEngine.listSkills();
+        logger.info(`Installing ${skills.length} skills...`);
+        for (const skill of skills) {
+          const { name, directory, files } = await adapter.transformSkill(skill);
+          await adapter.installSkill(name, directory, files);
+          logger.info(`  \u2713 Created ${name} skill`);
+        }
+      }
+      if (agentManager) {
+        const agents = await agentManager.listAgents();
+        logger.info(`Installing ${agents.length} agents...`);
+        for (const agent of agents) {
+          const { name, content } = await adapter.transformAgent(agent);
+          await adapter.installAgent(name, content);
+          logger.info(`  \u2713 Created ${name} agent`);
+        }
+      }
+      logger.success(`
+\u2713 AIKit installed to ${adapter.displayName}!`);
     } catch (error) {
       logger.error("Failed to install:", error);
       process.exit(1);
@@ -5412,17 +7886,17 @@ import chalk4 from "chalk";
 
 // src/core/sync-engine.ts
 init_esm_shims();
-import { readFile as readFile11, writeFile as writeFile12, copyFile, mkdir as mkdir10 } from "fs/promises";
-import { join as join17, dirname as dirname4 } from "path";
-import inquirer2 from "inquirer";
+import { readFile as readFile13, writeFile as writeFile15, copyFile, mkdir as mkdir13 } from "fs/promises";
+import { join as join20, dirname as dirname4 } from "path";
+import inquirer3 from "inquirer";
 import chalk3 from "chalk";
 
 // src/core/version-manager.ts
 init_esm_shims();
 init_paths();
 init_logger();
-import { readFile as readFile8, readdir as readdir7, writeFile as writeFile9, stat } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile10, readdir as readdir8, writeFile as writeFile12, stat } from "fs/promises";
+import { join as join17 } from "path";
 import { createHash } from "crypto";
 var VersionManager = class {
   config;
@@ -5433,9 +7907,9 @@ var VersionManager = class {
    * Get current installed version
    */
   async getCurrentVersion() {
-    const versionPath = join14(paths.globalConfig(), ".version.json");
+    const versionPath = join17(paths.globalConfig(), ".version.json");
     try {
-      const content = await readFile8(versionPath, "utf-8");
+      const content = await readFile10(versionPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -5446,7 +7920,7 @@ var VersionManager = class {
    */
   getPackageVersion() {
     try {
-      const packageJson = __require(join14(process.cwd(), "package.json"));
+      const packageJson = __require(join17(process.cwd(), "package.json"));
       return packageJson.version || "0.0.0";
     } catch {
       return "0.0.0";
@@ -5504,9 +7978,9 @@ var VersionManager = class {
     const removedSkills = [];
     const conflicts = [];
     const installedSkills = /* @__PURE__ */ new Map();
-    const installedPath = join14(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join17(paths.globalConfig(), ".installed-skills.json");
     try {
-      const installedData = await readFile8(installedPath, "utf-8");
+      const installedData = await readFile10(installedPath, "utf-8");
       const installedList = JSON.parse(installedData);
       installedList.forEach((skill) => {
         installedSkills.set(skill.name, skill);
@@ -5554,9 +8028,9 @@ var VersionManager = class {
     const hashes = [];
     try {
       const loadFromDir = async (dir) => {
-        const files = await readdir7(dir);
+        const files = await readdir8(dir);
         for (const file of files) {
-          const filePath = join14(dir, file);
+          const filePath = join17(dir, file);
           const stats = await stat(filePath);
           if (stats.isDirectory()) {
             await loadFromDir(filePath);
@@ -5582,7 +8056,7 @@ var VersionManager = class {
    */
   async calculateSkillHash(filePath) {
     try {
-      const content = await readFile8(filePath, "utf-8");
+      const content = await readFile10(filePath, "utf-8");
       return createHash("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -5603,9 +8077,9 @@ var VersionManager = class {
    * Save installed skills info
    */
   async saveInstalledSkills(skills) {
-    const installedPath = join14(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join17(paths.globalConfig(), ".installed-skills.json");
     try {
-      await writeFile9(installedPath, JSON.stringify(skills, null, 2));
+      await writeFile12(installedPath, JSON.stringify(skills, null, 2));
     } catch (error) {
       logger.error("Failed to save installed skills info:", error);
     }
@@ -5626,8 +8100,8 @@ var VersionManager = class {
       packageVersion: this.getPackageVersion(),
       migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
     };
-    const versionPath = join14(paths.globalConfig(), ".version.json");
-    await writeFile9(versionPath, JSON.stringify(updated, null, 2));
+    const versionPath = join17(paths.globalConfig(), ".version.json");
+    await writeFile12(versionPath, JSON.stringify(updated, null, 2));
   }
   /**
    * Check if migration is needed
@@ -5642,8 +8116,8 @@ var VersionManager = class {
 // src/core/backup-manager.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile9, writeFile as writeFile10, readdir as readdir8, stat as stat2, unlink, mkdir as mkdir9 } from "fs/promises";
-import { join as join15, dirname as dirname3 } from "path";
+import { readFile as readFile11, writeFile as writeFile13, readdir as readdir9, stat as stat2, unlink, mkdir as mkdir12 } from "fs/promises";
+import { join as join18, dirname as dirname3 } from "path";
 import { createHash as createHash2 } from "crypto";
 var BackupManager = class {
   configPath;
@@ -5651,7 +8125,7 @@ var BackupManager = class {
   maxBackups;
   constructor(configPath, maxBackups = 5) {
     this.configPath = configPath;
-    this.backupsDir = join15(configPath, ".backups");
+    this.backupsDir = join18(configPath, ".backups");
     this.maxBackups = maxBackups;
   }
   /**
@@ -5659,10 +8133,10 @@ var BackupManager = class {
    */
   async createBackup(fromVersion, toVersion) {
     try {
-      await mkdir9(this.backupsDir, { recursive: true });
+      await mkdir12(this.backupsDir, { recursive: true });
       const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-      const backupPath = join15(this.backupsDir, `${backupId}-v${toVersion}`);
-      await mkdir9(backupPath, { recursive: true });
+      const backupPath = join18(this.backupsDir, `${backupId}-v${toVersion}`);
+      await mkdir12(backupPath, { recursive: true });
       logger.info(`Creating backup: ${backupPath}`);
       const files = [];
       const backupItems = [
@@ -5683,8 +8157,8 @@ var BackupManager = class {
         files,
         success: true
       };
-      const manifestPath = join15(backupPath, "backup-manifest.json");
-      await writeFile10(manifestPath, JSON.stringify(manifest, null, 2));
+      const manifestPath = join18(backupPath, "backup-manifest.json");
+      await writeFile13(manifestPath, JSON.stringify(manifest, null, 2));
       await this.cleanupOldBackups();
       logger.success(`\u2713 Backup created: ${backupId}`);
       return backupId;
@@ -5697,20 +8171,20 @@ var BackupManager = class {
    * Backup a file or directory
    */
   async backupItem(sourceDir, item, targetDir) {
-    const sourcePath = join15(sourceDir, item);
-    const targetPath = join15(targetDir, item);
+    const sourcePath = join18(sourceDir, item);
+    const targetPath = join18(targetDir, item);
     const files = [];
     try {
       const stats = await stat2(sourcePath);
       if (stats.isDirectory()) {
-        await mkdir9(targetPath, { recursive: true });
-        const entries = await readdir8(sourcePath);
+        await mkdir12(targetPath, { recursive: true });
+        const entries = await readdir9(sourcePath);
         for (const entry of entries) {
           const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
           files.push(...entryFiles);
         }
       } else if (stats.isFile()) {
-        await mkdir9(dirname3(targetPath), { recursive: true });
+        await mkdir12(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
         const hash = await this.calculateHash(targetPath);
         files.push({
@@ -5728,15 +8202,15 @@ var BackupManager = class {
    * Copy file with hash calculation
    */
   async copyFile(source, target) {
-    const content = await readFile9(source);
-    await writeFile10(target, content);
+    const content = await readFile11(source);
+    await writeFile13(target, content);
   }
   /**
    * Calculate file hash
    */
   async calculateHash(filePath) {
     try {
-      const content = await readFile9(filePath);
+      const content = await readFile11(filePath);
       return createHash2("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -5747,13 +8221,13 @@ var BackupManager = class {
    */
   async listBackups() {
     try {
-      const entries = await readdir8(this.backupsDir);
+      const entries = await readdir9(this.backupsDir);
       const backups = [];
       for (const entry of entries) {
-        const backupPath = join15(this.backupsDir, entry);
-        const manifestPath = join15(backupPath, "backup-manifest.json");
+        const backupPath = join18(this.backupsDir, entry);
+        const manifestPath = join18(backupPath, "backup-manifest.json");
         try {
-          const manifestContent = await readFile9(manifestPath, "utf-8");
+          const manifestContent = await readFile11(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           const size = await this.calculateBackupSize(backupPath);
           backups.push({
@@ -5779,9 +8253,9 @@ var BackupManager = class {
     let totalSize = 0;
     try {
       const calculate = async (dir) => {
-        const entries = await readdir8(dir);
+        const entries = await readdir9(dir);
         for (const entry of entries) {
-          const entryPath = join15(dir, entry);
+          const entryPath = join18(dir, entry);
           const stats = await stat2(entryPath);
           if (stats.isDirectory()) {
             await calculate(entryPath);
@@ -5813,9 +8287,9 @@ var BackupManager = class {
         return false;
       }
       for (const file of backup.manifest.files) {
-        const sourcePath = join15(backup.path, file.path);
-        const targetPath = join15(this.configPath, file.path);
-        await mkdir9(dirname3(targetPath), { recursive: true });
+        const sourcePath = join18(backup.path, file.path);
+        const targetPath = join18(this.configPath, file.path);
+        await mkdir12(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
       }
       logger.success(`\u2713 Backup restored: ${backupId}`);
@@ -5830,10 +8304,10 @@ var BackupManager = class {
    */
   async validateBackup(backup) {
     try {
-      const manifestPath = join15(backup.path, "backup-manifest.json");
-      await readFile9(manifestPath, "utf-8");
+      const manifestPath = join18(backup.path, "backup-manifest.json");
+      await readFile11(manifestPath, "utf-8");
       for (const file of backup.manifest.files) {
-        const filePath = join15(backup.path, file.path);
+        const filePath = join18(backup.path, file.path);
         await stat2(filePath);
         const currentHash = await this.calculateHash(filePath);
         if (currentHash !== file.hash) {
@@ -5857,9 +8331,9 @@ var BackupManager = class {
       if (!backup) {
         return false;
       }
-      const entries = await readdir8(backup.path);
+      const entries = await readdir9(backup.path);
       for (const entry of entries) {
-        const entryPath = join15(backup.path, entry);
+        const entryPath = join18(backup.path, entry);
         const stats = await stat2(entryPath);
         if (stats.isDirectory()) {
           await this.removeDirectory(entryPath);
@@ -5878,9 +8352,9 @@ var BackupManager = class {
    * Remove directory recursively
    */
   async removeDirectory(dirPath) {
-    const entries = await readdir8(dirPath);
+    const entries = await readdir9(dirPath);
     for (const entry of entries) {
-      const entryPath = join15(dirPath, entry);
+      const entryPath = join18(dirPath, entry);
       const stats = await stat2(entryPath);
       if (stats.isDirectory()) {
         await this.removeDirectory(entryPath);
@@ -5926,14 +8400,14 @@ var BackupManager = class {
 // src/core/migration-manager.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile10, writeFile as writeFile11, readdir as readdir9 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile12, writeFile as writeFile14, readdir as readdir10 } from "fs/promises";
+import { join as join19 } from "path";
 var MigrationManager = class {
   configPath;
   migrationsDir;
   constructor(configPath) {
     this.configPath = configPath;
-    this.migrationsDir = join16(process.cwd(), "src/core/migrations");
+    this.migrationsDir = join19(process.cwd(), "src/core/migrations");
   }
   /**
    * Load all available migrations
@@ -5941,11 +8415,11 @@ var MigrationManager = class {
   async loadMigrations() {
     const migrations = [];
     try {
-      const files = await readdir9(this.migrationsDir);
+      const files = await readdir10(this.migrationsDir);
       for (const file of files) {
         if (file.endsWith(".js") && file.startsWith("migrate-")) {
           try {
-            const module = await import(join16(this.migrationsDir, file));
+            const module = await import(join19(this.migrationsDir, file));
             const migration = module.default || module.migration;
             if (migration) {
               migrations.push(migration);
@@ -5964,9 +8438,9 @@ var MigrationManager = class {
    * Get applied migrations
    */
   async getAppliedMigrations() {
-    const migrationHistoryPath = join16(this.configPath, ".migration-history.json");
+    const migrationHistoryPath = join19(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile10(migrationHistoryPath, "utf-8");
+      const content = await readFile12(migrationHistoryPath, "utf-8");
       const history = JSON.parse(content);
       return history.filter((m) => m.status === "completed").map((m) => m.to);
     } catch {
@@ -6052,16 +8526,16 @@ var MigrationManager = class {
    * Update migration history
    */
   async updateMigrationHistory(entries) {
-    const historyPath = join16(this.configPath, ".migration-history.json");
+    const historyPath = join19(this.configPath, ".migration-history.json");
     try {
       let history = [];
       try {
-        const content = await readFile10(historyPath, "utf-8");
+        const content = await readFile12(historyPath, "utf-8");
         history = JSON.parse(content);
       } catch {
       }
       history.push(...entries);
-      await writeFile11(historyPath, JSON.stringify(history, null, 2));
+      await writeFile14(historyPath, JSON.stringify(history, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history:", error);
     }
@@ -6070,14 +8544,14 @@ var MigrationManager = class {
    * Update migration history status
    */
   async updateMigrationHistoryStatus(version, status) {
-    const historyPath = join16(this.configPath, ".migration-history.json");
+    const historyPath = join19(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile10(historyPath, "utf-8");
+      const content = await readFile12(historyPath, "utf-8");
       const history = JSON.parse(content);
       const updated = history.map(
         (m) => m.to === version ? { ...m, status } : m
       );
-      await writeFile11(historyPath, JSON.stringify(updated, null, 2));
+      await writeFile14(historyPath, JSON.stringify(updated, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history status:", error);
     }
@@ -6086,9 +8560,9 @@ var MigrationManager = class {
    * Get migration history
    */
   async getMigrationHistory() {
-    const historyPath = join16(this.configPath, ".migration-history.json");
+    const historyPath = join19(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile10(historyPath, "utf-8");
+      const content = await readFile12(historyPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return [];
@@ -6176,7 +8650,7 @@ var SyncEngine = class {
       }
       await this.displayChanges(changes);
       if (!options.force) {
-        const { confirmed } = await inquirer2.prompt([{
+        const { confirmed } = await inquirer3.prompt([{
           type: "confirm",
           name: "confirmed",
           message: "Continue with update?",
@@ -6257,7 +8731,7 @@ var SyncEngine = class {
           console.log(chalk3.yellow("No backups available"));
           return false;
         }
-        const { selectedBackup } = await inquirer2.prompt([{
+        const { selectedBackup } = await inquirer3.prompt([{
           type: "list",
           name: "selectedBackup",
           message: "Select backup to restore:",
@@ -6330,7 +8804,7 @@ var SyncEngine = class {
 \u26A0\uFE0F  Conflict detected: ${conflict.skillName}
 `));
     console.log(chalk3.yellow("Your version differs from official version."));
-    const { action } = await inquirer2.prompt([{
+    const { action } = await inquirer3.prompt([{
       type: "list",
       name: "action",
       message: "Choose action:",
@@ -6397,19 +8871,19 @@ var SyncEngine = class {
    * Install a skill
    */
   async installSkill(sourceDir, skill, targetDir) {
-    const sourcePath = join17(sourceDir, skill.category, `${skill.name}.md`);
-    const targetPath = join17(targetDir, skill.category, `${skill.name}.md`);
-    await mkdir10(dirname4(targetPath), { recursive: true });
+    const sourcePath = join20(sourceDir, skill.category, `${skill.name}.md`);
+    const targetPath = join20(targetDir, skill.category, `${skill.name}.md`);
+    await mkdir13(dirname4(targetPath), { recursive: true });
     await copyFile(sourcePath, targetPath);
   }
   /**
    * Archive a removed skill
    */
   async archiveSkill(targetDir, skill) {
-    const sourcePath = join17(targetDir, skill.category, `${skill.name}.md`);
-    const targetPath = join17(targetDir, skill.category, `${skill.name}-deprecated.md`);
+    const sourcePath = join20(targetDir, skill.category, `${skill.name}.md`);
+    const targetPath = join20(targetDir, skill.category, `${skill.name}-deprecated.md`);
     try {
-      const content = await readFile11(sourcePath, "utf-8");
+      const content = await readFile13(sourcePath, "utf-8");
       const deprecatedNotice = `---
 \u26A0\uFE0F  DEPRECATED: This skill has been removed
 
@@ -6418,8 +8892,8 @@ Reason: Check release notes for replacement
 ---
 
 ${content}`;
-      await mkdir10(dirname4(targetPath), { recursive: true });
-      await writeFile12(targetPath, deprecatedNotice);
+      await mkdir13(dirname4(targetPath), { recursive: true });
+      await writeFile15(targetPath, deprecatedNotice);
     } catch (error) {
       if (error.code === "ENOENT") {
         console.log(chalk3.yellow(`    - ${skill.name} (not found, skipping)`));
@@ -6650,8 +9124,8 @@ async function configureToolAction(toolName) {
 // src/cli/commands/misc.ts
 init_esm_shims();
 import chalk6 from "chalk";
-import { readFile as readFile13, writeFile as writeFile14 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile15, writeFile as writeFile17 } from "fs/promises";
+import { join as join22 } from "path";
 init_config();
 init_memory();
 init_beads();
@@ -6714,9 +9188,9 @@ function registerModeCommand(program2) {
         console.log(chalk6.red(`Invalid mode. Available modes: ${validModes.join(", ")}`));
         return;
       }
-      const configData = JSON.parse(await readFile13(join19(configPath, "aikit.json"), "utf-8"));
+      const configData = JSON.parse(await readFile15(join22(configPath, "aikit.json"), "utf-8"));
       configData.mode = mode;
-      await writeFile14(join19(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
+      await writeFile17(join22(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
       console.log(chalk6.green(`\u2713 Mode set to: ${mode}`));
       console.log(chalk6.gray(`Configuration updated at: ${configPath}/aikit.json`));
     } catch (error) {
@@ -6822,8 +9296,36 @@ function registerStatusCommand(program2) {
   });
 }
 
+// src/cli/commands/session.ts
+init_esm_shims();
+function registerSessionCommand(program2) {
+  const sessionCmd = program2.command("session").description("Manage development sessions");
+  sessionCmd.command("start [name]").description("Start a new development session").option("-g, --goals <goals...>", "Session goals").action(async (name, options) => {
+    await startSession(name, options.goals);
+  });
+  sessionCmd.command("update [notes]").description("Add progress notes to current session").action(async (notes) => {
+    await updateSession(notes);
+  });
+  sessionCmd.command("end").description("End current session with summary").action(async () => {
+    await endSession();
+  });
+  sessionCmd.command("current").description("Show current active session").action(async () => {
+    await showCurrentSession();
+  });
+  sessionCmd.command("list").description("List all sessions").action(async () => {
+    await listSessions();
+  });
+  sessionCmd.command("show <sessionId>").description("Show details of a specific session").action(async (sessionId) => {
+    await showSession(sessionId);
+  });
+  sessionCmd.command("search <query>").description("Search sessions by keyword").action(async (query) => {
+    await searchSessions(query);
+  });
+  return sessionCmd;
+}
+
 // src/cli/index.ts
-var program = new Command();
+var program = new Command3();
 program.name("aikit").description("Open-source AI coding agent toolkit for OpenCode").version(getVersion());
 registerInitCommand(program);
 registerInstallCommand(program);
@@ -6836,6 +9338,7 @@ registerToolsCommand(program);
 registerPluginsCommand(program);
 registerMemoryCommand(program);
 registerBeadsCommand(program);
+registerSessionCommand(program);
 registerStatusCommand(program);
 program.parse();
 //# sourceMappingURL=cli.js.map