@tdsoft-tech/aikit 0.1.30 → 0.1.31

package/dist/cli.js

@@ -159,6 +159,7 @@ var init_paths = __esm({
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join as join2 } from "path";
+import { compare, gt, valid } from "semver";
 function getVersion() {
   try {
     const __filename2 = fileURLToPath2(import.meta.url);
@@ -171,6 +172,9 @@ function getVersion() {
     return "0.0.0";
   }
 }
+function isGreaterThan(v1, v2) {
+  return gt(v1, v2);
+}
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
@@ -403,8 +407,8 @@ var init_memory = __esm({
         for (const subDir of subDirs) {
           const dirPath = join6(memoryPath, subDir);
           try {
-            const { readdir: readdir11 } = await import("fs/promises");
-            const files = await readdir11(dirPath);
+            const { readdir: readdir12 } = await import("fs/promises");
+            const files = await readdir12(dirPath);
             for (const file of files) {
               if (!file.endsWith(".md")) continue;
               const content = await readFile4(join6(dirPath, file), "utf-8");
@@ -1684,11 +1688,14 @@ __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 { readFile as readFile8, writeFile as writeFile10, readdir as readdir7, mkdir as mkdir10, access as access4, constants as constants4 } from "fs/promises";
+import { join as join15 } from "path";
 import matter3 from "gray-matter";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
+function sanitizeTTY(tty) {
+  return tty.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
 function formatSession(session) {
   const startDate = new Date(session.startTime);
   const endDate = session.endTime ? new Date(session.endTime) : null;
@@ -1711,20 +1718,104 @@ var init_sessions = __esm({
     SessionManager = class {
       sessionsDir;
       projectPath;
+      aikitDir;
       constructor(projectPath) {
         this.projectPath = projectPath || process.cwd();
-        this.sessionsDir = join13(this.projectPath, ".aikit", "sessions");
+        this.aikitDir = join15(this.projectPath, ".aikit");
+        this.sessionsDir = join15(this.aikitDir, "sessions");
+      }
+      /**
+       * Get current terminal's TTY path
+       * Uses the `tty` command to get the terminal device path
+       * Returns null if not a TTY (editor environment)
+       */
+      async getCurrentTTY() {
+        try {
+          const { stdout } = await execAsync2("tty");
+          const tty = stdout.trim();
+          if (tty === "not a tty" || !tty.startsWith("/")) {
+            return null;
+          }
+          return tty;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Get a unique identifier for the current terminal/editor session
+       * Uses TTY if available, otherwise uses PPID (parent process ID)
+       */
+      async getTerminalIdentifier() {
+        const tty = await this.getCurrentTTY();
+        if (tty) {
+          return sanitizeTTY(tty);
+        }
+        return `ppid-${process.ppid}`;
+      }
+      /**
+       * Get the current session tracker file path
+       * Always uses per-terminal file (TTY or PPID-based)
+       */
+      async getSessionTrackerPath() {
+        const identifier = await this.getTerminalIdentifier();
+        return join15(this.sessionsDir, `.current-${identifier}-session`);
+      }
+      /**
+       * Switch to a different session in the current terminal
+       */
+      async switchSession(sessionId) {
+        const session = await this.getSession(sessionId);
+        if (!session) {
+          throw new Error(`Session not found: ${sessionId}`);
+        }
+        const sessionFile = await this.getSessionTrackerPath();
+        await writeFile10(sessionFile, sessionId);
+      }
+      /**
+       * Initialize the current terminal's session file
+       * Creates an empty tracker file if it doesn't exist
+       */
+      async initTerminalSession() {
+        const sessionFile = await this.getSessionTrackerPath();
+        try {
+          await access4(sessionFile);
+        } catch {
+          await writeFile10(sessionFile, "");
+        }
+        return { tracker: sessionFile };
+      }
+      /**
+       * Get current terminal info (for display purposes)
+       */
+      async getTerminalInfo() {
+        const tty = await this.getCurrentTTY();
+        const sessionId = await this.getActiveSessionId();
+        return { tty, sessionId };
+      }
+      /**
+       * Check if .aikit directory exists in current project path
+       */
+      async ensureAikitExists() {
+        try {
+          await access4(this.aikitDir, constants4.R_OK);
+        } catch {
+          throw new Error(
+            `AIKit not initialized in current directory (${this.projectPath}). Run 'aikit init' first to initialize AIKit in this directory.`
+          );
+        }
       }
       /**
        * Initialize sessions directory
        */
       async init() {
-        await mkdir8(this.sessionsDir, { recursive: true });
+        await this.ensureAikitExists();
+        await mkdir10(this.sessionsDir, { recursive: true });
       }
       /**
        * Start a new session
        */
       async startSession(name, goals) {
+        await this.ensureAikitExists();
         await this.init();
         const now = /* @__PURE__ */ new Date();
         const date = now.toISOString().split("T")[0].replace(/-/g, "");
@@ -1754,6 +1845,7 @@ var init_sessions = __esm({
        * Update current session with notes
        */
       async updateSession(notes) {
+        await this.ensureAikitExists();
         const sessionId = await this.getActiveSessionId();
         if (!sessionId) {
           throw new Error("No active session. Use startSession() first.");
@@ -1783,6 +1875,7 @@ var init_sessions = __esm({
        * End current session and generate summary
        */
       async endSession() {
+        await this.ensureAikitExists();
         const sessionId = await this.getActiveSessionId();
         if (!sessionId) {
           throw new Error("No active session. Use startSession() first.");
@@ -1810,6 +1903,7 @@ var init_sessions = __esm({
        * Get current active session
        */
       async getCurrentSession() {
+        await this.ensureAikitExists();
         const sessionId = await this.getActiveSessionId();
         if (!sessionId) return null;
         return this.getSession(sessionId);
@@ -1818,6 +1912,7 @@ var init_sessions = __esm({
        * Get all sessions
        */
       async listSessions() {
+        await this.ensureAikitExists();
         try {
           const files = await readdir7(this.sessionsDir);
           const sessions = [];
@@ -1832,17 +1927,21 @@ var init_sessions = __esm({
           return sessions.sort(
             (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
           );
-        } catch {
-          return [];
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return [];
+          }
+          throw error;
         }
       }
       /**
        * Get specific session
        */
       async getSession(id) {
-        const filePath = join13(this.sessionsDir, `${id}.md`);
+        await this.ensureAikitExists();
+        const filePath = join15(this.sessionsDir, `${id}.md`);
         try {
-          const content = await readFile7(filePath, "utf-8");
+          const content = await readFile8(filePath, "utf-8");
           const { data, content: body } = matter3(content);
           const updates = this.parseUpdates(body);
           return {
@@ -1865,35 +1964,88 @@ var init_sessions = __esm({
         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))
+          (session) => session.name.toLowerCase().includes(lowerQuery) || session.id.toLowerCase().includes(lowerQuery) || Array.isArray(session.goals) && session.goals.some(
+            (g) => typeof g === "string" && g.toLowerCase().includes(lowerQuery)
+          ) || session.updates.some((u) => u.notes?.toLowerCase().includes(lowerQuery))
         );
       }
+      /**
+       * Resume a past session (set as active)
+       * Supports partial ID matching and "latest" keyword
+       */
+      async resumeSession(idOrLatest) {
+        await this.ensureAikitExists();
+        let session = null;
+        if (idOrLatest === "latest") {
+          const sessions = await this.listSessions();
+          if (sessions.length === 0) {
+            throw new Error("No sessions found to resume");
+          }
+          session = sessions[0];
+        } else {
+          session = await this.getSession(idOrLatest);
+          if (!session) {
+            const sessions = await this.listSessions();
+            const matches = sessions.filter((s) => s.id.startsWith(idOrLatest));
+            if (matches.length === 0) {
+              throw new Error(`Session not found: ${idOrLatest}`);
+            }
+            if (matches.length > 1) {
+              throw new Error(
+                `Multiple sessions match "${idOrLatest}": ${matches.map((s) => s.id).join(", ")}. Please use a more specific ID.`
+              );
+            }
+            session = matches[0];
+          }
+        }
+        if (!session) {
+          throw new Error(`Session not found: ${idOrLatest}`);
+        }
+        const currentSessionId = await this.getActiveSessionId();
+        if (currentSessionId === session.id) {
+          return session;
+        }
+        await this.setActiveSession(session.id);
+        if (session.status === "ended") {
+          session.status = "active";
+          session.endTime = void 0;
+          session.updates.push({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            notes: "Session resumed",
+            gitBranch: (await this.getGitState()).branch
+          });
+          await this.saveSession(session);
+        }
+        return session;
+      }
       /**
        * Get active session ID
+       * Reads from the current session tracker file
        */
       async getActiveSessionId() {
-        const trackerPath = join13(this.sessionsDir, ".current-session");
+        const sessionFile = await this.getSessionTrackerPath();
         try {
-          const content = await readFile7(trackerPath, "utf-8");
-          return content.trim();
+          const content = await readFile8(sessionFile, "utf-8");
+          return content.trim() || null;
         } catch {
           return null;
         }
       }
       /**
-       * Set active session
+       * Set active session for current terminal
+       * Writes to the current session tracker file
        */
       async setActiveSession(id) {
-        const trackerPath = join13(this.sessionsDir, ".current-session");
-        await writeFile8(trackerPath, id);
+        const sessionFile = await this.getSessionTrackerPath();
+        await writeFile10(sessionFile, id);
       }
       /**
-       * Clear active session
+       * Clear active session for current terminal
        */
       async clearActiveSession() {
-        const trackerPath = join13(this.sessionsDir, ".current-session");
+        const sessionFile = await this.getSessionTrackerPath();
         try {
-          await writeFile8(trackerPath, "");
+          await writeFile10(sessionFile, "");
         } catch {
         }
       }
@@ -1901,7 +2053,7 @@ var init_sessions = __esm({
        * Save session to file
        */
       async saveSession(session) {
-        const filePath = join13(this.sessionsDir, `${session.id}.md`);
+        const filePath = join15(this.sessionsDir, `${session.id}.md`);
         const updatesMarkdown = session.updates.map((update) => {
           const date = new Date(update.timestamp);
           const dateStr = date.toLocaleString();
@@ -1940,7 +2092,7 @@ var init_sessions = __esm({
 ${session.endTime ? `**Ended:** ${new Date(session.endTime).toLocaleString()}` : ""}
 
 ## Goals
-${session.goals.map((g, i) => `- [ ] ${g}`).join("\n")}
+${session.goals.map((g) => `- [ ] ${g}`).join("\n")}
 
 ## Progress
 
@@ -1950,7 +2102,7 @@ ${updatesMarkdown}
 ${this.generateSummary(session)}
 `;
         const fileContent = matter3.stringify(content, frontmatter);
-        await writeFile8(filePath, fileContent);
+        await writeFile10(filePath, fileContent);
       }
       /**
        * Generate session summary
@@ -2076,14 +2228,16 @@ ${this.generateSummary(session)}
       }
       /**
        * Get current Beads task
+       * NOTE: This only reads Beads metadata for session updates.
+       * Sessions are NEVER stored in .beads - they are always in .aikit/sessions
        */
       async getCurrentBeadsTask() {
-        const beadsDir = join13(this.projectPath, ".beads");
+        const beadsDir = join15(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 content = await readFile8(join15(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")) {
@@ -2107,8 +2261,8 @@ var tool_config_exports = {};
 __export(tool_config_exports, {
   ToolConfigManager: () => ToolConfigManager
 });
-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 { readFile as readFile15, writeFile as writeFile18, mkdir as mkdir16, access as access7, constants as constants5 } from "fs/promises";
+import { join as join23 } from "path";
 import { z as z3 } from "zod";
 var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
 var init_tool_config = __esm({
@@ -2136,7 +2290,7 @@ var init_tool_config = __esm({
       toolsConfigPath;
       constructor(config) {
         this.config = config;
-        this.toolsConfigPath = join21(this.config.configPath, "config", "tools.json");
+        this.toolsConfigPath = join23(this.config.configPath, "config", "tools.json");
       }
       /**
        * Get all registered tools with their current status
@@ -2219,8 +2373,8 @@ var init_tool_config = __esm({
        */
       async loadConfigs() {
         try {
-          await access7(this.toolsConfigPath, constants4.R_OK);
-          const content = await readFile14(this.toolsConfigPath, "utf-8");
+          await access7(this.toolsConfigPath, constants5.R_OK);
+          const content = await readFile15(this.toolsConfigPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -2230,9 +2384,9 @@ var init_tool_config = __esm({
        * Save configurations
        */
       async saveConfigs(configs) {
-        const configDir = join21(this.config.configPath, "config");
-        await mkdir14(configDir, { recursive: true });
-        await writeFile16(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+        const configDir = join23(this.config.configPath, "config");
+        await mkdir16(configDir, { recursive: true });
+        await writeFile18(this.toolsConfigPath, JSON.stringify(configs, null, 2));
       }
     };
   }
@@ -4161,14 +4315,14 @@ Total: 2 checkpoints
 init_esm_shims();
 var SESSION_COMMANDS = [
   {
-    name: "session:start",
+    name: "session-start",
     description: "Start a new development session",
     category: "session",
-    usage: "/session:start [name]",
+    usage: "/session-start [name]",
     examples: [
-      "/session:start",
-      "/session:start authentication-refactor",
-      '/session:start "Add user profile feature"'
+      "/session-start",
+      "/session-start authentication-refactor",
+      '/session-start "Add user profile feature"'
     ],
     content: `Start a new development session to track your work.
 
@@ -4176,47 +4330,70 @@ var SESSION_COMMANDS = [
 
 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
+**IMPORTANT - Scope Rules:**
+- Sessions are scoped to the CURRENT working directory
+- AIKit will NOT search parent directories for .aikit
+- If .aikit doesn't exist in current directory, you MUST run 'aikit init' first
+- Each directory needs its own .aikit if you want separate session tracking
+
+1. **Check Current Directory:**
+   - Verify .aikit exists in current directory (process.cwd())
+   - If not, inform user to run 'aikit init' first
+   - DO NOT search parent directories
 
-2. **Set Goals:**
+2. **Create Session:**
+   - Generate session ID with timestamp
+   - Create session file in .aikit/sessions/ (current directory only)
+   - Determine session tracker file:
+     * Try 'tty' command to get terminal identifier
+     * If 'tty' works, use .aikit/sessions/.current-<sanitized_tty>-session
+       (replace '/' with '-' in TTY path)
+     * If 'tty' fails with "not a tty", get parent PID using: ps -o ppid= -p $$
+       Use .aikit/sessions/.current-ppid-<PPID>-session
+       (each Claude Code window has unique PPID)
+   - Write session ID to the tracker file
+   - **Capture initial git state (scoped to current directory):**
+     * First check if .git exists in CURRENT directory (process.cwd())
+     * ONLY capture git state if .git exists in current directory
+     * DO NOT search parent directories for git repo
+     * If no .git in current directory, skip git state capture
+
+3. **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:**
+4. **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
+- Git branch and commits (ONLY if .git exists in current directory)
+- Modified files (ONLY if .git exists in current directory)
 - Progress notes
 - Linked Beads task
 
 ## Session File Location
-.aikit/sessions/YYYY-MM-DD-HHMM[-name].md
+Current directory: .aikit/sessions/YYYY-MM-DD-HHMM[-name].md
+(Always relative to process.cwd(), never parent directories)
 
 ## Examples
 
 Start unnamed session:
 \`\`\`
-/session:start
+/session-start
 \`\`\`
 
 Start with descriptive name:
 \`\`\`
-/session:start auth-refactor
+/session-start auth-refactor
 \`\`\`
 
 Start with goal:
 \`\`\`
-/session:start "Implement OAuth 2.0"
+/session-start "Implement OAuth 2.0"
 Goals:
 - Add Google OAuth
 - Add JWT token handling
@@ -4225,18 +4402,18 @@ Goals:
 ## 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`
+- Use /session-update to add progress notes
+- Use /session-end to close and summarize`
   },
   {
-    name: "session:update",
+    name: "session-update",
     description: "Add progress notes to current session",
     category: "session",
-    usage: "/session:update [notes]",
+    usage: "/session-update [notes]",
     examples: [
-      "/session:update",
-      "/session:update Fixed authentication bug",
-      '/session:update "Added JWT middleware"'
+      "/session-update",
+      "/session-update Fixed authentication bug",
+      '/session-update "Added JWT middleware"'
     ],
     content: `Update the current session with progress notes.
 
@@ -4245,19 +4422,28 @@ Goals:
 Progress notes: $ARGUMENTS
 
 1. **Check Active Session:**
-   - Verify there's an active session
+   - Determine session tracker file:
+     * Try 'tty' command to get terminal identifier
+     * If 'tty' works, read .aikit/sessions/.current-<sanitized_tty>-session
+     * If 'tty' fails, get parent PID and read .aikit/sessions/.current-ppid-<PPID>-session
    - Load session file
 
 2. **Capture Current State:**
-   - Get current git branch
-   - Count git commits
-   - List modified files
-   - Check active Beads task
+   - **IMPORTANT - Git State Scope:**
+     * First check if .git exists in CURRENT directory (process.cwd())
+     * ONLY capture git state if .git exists in current directory
+     * DO NOT search parent directories for git repo
+     * If no .git in current directory, skip git state capture
+   - If .git exists in current directory:
+     * Get current git branch
+     * Count git commits
+     * List modified files
+   - Check active Beads task (from .beads directory if exists)
 
 3. **Add Update:**
    - Add timestamped update entry
    - Include your notes (or auto-generate)
-   - Include git state
+   - Include git state ONLY if .git exists in current directory
    - Include Beads task if active
 
 4. **Save Session:**
@@ -4267,27 +4453,25 @@ Progress notes: $ARGUMENTS
 ## What Gets Captured
 - Timestamp of update
 - Your progress notes
-- Current git branch
-- Number of commits
-- List of modified files
+- Git state (branch, commits, files) - ONLY if .git exists in current directory
 - Active Beads task (if any)
 
 ## Examples
 
 Auto-update (no notes):
 \`\`\`
-/session:update
+/session-update
 \`\`\`
 *Auto-generates summary of recent work*
 
 With specific notes:
 \`\`\`
-/session:update Fixed Next.js params issue
+/session-update Fixed Next.js params issue
 \`\`\`
 
 With detailed notes:
 \`\`\`
-/session:update "Implemented OAuth flow with Google provider. Added callback handler and token validation."
+/session-update "Implemented OAuth flow with Google provider. Added callback handler and token validation."
 \`\`\`
 
 ## Notes
@@ -4297,11 +4481,11 @@ With detailed notes:
 - Beads task automatically linked`
   },
   {
-    name: "session:end",
+    name: "session-end",
     description: "End current session with summary",
     category: "session",
-    usage: "/session:end",
-    examples: ["/session:end"],
+    usage: "/session-end",
+    examples: ["/session-end"],
     content: `End the current session and generate a comprehensive summary.
 
 ## Workflow
@@ -4331,7 +4515,10 @@ With detailed notes:
    - Mark session as ended
    - Set end time
    - Save session file
-   - Clear .current-session tracker
+   - Determine session tracker file:
+     * Try 'tty' command to get terminal identifier
+     * If 'tty' works, clear .aikit/sessions/.current-<sanitized_tty>-session
+     * If 'tty' fails, get parent PID and clear .aikit/sessions/.current-ppid-<PPID>-session
 
 ## Summary Includes
 
@@ -4386,17 +4573,20 @@ Lessons:
 - Can start new session after ending`
   },
   {
-    name: "session:current",
+    name: "session-current",
     description: "Show current active session",
     category: "session",
-    usage: "/session:current",
-    examples: ["/session:current"],
+    usage: "/session-current",
+    examples: ["/session-current"],
     content: `Display information about the current active session.
 
 ## Workflow
 
 1. **Check Active Session:**
-   - Read .current-session file
+   - Determine session tracker file:
+     * Try 'tty' command to get terminal identifier
+     * If 'tty' works, read .aikit/sessions/.current-<sanitized_tty>-session
+     * If 'tty' fails, get parent PID and read .aikit/sessions/.current-ppid-<PPID>-session
    - Load session data
 
 2. **Display Session Info:**
@@ -4436,8 +4626,8 @@ Beads Task:
 - bead-001 (in-progress)
 
 Commands:
-/session:update [notes] - Add progress
-/session:end - Close session
+/session-update [notes] - Add progress
+/session-end - Close session
 \`\`\`
 
 ## Notes
@@ -4446,18 +4636,18 @@ Commands:
 - Displays recent progress`
   },
   {
-    name: "session:list",
+    name: "session-list",
     description: "List all sessions",
     category: "session",
-    usage: "/session:list",
-    examples: ["/session:list"],
+    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
+   - Exclude all .current-*-session files (terminal trackers)
 
 2. **Sort by Date:**
    - Newest sessions first
@@ -4500,16 +4690,16 @@ Total: 3 sessions
 - Shows both active and ended sessions
 - Most recent sessions first
 - Active session highlighted
-- Use /session:show <id> for details`
+- Use /session-show <id> for details`
   },
   {
-    name: "session:show",
+    name: "session-show",
     description: "Show details of a specific session",
     category: "session",
-    usage: "/session:show <session-id>",
+    usage: "/session-show <session-id>",
     examples: [
-      "/session:show 2025-01-02-1430",
-      "/session:show 2025-01-02-1430-auth-refactor"
+      "/session-show 2025-01-02-1430",
+      "/session-show 2025-01-02-1430-auth-refactor"
     ],
     content: `Display full details of a specific session.
 
@@ -4580,14 +4770,14 @@ Successfully refactored authentication system...
 - Full session details displayed`
   },
   {
-    name: "session:search",
+    name: "session-search",
     description: "Search sessions by keyword",
     category: "session",
-    usage: "/session:search <query>",
+    usage: "/session-search <query>",
     examples: [
-      "/session:search oauth",
-      '/session:search "jwt"',
-      "/session:search authentication"
+      "/session-search oauth",
+      '/session-search "jwt"',
+      "/session-search authentication"
     ],
     content: `Search for sessions matching a keyword.
 
@@ -4608,7 +4798,7 @@ Search query: $ARGUMENTS
 
 3. **Show Actions:**
    - List matching sessions
-   - Suggest /session:show for details
+   - Suggest /session-show for details
 
 ## Example Output
 \`\`\`
@@ -4638,14 +4828,14 @@ Total: 2 matching sessions
 - Use partial IDs too`
   },
   {
-    name: "session:resume",
+    name: "session-resume",
     description: "Resume a past session (load context)",
     category: "session",
-    usage: "/session:resume <session-id>",
+    usage: "/session-resume <session-id>",
     examples: [
-      "/session:resume latest",
-      "/session:resume 2025-01-02-1430",
-      "/session:resume 2025-01-02-1430-auth-refactor"
+      "/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.
 
@@ -6597,6 +6787,282 @@ init_beads();
 init_esm_shims();
 init_logger();
 
+// src/core/update-manager.ts
+init_esm_shims();
+init_version();
+import chalk2 from "chalk";
+
+// src/utils/npm-client.ts
+init_esm_shims();
+import https from "https";
+async function getLatestVersion(packageName) {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${packageName}`;
+    https.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          if (res.statusCode === 200) {
+            const packageData = JSON.parse(data);
+            const latestVersion = packageData["dist-tags"]?.latest;
+            resolve(latestVersion || null);
+          } else {
+            resolve(null);
+          }
+        } catch {
+          resolve(null);
+        }
+      });
+    }).on("error", () => {
+      resolve(null);
+    }).setTimeout(5e3, () => {
+      resolve(null);
+    });
+  });
+}
+
+// src/utils/update-cache.ts
+init_esm_shims();
+init_paths();
+import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join12 } from "path";
+var CACHE_FILE = ".update-cache.json";
+var DEFAULT_CACHE = {
+  lastCheckTime: 0,
+  lastCheckedVersion: "0.0.0",
+  errorCount: 0
+};
+function getCachePath() {
+  const configDir = paths.globalConfig();
+  return join12(configDir, CACHE_FILE);
+}
+async function readCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync5(cachePath)) {
+      return DEFAULT_CACHE;
+    }
+    const content = await readFile7(cachePath, "utf-8");
+    const data = JSON.parse(content);
+    return { ...DEFAULT_CACHE, ...data };
+  } catch {
+    return DEFAULT_CACHE;
+  }
+}
+async function writeCache(data) {
+  try {
+    const cachePath = getCachePath();
+    const configDir = paths.globalConfig();
+    if (!existsSync5(configDir)) {
+      await mkdir8(configDir, { recursive: true });
+    }
+    await writeFile8(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+  }
+}
+async function setLastCheckTime(timestamp) {
+  const cache = await readCache();
+  cache.lastCheckTime = timestamp;
+  await writeCache(cache);
+}
+async function setLastCheckedVersion(version) {
+  const cache = await readCache();
+  cache.lastCheckedVersion = version;
+  await writeCache(cache);
+}
+async function setCompletedUpdate(version) {
+  const cache = await readCache();
+  cache.completedUpdate = version;
+  cache.completedUpdateTime = Date.now();
+  cache.errorCount = 0;
+  cache.lastError = void 0;
+  await writeCache(cache);
+}
+async function clearCompletedUpdate() {
+  const cache = await readCache();
+  cache.completedUpdate = void 0;
+  cache.completedUpdateTime = void 0;
+  await writeCache(cache);
+}
+async function incrementError(error) {
+  const cache = await readCache();
+  cache.errorCount += 1;
+  cache.lastError = error;
+  await writeCache(cache);
+}
+
+// src/core/background-updater.ts
+init_esm_shims();
+init_paths();
+import { spawn } from "child_process";
+import { writeFile as writeFile9, mkdir as mkdir9 } from "fs/promises";
+import { join as join13 } from "path";
+async function spawnUpdateProcess(targetVersion) {
+  try {
+    const configDir = paths.globalConfig();
+    const logsDir = join13(configDir, "logs");
+    await mkdir9(logsDir, { recursive: true });
+    const scriptContent = generateUpdateScript(targetVersion, logsDir);
+    const scriptPath = join13(configDir, "update-script.js");
+    await writeFile9(scriptPath, scriptContent, "utf-8");
+    const child = spawn(process.execPath, [scriptPath], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateUpdateScript(targetVersion, logsDir) {
+  return `
+// AIKit Auto-Update Script
+// Generated automatically - DO NOT EDIT
+
+const { spawn } = require('child_process');
+const { writeFile, appendFile } = require('fs').promises;
+const { join } = require('path');
+
+const configDir = '${paths.globalConfig().replace(/\\/g, "\\\\")}';
+const logsDir = '${logsDir.replace(/\\/g, "\\\\")}';
+const cachePath = join(configDir, '.update-cache.json');
+const errorLogPath = join(logsDir, 'update-error.log');
+const targetVersion = '${targetVersion}';
+
+async function logError(message) {
+  const timestamp = new Date().toISOString();
+  await appendFile(errorLogPath, \`[\${timestamp}] \${message}\\n\`);
+}
+
+async function updateCache(version, error) {
+  try {
+    const fs = require('fs');
+    let cache = { lastCheckTime: 0, lastCheckedVersion: '0.0.0', errorCount: 0 };
+
+    try {
+      cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+    } catch {}
+
+    if (error) {
+      cache.errorCount = (cache.errorCount || 0) + 1;
+      cache.lastError = error;
+    } else {
+      cache.completedUpdate = version;
+      cache.completedUpdateTime = Date.now();
+      cache.errorCount = 0;
+      cache.lastError = undefined;
+    }
+
+    await writeFile(cachePath, JSON.stringify(cache, null, 2));
+  } catch {}
+}
+
+async function runUpdate() {
+  return new Promise((resolve) => {
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const child = spawn(npmCmd, ['install', '-g', '@tdsoft-tech/aikit@latest'], {
+      stdio: 'pipe',
+    });
+
+    let output = '';
+    let errorOutput = '';
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+    });
+
+    child.on('close', async (code) => {
+      if (code === 0) {
+        await updateCache(targetVersion, null);
+        resolve(true);
+      } else {
+        const errorMsg = errorOutput || 'npm install failed';
+        await logError(\`Update failed (code \${code}): \${errorMsg}\`);
+        await updateCache(targetVersion, errorMsg);
+        resolve(false);
+      }
+    });
+
+    child.on('error', async (err) => {
+      await logError(\`Update error: \${err.message}\`);
+      await updateCache(targetVersion, err.message);
+      resolve(false);
+    });
+  });
+}
+
+// Run update and exit
+runUpdate().then(() => process.exit(0));
+`;
+}
+
+// src/core/update-manager.ts
+var CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+var PACKAGE_NAME = "@tdsoft-tech/aikit";
+async function shouldCheckForUpdates() {
+  const cache = await readCache();
+  const now = Date.now();
+  return now - cache.lastCheckTime > CHECK_INTERVAL;
+}
+async function displayNotification() {
+  const cache = await readCache();
+  if (cache.completedUpdate) {
+    const currentVersion = getVersion();
+    if (isGreaterThan(cache.completedUpdate, currentVersion)) {
+      console.log(chalk2.cyan.bold("\n\u2728 AIKit has been updated!\n"));
+      console.log(chalk2.gray(`   Version: ${currentVersion} \u2192 ${cache.completedUpdate}`));
+      console.log(chalk2.gray(`   Updated: Just now
+`));
+      console.log(chalk2.gray("Run 'aikit --version' to verify.\n"));
+      await clearCompletedUpdate();
+    }
+  }
+  if (cache.errorCount >= 3 && cache.lastError) {
+    console.log(chalk2.yellow.bold("\n\u26A0\uFE0F  AIKit update failed\n"));
+    console.log(chalk2.gray(`   Last error: ${cache.lastError}`));
+    console.log(chalk2.gray("   Check logs: ~/.config/aikit/logs/update-error.log\n"));
+  }
+}
+async function performBackgroundUpdate(latestVersion) {
+  const success = await spawnUpdateProcess(latestVersion);
+  if (!success) {
+    await incrementError("Failed to spawn update process");
+  } else {
+    await setCompletedUpdate(latestVersion);
+  }
+}
+async function checkForUpdates() {
+  try {
+    await displayNotification();
+    if (!await shouldCheckForUpdates()) {
+      return;
+    }
+    const currentVersion = getVersion();
+    const latestVersion = await getLatestVersion(PACKAGE_NAME);
+    await setLastCheckTime(Date.now());
+    await setLastCheckedVersion(currentVersion);
+    if (!latestVersion || !isGreaterThan(latestVersion, currentVersion)) {
+      return;
+    }
+    await performBackgroundUpdate(latestVersion);
+  } catch {
+  }
+}
+async function checkForUpdatesAsync() {
+  checkForUpdates().catch(() => {
+  });
+}
+
 // src/index.ts
 init_logger();
 init_paths();
@@ -6608,15 +7074,15 @@ init_esm_shims();
 // src/cli/commands/init.ts
 init_esm_shims();
 init_config();
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import inquirer from "inquirer";
 init_beads();
 
 // src/utils/cli-detector.ts
 init_esm_shims();
 import { execSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join14 } from "path";
 import { homedir as homedir2 } from "os";
 var CliPlatform = /* @__PURE__ */ ((CliPlatform2) => {
   CliPlatform2["OPENCODE"] = "opencode";
@@ -6630,16 +7096,16 @@ var CliDetector = class {
    */
   static async checkOpenCode() {
     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 = existsSync5(opencodeConfig);
+      const opencodePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".config");
+      const opencodeConfig = join14(opencodePath, "opencode", "opencode.json");
+      let installed = existsSync6(opencodeConfig);
       let version;
       if (installed) {
         try {
           execSync("opencode --version", { stdio: "ignore" });
           version = "installed";
         } catch (error) {
-          if (existsSync5(opencodeConfig)) {
+          if (existsSync6(opencodeConfig)) {
             version = "installed (config exists)";
           } else {
             installed = false;
@@ -6736,18 +7202,18 @@ var CliDetector = class {
    */
   static async detectPlatforms() {
     const platforms = [];
-    const opencodePath = process.platform === "win32" ? process.env.APPDATA || join12(homedir2(), "AppData", "Roaming") : join12(homedir2(), ".config");
+    const opencodePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".config");
     platforms.push({
       platform: "opencode" /* OPENCODE */,
       displayName: "OpenCode",
-      installed: existsSync5(join12(opencodePath, "opencode", "opencode.json")),
+      installed: existsSync6(join14(opencodePath, "opencode", "opencode.json")),
       configPath: opencodePath
     });
-    const claudePath = process.platform === "win32" ? process.env.APPDATA || join12(homedir2(), "AppData", "Roaming") : join12(homedir2(), ".claude");
+    const claudePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".claude");
     platforms.push({
       platform: "claude" /* CLAUDE */,
       displayName: "Claude Code CLI",
-      installed: existsSync5(claudePath),
+      installed: existsSync6(claudePath),
       configPath: claudePath
     });
     return platforms;
@@ -6780,9 +7246,9 @@ init_paths();
 
 // src/cli/helpers.ts
 init_esm_shims();
-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 { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir11, writeFile as writeFile11, readFile as readFile9, access as access5 } from "fs/promises";
+import { join as join16, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execSync as execSync2 } from "child_process";
@@ -6808,7 +7274,7 @@ async function initializeConfig(configDir, _isGlobal) {
     "memory/research"
   ];
   for (const dir of dirs) {
-    await mkdir9(join14(configDir, dir), { recursive: true });
+    await mkdir11(join16(configDir, dir), { recursive: true });
   }
   const defaultConfig = {
     version: getVersion(),
@@ -6821,8 +7287,8 @@ async function initializeConfig(configDir, _isGlobal) {
     beads: { enabled: true },
     antiHallucination: { enabled: true }
   };
-  await writeFile9(
-    join14(configDir, "aikit.json"),
+  await writeFile11(
+    join16(configDir, "aikit.json"),
     JSON.stringify(defaultConfig, null, 2)
   );
   const agentsMd = `# AIKit Agent Rules
@@ -6845,20 +7311,20 @@ async function initializeConfig(configDir, _isGlobal) {
 ## Project-Specific Rules
 Add your project-specific rules here.
 `;
-  await writeFile9(join14(configDir, "AGENTS.md"), agentsMd);
+  await writeFile11(join16(configDir, "AGENTS.md"), agentsMd);
 }
 async function configureMcpServer(projectPath) {
   const currentFile = fileURLToPath3(import.meta.url);
   const currentDir = dirname2(currentFile);
-  const aikitPath = join14(currentDir, "..", "..");
-  const mcpServerPath = join14(aikitPath, "dist", "mcp-server.js");
+  const aikitPath = join16(currentDir, "..", "..");
+  const mcpServerPath = join16(aikitPath, "dist", "mcp-server.js");
   const configLocations = [
     // Global config (most common)
-    join14(homedir3(), ".config", "opencode", "opencode.json"),
+    join16(homedir3(), ".config", "opencode", "opencode.json"),
     // Project-level config
-    join14(projectPath, ".opencode", "opencode.json"),
+    join16(projectPath, ".opencode", "opencode.json"),
     // Alternative global location
-    join14(homedir3(), ".opencode", "opencode.json")
+    join16(homedir3(), ".opencode", "opencode.json")
   ];
   const mcpServerConfig = {
     type: "local",
@@ -6867,12 +7333,12 @@ async function configureMcpServer(projectPath) {
   };
   for (const configPath of configLocations) {
     try {
-      const configDir = join14(configPath, "..");
-      await mkdir9(configDir, { recursive: true });
+      const configDir = join16(configPath, "..");
+      await mkdir11(configDir, { recursive: true });
       let config = {};
-      if (existsSync6(configPath)) {
+      if (existsSync7(configPath)) {
         try {
-          const existing = await readFile8(configPath, "utf-8");
+          const existing = await readFile9(configPath, "utf-8");
           config = JSON.parse(existing);
         } catch {
           config = {};
@@ -6882,7 +7348,7 @@ async function configureMcpServer(projectPath) {
         config.mcp = {};
       }
       config.mcp.aikit = mcpServerConfig;
-      await writeFile9(configPath, JSON.stringify(config, null, 2));
+      await writeFile11(configPath, JSON.stringify(config, null, 2));
       logger.success(`
 \u2705 MCP server configured: ${configPath}`);
       logger.info(`   Server: node ${mcpServerPath}`);
@@ -6891,9 +7357,9 @@ async function configureMcpServer(projectPath) {
       continue;
     }
   }
-  const instructionsPath = join14(projectPath, ".opencode", "MCP_SETUP.md");
-  await mkdir9(join14(projectPath, ".opencode"), { recursive: true });
-  await writeFile9(instructionsPath, `# AIKit MCP Server Configuration
+  const instructionsPath = join16(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir11(join16(projectPath, ".opencode"), { recursive: true });
+  await writeFile11(instructionsPath, `# AIKit MCP Server Configuration
 
 ## Automatic Setup Failed
 
@@ -7146,26 +7612,26 @@ Report what was extracted:
 }
 async function installToOpenCode(_opencodePath) {
   const projectPath = process.cwd();
-  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 });
+  const opencodeCommandDir = join16(projectPath, ".opencode", "command");
+  const aikitDir = join16(projectPath, ".aikit");
+  const opencodeAgentDir = join16(paths.opencodeConfig(), "agent");
+  await mkdir11(opencodeCommandDir, { recursive: true });
+  await mkdir11(join16(aikitDir, "skills"), { recursive: true });
+  await mkdir11(opencodeAgentDir, { recursive: true });
   for (const [name, content] of Object.entries(AGENT_FILES)) {
-    const filePath = join14(opencodeAgentDir, `${name}.md`);
+    const filePath = join16(opencodeAgentDir, `${name}.md`);
     try {
       await access5(filePath);
-      const existingContent = await readFile8(filePath, "utf8");
+      const existingContent = await readFile9(filePath, "utf8");
       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 writeFile9(filePath, updatedContent, "utf8");
+        await writeFile11(filePath, updatedContent, "utf8");
       }
     } catch {
-      await writeFile9(filePath, content, "utf8");
+      await writeFile11(filePath, content, "utf8");
     }
   }
   const config = await loadConfig();
@@ -7174,8 +7640,8 @@ async function installToOpenCode(_opencodePath) {
   const skills = await skillEngine.listSkills();
   const commands = await commandRunner.listCommands();
   const opencodeCommands = {};
-  const skillsList = skills.map((s) => `| \`/ak_sk_${s.name.replace(/\s+/g, "-")}\` | ${s.description} |`).join("\n");
-  opencodeCommands["ak_cm_skills"] = `List all available AIKit skills and how to use them.
+  const skillsList = skills.map((s) => `| \`/${s.name.replace(/\s+/g, "-")}\` | ${s.description} |`).join("\n");
+  opencodeCommands["skills"] = `List all available AIKit skills and how to use them.
 
 READ .aikit/AGENTS.md
 
@@ -7185,9 +7651,9 @@ READ .aikit/AGENTS.md
 |---------|-------------|
 ${skillsList}
 
-Type any command to use that skill. For example: \`/ak_sk_test-driven-development\``;
+Type any command to use that skill. For example: \`/test-driven-development\``;
   for (const skill of skills) {
-    const commandName = `ak_sk_${skill.name.replace(/\s+/g, "-").toLowerCase()}`;
+    const commandName = skill.name.replace(/\s+/g, "-").toLowerCase();
     const skillPath = skill.filePath;
     const relativePath = skillPath.startsWith(projectPath) ? skillPath.replace(projectPath, "").replace(/\\/g, "/").replace(/^\//, "") : `.aikit/skills/${skill.name.replace(/\s+/g, "-").toLowerCase()}.md`;
     const useWhen = skill.useWhen || `The user asks you to ${skill.name}`;
@@ -7209,21 +7675,20 @@ Complete the checklist at the end of the skill.`;
   }
   for (const cmd of commands) {
     if (opencodeCommands[cmd.name]) continue;
-    const commandName = `ak_cm_${cmd.name.replace(/\//g, "").replace(/\s+/g, "-")}`;
+    const commandName = cmd.name.replace(/\//g, "").replace(/\s+/g, "-");
     const examples = cmd.examples.map((e) => {
-      const prefixed = e.replace(/\//g, "/ak_cm_");
-      return `- \`${prefixed}\``;
+      return `- \`${e}\``;
     }).join("\n");
     if (cmd.name === "analyze-figma") {
       opencodeCommands[commandName] = generateAnalyzeFigmaCommand();
     } else {
-      opencodeCommands[commandName] = `# Command: /ak_cm_${cmd.name}
+      opencodeCommands[commandName] = `# Command: /${cmd.name}
 
 ## Description
 ${cmd.description}
 
 ## Usage
-\`${cmd.usage.replace(/\//g, "/ak_cm_")}\`
+\`${cmd.usage}\`
 
 ## Examples
 ${examples}
@@ -7241,8 +7706,8 @@ The arguments are available in this command response - look at the command workf
 4. They have already provided it - extract and use it!
 
 **Example Scenario**:
-- User runs: \`/ak_cm_${cmd.name} snake game with html & css\`
-- Command: \`/ak_cm_${cmd.name}\`
+- User runs: \`/${cmd.name} snake game with html & css\`
+- Command: \`/${cmd.name}\`
 - Arguments to use: \`snake game with html & css\`
 - You must use "snake game with html & css" as provided in the workflow!
 
@@ -7257,8 +7722,8 @@ ${cmd.content}
   }
   let count = 0;
   for (const [name, content] of Object.entries(opencodeCommands)) {
-    const filePath = join14(opencodeCommandDir, `${name}.md`);
-    await writeFile9(filePath, content.trim());
+    const filePath = join16(opencodeCommandDir, `${name}.md`);
+    await writeFile11(filePath, content.trim());
     logger.info(`  \u2713 Created /${name} command`);
     count++;
   }
@@ -7267,8 +7732,8 @@ Created ${count} OpenCode commands in .opencode/command/`);
   await configureMcpServer(projectPath);
   logger.info("\nUsage in OpenCode:");
   logger.info("  Press Ctrl+K to open command picker");
-  logger.info("  Or type /ak_cm_skills to see all available skills");
-  logger.info(`  Available: ${skills.length} skills (ak_sk_*), ${commands.length} commands (ak_cm_*)`);
+  logger.info("  Or type /skills to see all available skills");
+  logger.info(`  Available: ${skills.length} skills, ${commands.length} commands`);
   logger.info("  MCP server configured - tools available via MCP protocol");
 }
 function groupBy(array, keyFn) {
@@ -7295,9 +7760,15 @@ async function startSession(name, goals) {
     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");
+    console.log("  /session:current - Show session status");
+    console.log("  /session:use <id> - Switch to a different session\n");
   } catch (error) {
-    logger.error("Failed to start session:", error);
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else {
+      logger.error("Failed to start session:", error);
+    }
   }
 }
 async function updateSession(notes) {
@@ -7317,7 +7788,10 @@ async function updateSession(notes) {
       console.log();
     }
   } catch (error) {
-    if (error instanceof Error && error.message.includes("No active session")) {
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else 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);
@@ -7356,7 +7830,10 @@ Use /session:show ${session.id} for details
 `);
     }
   } catch (error) {
-    if (error instanceof Error && error.message.includes("No active session")) {
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else 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);
@@ -7374,12 +7851,16 @@ async function showCurrentSession() {
       return;
     }
     const duration = Math.floor((Date.now() - new Date(session.startTime).getTime()) / 6e4);
+    const terminalInfo = await manager.getTerminalInfo();
     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 (terminalInfo.tty) {
+      console.log(`Terminal: ${terminalInfo.tty}`);
+    }
     if (session.goals.length > 0) {
       console.log(`
 Goals:`);
@@ -7411,10 +7892,16 @@ Beads Task:`);
     }
     console.log("\nCommands:");
     console.log("  /session:update [notes] - Add progress");
+    console.log("  /session:use <id> - Switch to another session");
     console.log("  /session:end - Close session");
     console.log("\u2501".repeat(60) + "\n");
   } catch (error) {
-    logger.error("Failed to show current session:", error);
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else {
+      logger.error("Failed to show current session:", error);
+    }
   }
 }
 async function listSessions() {
@@ -7455,7 +7942,12 @@ Total: ${sessions.length} session${sessions.length > 1 ? "s" : ""}
     console.log("  /session:resume <id> - Resume session");
     console.log("  /session:search <query> - Search sessions\n");
   } catch (error) {
-    logger.error("Failed to list sessions:", error);
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else {
+      logger.error("Failed to list sessions:", error);
+    }
   }
 }
 async function showSession(sessionId) {
@@ -7513,7 +8005,12 @@ Goals:`);
     }
     console.log("\n" + "\u2501".repeat(60) + "\n");
   } catch (error) {
-    logger.error("Failed to show session:", error);
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else {
+      logger.error("Failed to show session:", error);
+    }
   }
 }
 async function searchSessions(query) {
@@ -7551,9 +8048,84 @@ Total: ${sessions.length} matching session${sessions.length > 1 ? "s" : ""}
     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);
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else {
+      logger.error("Failed to search sessions:", error);
+    }
   }
 }
+async function resumeSession(sessionId) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.resumeSession(sessionId);
+    logger.success("\u2713 Session resumed");
+    console.log(`  ID: ${session.id}`);
+    console.log(`  Name: ${session.name}`);
+    console.log(`  Status: ${session.status}`);
+    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");
+    console.log("  /session:use <id> - Switch to a different session\n");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else if (error instanceof Error && error.message.includes("not found")) {
+      logger.error(error.message);
+      console.log("Use /session:list to see all sessions\n");
+    } else {
+      logger.error("Failed to resume session:", error);
+    }
+  }
+}
+async function switchSession(sessionId) {
+  try {
+    const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+    const manager = new SessionManager2();
+    const session = await manager.getSession(sessionId);
+    if (!session) {
+      logger.error(`Session not found: ${sessionId}`);
+      console.log("Use /session:list to see all sessions\n");
+      return;
+    }
+    await manager.switchSession(sessionId);
+    logger.success("\u2713 Switched to session");
+    console.log(`  ID: ${session.id}`);
+    console.log(`  Name: ${session.name}`);
+    console.log(`  Status: ${session.status}`);
+    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) {
+    if (error instanceof Error && error.message.includes("not initialized")) {
+      logger.error(error.message);
+      console.log('Run "aikit init" first to initialize AIKit in this directory.\n');
+    } else if (error instanceof Error && error.message.includes("not found")) {
+      logger.error(error.message);
+      console.log("Use /session:list to see all sessions\n");
+    } else {
+      logger.error("Failed to switch session:", error);
+    }
+  }
+}
+
+// src/cli/commands/init.ts
+init_sessions();
 
 // src/platform/adapters.ts
 init_esm_shims();
@@ -7561,33 +8133,31 @@ 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";
+import { readFile as readFile10, writeFile as writeFile12, mkdir as mkdir12, access as access6 } from "fs/promises";
+import { join as join17 } from "path";
 var OpenCodeAdapter = class {
   platform = "opencode" /* OPENCODE */;
   displayName = "OpenCode";
   getCommandsDir() {
-    return join15(process.cwd(), ".opencode", "command");
+    return join17(process.cwd(), ".opencode", "command");
   }
   getSkillsDir() {
-    return join15(process.cwd(), ".opencode", "skill");
+    return join17(process.cwd(), ".opencode", "skill");
   }
   getAgentsDir() {
-    return join15(paths.opencodeConfig(), "agent");
+    return join17(paths.opencodeConfig(), "agent");
   }
   async transformCommand(command) {
-    const sanitizedName = command.name.replace(/:/g, "-");
-    const name = `ak_cm_${sanitizedName}`;
+    const name = command.name.replace(/:/g, "-");
     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,
+      name: skill.name,
       directory: "",
-      files: { [`${skillName}.md`]: skillContent }
+      files: { [`${skill.name}.md`]: skillContent }
     };
     return result;
   }
@@ -7598,47 +8168,46 @@ var OpenCodeAdapter = class {
   }
   async installCommand(name, content) {
     const dir = this.getCommandsDir();
-    await mkdir10(dir, { recursive: true });
-    await writeFile10(join15(dir, `${name}.md`), content);
+    await mkdir12(dir, { recursive: true });
+    await writeFile12(join17(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 });
+    const targetDir = directory ? join17(baseDir, directory) : baseDir;
+    await mkdir12(targetDir, { recursive: true });
     for (const [filename, content] of Object.entries(files)) {
-      await writeFile10(join15(targetDir, filename), content);
+      await writeFile12(join17(targetDir, filename), content);
     }
   }
   async installAgent(name, content) {
     const dir = this.getAgentsDir();
-    await mkdir10(dir, { recursive: true });
-    const filePath = join15(dir, `${name}.md`);
+    await mkdir12(dir, { recursive: true });
+    const filePath = join17(dir, `${name}.md`);
     try {
       await access6(filePath);
-      const existingContent = await readFile9(filePath, "utf-8");
+      const existingContent = await readFile10(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");
+        await writeFile12(filePath, updatedContent, "utf-8");
       }
     } catch {
-      await writeFile10(filePath, content, "utf-8");
+      await writeFile12(filePath, content, "utf-8");
     }
   }
   generateCommandContent(command) {
     const examples = command.examples.map((e) => {
-      const prefixed = e.replace(/\//g, "/ak_cm_");
-      return `- \`${prefixed}\``;
+      return `- \`${e}\``;
     }).join("\n");
-    return `# Command: /ak_cm_${command.name}
+    return `# Command: /${command.name}
 
 ## Description
 ${command.description}
 
 ## Usage
-\`${command.usage.replace(/\//g, "/ak_cm_")}\`
+\`${command.usage}\`
 
 ## Examples
 ${examples}
@@ -7656,8 +8225,8 @@ The arguments are available in this command response - look at the command workf
 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}\`
+- User runs: \`/${command.name} snake game with html & css\`
+- Command: \`/${command.name}\`
 - Arguments to use: \`snake game with html & css\`
 - You must use "snake game with html & css" as provided in the workflow!
 
@@ -7700,12 +8269,14 @@ ${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 { writeFile as writeFile13, mkdir as mkdir13 } from "fs/promises";
+import { join as join18 } from "path";
 import matter4 from "gray-matter";
 var ClaudeAdapter = class {
   platform = "claude" /* CLAUDE */;
   displayName = "Claude Code CLI";
+  // Track installed commands for manifest generation
+  installedCommands = [];
   getCommandsDir() {
     return paths.claudeCommands(true);
   }
@@ -7736,26 +8307,27 @@ var ClaudeAdapter = class {
   }
   async installCommand(name, content) {
     const dir = this.getCommandsDir();
-    await mkdir11(dir, { recursive: true });
-    await writeFile11(join16(dir, `${name}.md`), content);
+    await mkdir13(dir, { recursive: true });
+    await writeFile13(join18(dir, `${name}.md`), content);
+    this.installedCommands.push(name);
   }
   async installSkill(_name, directory, files) {
     const baseDir = this.getSkillsDir();
-    const targetDir = join16(baseDir, directory);
-    await mkdir11(targetDir, { recursive: true });
+    const targetDir = join18(baseDir, directory);
+    await mkdir13(targetDir, { recursive: true });
     for (const [filename, content] of Object.entries(files)) {
-      await writeFile11(join16(targetDir, filename), content);
+      await writeFile13(join18(targetDir, filename), content);
     }
   }
   async installAgent(name, content) {
     const dir = this.getAgentsDir();
-    await mkdir11(dir, { recursive: true });
-    await writeFile11(join16(dir, `${name}.md`), content);
+    await mkdir13(dir, { recursive: true });
+    await writeFile13(join18(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(/^# Command: \/[a-z_]*[\s-]+\n+/g, "");
     workflow = workflow.replace(/\$ARGUMENTS/g, "$ARGUMENTS").replace(/\$1/g, "$1").replace(/\$2/g, "$2");
     const frontmatter = {
       description: command.description,
@@ -7794,6 +8366,26 @@ ${skill.content}
     };
     return matter4.stringify(agent.systemPrompt, frontmatter);
   }
+  /**
+   * Generate commands.json manifest file
+   * This ensures local commands are discovered by Claude Code
+   * and take precedence over parent directory commands
+   *
+   * Reference: https://github.com/anthropics/claude-code/issues/14243
+   */
+  async generateCommandsManifest() {
+    const commandsDir = this.getCommandsDir();
+    const manifestPath = join18(commandsDir, "commands.json");
+    const sortedCommands = [...this.installedCommands].sort();
+    const manifest = {
+      commands: sortedCommands,
+      // Add version for future compatibility
+      version: "1.0",
+      generatedBy: "aikit",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFile13(manifestPath, JSON.stringify(manifest, null, 2));
+  }
 };
 
 // src/platform/adapters.ts
@@ -7816,7 +8408,7 @@ var SUPPORTED_PLATFORMS = [
 function registerInitCommand(program2) {
   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"));
+    console.log(chalk3.bold("\n\u{1F680} AIKit Setup\n"));
     logger.info(`Initializing AIKit in ${configDir}...`);
     try {
       await initializeConfig(configDir, options.global);
@@ -7828,9 +8420,9 @@ function registerInitCommand(program2) {
         } else {
           const platforms = await CliDetector.detectPlatforms();
           const installed = CliDetector.filterInstalledPlatforms(platforms);
-          console.log(chalk2.bold("\n\u{1F50D} Available CLI Tools\n"));
+          console.log(chalk3.bold("\n\u{1F50D} Available CLI Tools\n"));
           for (const p of platforms) {
-            const status = p.installed ? chalk2.green("\u2713") : chalk2.gray("\u25CB");
+            const status = p.installed ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
             console.log(`  ${status} ${p.displayName}`);
           }
           const { platform } = await inquirer.prompt([
@@ -7886,10 +8478,15 @@ function registerInitCommand(program2) {
         logger.info("Setting up git hooks...");
         await beads.setupGitHooks();
         logger.success("\u2713 Git hooks configured");
+        const sessionManager = new SessionManager();
+        await sessionManager.init();
+        logger.success("\u2713 Sessions folder initialized");
+        const { tracker } = await sessionManager.initTerminalSession();
+        logger.success(`\u2713 Session tracker initialized (${tracker.split("/").pop()})`);
         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(chalk3.bold("\n\u2728 AIKit is ready!\n"));
         if (selectedPlatform === "opencode" /* OPENCODE */) {
           showOpenCodeUsage();
         } else if (selectedPlatform === "claude" /* CLAUDE */) {
@@ -7930,22 +8527,22 @@ async function installToPlatform(adapter, config) {
 }
 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");
+  console.log(chalk3.cyan("  /skills") + "  - List all available skills");
+  console.log(chalk3.cyan("  /plan") + "    - Create implementation plan");
+  console.log(chalk3.cyan("  /tdd") + "     - Test-driven development");
+  console.log(chalk3.cyan("  /debug") + "   - Systematic debugging");
+  console.log(chalk3.cyan("  /review") + "  - Code review checklist");
+  console.log(chalk3.cyan("  /git") + "     - Git workflow");
+  console.log(chalk3.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
+  console.log("\nPress " + chalk3.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");
+  console.log(chalk3.cyan("  /help") + "    - List all available commands");
+  console.log(chalk3.cyan("  /plan") + "    - Create implementation plan");
+  console.log(chalk3.cyan("  /implement") + " - Implement a task");
+  console.log(chalk3.cyan("  /test") + "    - Run tests");
+  console.log("\nType " + chalk3.bold('"/help"') + " in Claude to see all commands.\n");
 }
 
 // src/cli/commands/install.ts
@@ -7953,6 +8550,7 @@ init_esm_shims();
 init_logger();
 import inquirer2 from "inquirer";
 init_config();
+init_sessions();
 function registerInstallCommand(program2) {
   program2.command("install [platform]").description("Install AIKit to specific CLI tool configuration").action(async (platformArg) => {
     try {
@@ -7983,6 +8581,11 @@ function registerInstallCommand(program2) {
         selectedPlatform = platform;
       }
       logger.info(`Installing AIKit for ${selectedPlatform}...`);
+      const sessionManager = new SessionManager();
+      await sessionManager.init();
+      logger.success("\u2713 Sessions folder initialized");
+      const { tracker } = await sessionManager.initTerminalSession();
+      logger.success(`\u2713 Session tracker initialized (${tracker.split("/").pop()})`);
       const config = await loadConfig();
       const adapter = createAdapter(selectedPlatform);
       const skillEngine = config.skills.enabled ? new SkillEngine(config) : null;
@@ -8015,6 +8618,10 @@ function registerInstallCommand(program2) {
           logger.info(`  \u2713 Created ${name} agent`);
         }
       }
+      if (selectedPlatform === "claude" && adapter.generateCommandsManifest) {
+        await adapter.generateCommandsManifest();
+        logger.success("\u2713 Generated commands manifest");
+      }
       logger.success(`
 \u2713 AIKit installed to ${adapter.displayName}!`);
     } catch (error) {
@@ -8027,21 +8634,21 @@ function registerInstallCommand(program2) {
 // src/cli/commands/sync.ts
 init_esm_shims();
 init_config();
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/core/sync-engine.ts
 init_esm_shims();
-import { readFile as readFile13, writeFile as writeFile15, copyFile, mkdir as mkdir13 } from "fs/promises";
-import { join as join20, dirname as dirname4 } from "path";
+import { readFile as readFile14, writeFile as writeFile17, copyFile, mkdir as mkdir15 } from "fs/promises";
+import { join as join22, dirname as dirname4 } from "path";
 import inquirer3 from "inquirer";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 
 // src/core/version-manager.ts
 init_esm_shims();
 init_paths();
 init_logger();
-import { readFile as readFile10, readdir as readdir8, writeFile as writeFile12, stat } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile11, readdir as readdir9, writeFile as writeFile14, stat } from "fs/promises";
+import { join as join19 } from "path";
 import { createHash } from "crypto";
 var VersionManager = class {
   config;
@@ -8052,9 +8659,9 @@ var VersionManager = class {
    * Get current installed version
    */
   async getCurrentVersion() {
-    const versionPath = join17(paths.globalConfig(), ".version.json");
+    const versionPath = join19(paths.globalConfig(), ".version.json");
     try {
-      const content = await readFile10(versionPath, "utf-8");
+      const content = await readFile11(versionPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -8065,7 +8672,7 @@ var VersionManager = class {
    */
   getPackageVersion() {
     try {
-      const packageJson = __require(join17(process.cwd(), "package.json"));
+      const packageJson = __require(join19(process.cwd(), "package.json"));
       return packageJson.version || "0.0.0";
     } catch {
       return "0.0.0";
@@ -8123,9 +8730,9 @@ var VersionManager = class {
     const removedSkills = [];
     const conflicts = [];
     const installedSkills = /* @__PURE__ */ new Map();
-    const installedPath = join17(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join19(paths.globalConfig(), ".installed-skills.json");
     try {
-      const installedData = await readFile10(installedPath, "utf-8");
+      const installedData = await readFile11(installedPath, "utf-8");
       const installedList = JSON.parse(installedData);
       installedList.forEach((skill) => {
         installedSkills.set(skill.name, skill);
@@ -8173,9 +8780,9 @@ var VersionManager = class {
     const hashes = [];
     try {
       const loadFromDir = async (dir) => {
-        const files = await readdir8(dir);
+        const files = await readdir9(dir);
         for (const file of files) {
-          const filePath = join17(dir, file);
+          const filePath = join19(dir, file);
           const stats = await stat(filePath);
           if (stats.isDirectory()) {
             await loadFromDir(filePath);
@@ -8201,7 +8808,7 @@ var VersionManager = class {
    */
   async calculateSkillHash(filePath) {
     try {
-      const content = await readFile10(filePath, "utf-8");
+      const content = await readFile11(filePath, "utf-8");
       return createHash("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -8222,9 +8829,9 @@ var VersionManager = class {
    * Save installed skills info
    */
   async saveInstalledSkills(skills) {
-    const installedPath = join17(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join19(paths.globalConfig(), ".installed-skills.json");
     try {
-      await writeFile12(installedPath, JSON.stringify(skills, null, 2));
+      await writeFile14(installedPath, JSON.stringify(skills, null, 2));
     } catch (error) {
       logger.error("Failed to save installed skills info:", error);
     }
@@ -8245,8 +8852,8 @@ var VersionManager = class {
       packageVersion: this.getPackageVersion(),
       migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
     };
-    const versionPath = join17(paths.globalConfig(), ".version.json");
-    await writeFile12(versionPath, JSON.stringify(updated, null, 2));
+    const versionPath = join19(paths.globalConfig(), ".version.json");
+    await writeFile14(versionPath, JSON.stringify(updated, null, 2));
   }
   /**
    * Check if migration is needed
@@ -8261,8 +8868,8 @@ var VersionManager = class {
 // src/core/backup-manager.ts
 init_esm_shims();
 init_logger();
-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 { readFile as readFile12, writeFile as writeFile15, readdir as readdir10, stat as stat2, unlink as unlink2, mkdir as mkdir14 } from "fs/promises";
+import { join as join20, dirname as dirname3 } from "path";
 import { createHash as createHash2 } from "crypto";
 var BackupManager = class {
   configPath;
@@ -8270,7 +8877,7 @@ var BackupManager = class {
   maxBackups;
   constructor(configPath, maxBackups = 5) {
     this.configPath = configPath;
-    this.backupsDir = join18(configPath, ".backups");
+    this.backupsDir = join20(configPath, ".backups");
     this.maxBackups = maxBackups;
   }
   /**
@@ -8278,10 +8885,10 @@ var BackupManager = class {
    */
   async createBackup(fromVersion, toVersion) {
     try {
-      await mkdir12(this.backupsDir, { recursive: true });
+      await mkdir14(this.backupsDir, { recursive: true });
       const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-      const backupPath = join18(this.backupsDir, `${backupId}-v${toVersion}`);
-      await mkdir12(backupPath, { recursive: true });
+      const backupPath = join20(this.backupsDir, `${backupId}-v${toVersion}`);
+      await mkdir14(backupPath, { recursive: true });
       logger.info(`Creating backup: ${backupPath}`);
       const files = [];
       const backupItems = [
@@ -8302,8 +8909,8 @@ var BackupManager = class {
         files,
         success: true
       };
-      const manifestPath = join18(backupPath, "backup-manifest.json");
-      await writeFile13(manifestPath, JSON.stringify(manifest, null, 2));
+      const manifestPath = join20(backupPath, "backup-manifest.json");
+      await writeFile15(manifestPath, JSON.stringify(manifest, null, 2));
       await this.cleanupOldBackups();
       logger.success(`\u2713 Backup created: ${backupId}`);
       return backupId;
@@ -8316,20 +8923,20 @@ var BackupManager = class {
    * Backup a file or directory
    */
   async backupItem(sourceDir, item, targetDir) {
-    const sourcePath = join18(sourceDir, item);
-    const targetPath = join18(targetDir, item);
+    const sourcePath = join20(sourceDir, item);
+    const targetPath = join20(targetDir, item);
     const files = [];
     try {
       const stats = await stat2(sourcePath);
       if (stats.isDirectory()) {
-        await mkdir12(targetPath, { recursive: true });
-        const entries = await readdir9(sourcePath);
+        await mkdir14(targetPath, { recursive: true });
+        const entries = await readdir10(sourcePath);
         for (const entry of entries) {
           const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
           files.push(...entryFiles);
         }
       } else if (stats.isFile()) {
-        await mkdir12(dirname3(targetPath), { recursive: true });
+        await mkdir14(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
         const hash = await this.calculateHash(targetPath);
         files.push({
@@ -8347,15 +8954,15 @@ var BackupManager = class {
    * Copy file with hash calculation
    */
   async copyFile(source, target) {
-    const content = await readFile11(source);
-    await writeFile13(target, content);
+    const content = await readFile12(source);
+    await writeFile15(target, content);
   }
   /**
    * Calculate file hash
    */
   async calculateHash(filePath) {
     try {
-      const content = await readFile11(filePath);
+      const content = await readFile12(filePath);
       return createHash2("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -8366,13 +8973,13 @@ var BackupManager = class {
    */
   async listBackups() {
     try {
-      const entries = await readdir9(this.backupsDir);
+      const entries = await readdir10(this.backupsDir);
       const backups = [];
       for (const entry of entries) {
-        const backupPath = join18(this.backupsDir, entry);
-        const manifestPath = join18(backupPath, "backup-manifest.json");
+        const backupPath = join20(this.backupsDir, entry);
+        const manifestPath = join20(backupPath, "backup-manifest.json");
         try {
-          const manifestContent = await readFile11(manifestPath, "utf-8");
+          const manifestContent = await readFile12(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           const size = await this.calculateBackupSize(backupPath);
           backups.push({
@@ -8398,9 +9005,9 @@ var BackupManager = class {
     let totalSize = 0;
     try {
       const calculate = async (dir) => {
-        const entries = await readdir9(dir);
+        const entries = await readdir10(dir);
         for (const entry of entries) {
-          const entryPath = join18(dir, entry);
+          const entryPath = join20(dir, entry);
           const stats = await stat2(entryPath);
           if (stats.isDirectory()) {
             await calculate(entryPath);
@@ -8432,9 +9039,9 @@ var BackupManager = class {
         return false;
       }
       for (const file of backup.manifest.files) {
-        const sourcePath = join18(backup.path, file.path);
-        const targetPath = join18(this.configPath, file.path);
-        await mkdir12(dirname3(targetPath), { recursive: true });
+        const sourcePath = join20(backup.path, file.path);
+        const targetPath = join20(this.configPath, file.path);
+        await mkdir14(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
       }
       logger.success(`\u2713 Backup restored: ${backupId}`);
@@ -8449,10 +9056,10 @@ var BackupManager = class {
    */
   async validateBackup(backup) {
     try {
-      const manifestPath = join18(backup.path, "backup-manifest.json");
-      await readFile11(manifestPath, "utf-8");
+      const manifestPath = join20(backup.path, "backup-manifest.json");
+      await readFile12(manifestPath, "utf-8");
       for (const file of backup.manifest.files) {
-        const filePath = join18(backup.path, file.path);
+        const filePath = join20(backup.path, file.path);
         await stat2(filePath);
         const currentHash = await this.calculateHash(filePath);
         if (currentHash !== file.hash) {
@@ -8476,14 +9083,14 @@ var BackupManager = class {
       if (!backup) {
         return false;
       }
-      const entries = await readdir9(backup.path);
+      const entries = await readdir10(backup.path);
       for (const entry of entries) {
-        const entryPath = join18(backup.path, entry);
+        const entryPath = join20(backup.path, entry);
         const stats = await stat2(entryPath);
         if (stats.isDirectory()) {
           await this.removeDirectory(entryPath);
         } else {
-          await unlink(entryPath);
+          await unlink2(entryPath);
         }
       }
       logger.success(`\u2713 Backup deleted: ${backupId}`);
@@ -8497,17 +9104,17 @@ var BackupManager = class {
    * Remove directory recursively
    */
   async removeDirectory(dirPath) {
-    const entries = await readdir9(dirPath);
+    const entries = await readdir10(dirPath);
     for (const entry of entries) {
-      const entryPath = join18(dirPath, entry);
+      const entryPath = join20(dirPath, entry);
       const stats = await stat2(entryPath);
       if (stats.isDirectory()) {
         await this.removeDirectory(entryPath);
       } else {
-        await unlink(entryPath);
+        await unlink2(entryPath);
       }
     }
-    await unlink(dirPath);
+    await unlink2(dirPath);
   }
   /**
    * Cleanup old backups (keep only maxBackups)
@@ -8545,14 +9152,14 @@ var BackupManager = class {
 // src/core/migration-manager.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile12, writeFile as writeFile14, readdir as readdir10 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile13, writeFile as writeFile16, readdir as readdir11 } from "fs/promises";
+import { join as join21 } from "path";
 var MigrationManager = class {
   configPath;
   migrationsDir;
   constructor(configPath) {
     this.configPath = configPath;
-    this.migrationsDir = join19(process.cwd(), "src/core/migrations");
+    this.migrationsDir = join21(process.cwd(), "src/core/migrations");
   }
   /**
    * Load all available migrations
@@ -8560,11 +9167,11 @@ var MigrationManager = class {
   async loadMigrations() {
     const migrations = [];
     try {
-      const files = await readdir10(this.migrationsDir);
+      const files = await readdir11(this.migrationsDir);
       for (const file of files) {
         if (file.endsWith(".js") && file.startsWith("migrate-")) {
           try {
-            const module = await import(join19(this.migrationsDir, file));
+            const module = await import(join21(this.migrationsDir, file));
             const migration = module.default || module.migration;
             if (migration) {
               migrations.push(migration);
@@ -8583,9 +9190,9 @@ var MigrationManager = class {
    * Get applied migrations
    */
   async getAppliedMigrations() {
-    const migrationHistoryPath = join19(this.configPath, ".migration-history.json");
+    const migrationHistoryPath = join21(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile12(migrationHistoryPath, "utf-8");
+      const content = await readFile13(migrationHistoryPath, "utf-8");
       const history = JSON.parse(content);
       return history.filter((m) => m.status === "completed").map((m) => m.to);
     } catch {
@@ -8671,16 +9278,16 @@ var MigrationManager = class {
    * Update migration history
    */
   async updateMigrationHistory(entries) {
-    const historyPath = join19(this.configPath, ".migration-history.json");
+    const historyPath = join21(this.configPath, ".migration-history.json");
     try {
       let history = [];
       try {
-        const content = await readFile12(historyPath, "utf-8");
+        const content = await readFile13(historyPath, "utf-8");
         history = JSON.parse(content);
       } catch {
       }
       history.push(...entries);
-      await writeFile14(historyPath, JSON.stringify(history, null, 2));
+      await writeFile16(historyPath, JSON.stringify(history, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history:", error);
     }
@@ -8689,14 +9296,14 @@ var MigrationManager = class {
    * Update migration history status
    */
   async updateMigrationHistoryStatus(version, status) {
-    const historyPath = join19(this.configPath, ".migration-history.json");
+    const historyPath = join21(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile12(historyPath, "utf-8");
+      const content = await readFile13(historyPath, "utf-8");
       const history = JSON.parse(content);
       const updated = history.map(
         (m) => m.to === version ? { ...m, status } : m
       );
-      await writeFile14(historyPath, JSON.stringify(updated, null, 2));
+      await writeFile16(historyPath, JSON.stringify(updated, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history status:", error);
     }
@@ -8705,9 +9312,9 @@ var MigrationManager = class {
    * Get migration history
    */
   async getMigrationHistory() {
-    const historyPath = join19(this.configPath, ".migration-history.json");
+    const historyPath = join21(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile12(historyPath, "utf-8");
+      const content = await readFile13(historyPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return [];
@@ -8747,7 +9354,7 @@ var SyncEngine = class {
       if (changes.hasUpdate) {
         this.displayUpdateInfo(changes);
       } else {
-        console.log(chalk3.green("\u2713 Your AIKit is up to date"));
+        console.log(chalk4.green("\u2713 Your AIKit is up to date"));
         console.log(`  Installed: ${changes.fromVersion}`);
         console.log(`  Latest:    ${changes.toVersion}`);
       }
@@ -8762,15 +9369,15 @@ var SyncEngine = class {
    */
   async previewUpdate() {
     try {
-      console.log(chalk3.bold("\n\u{1F50D} Previewing update...\n"));
+      console.log(chalk4.bold("\n\u{1F50D} Previewing update...\n"));
       const changes = await this.versionManager.checkForUpdates();
       if (!changes.hasUpdate) {
-        console.log(chalk3.green("\u2713 No updates available"));
+        console.log(chalk4.green("\u2713 No updates available"));
         return false;
       }
       await this.displayChanges(changes);
-      console.log(chalk3.yellow("\n\u26A0\uFE0F  This is a preview - no changes will be made."));
-      console.log(chalk3.gray("Use `aikit sync apply` to apply these changes."));
+      console.log(chalk4.yellow("\n\u26A0\uFE0F  This is a preview - no changes will be made."));
+      console.log(chalk4.gray("Use `aikit sync apply` to apply these changes."));
       return true;
     } catch (error) {
       logger.error("Failed to preview update:", error);
@@ -8784,7 +9391,7 @@ var SyncEngine = class {
     try {
       const changes = await this.versionManager.checkForUpdates();
       if (!changes.hasUpdate) {
-        console.log(chalk3.green("\u2713 Already up to date"));
+        console.log(chalk4.green("\u2713 Already up to date"));
         return {
           success: true,
           newSkills: [],
@@ -8802,7 +9409,7 @@ var SyncEngine = class {
           default: false
         }]);
         if (!confirmed) {
-          console.log(chalk3.yellow("Update cancelled"));
+          console.log(chalk4.yellow("Update cancelled"));
           return {
             success: false,
             newSkills: [],
@@ -8814,7 +9421,7 @@ var SyncEngine = class {
       }
       let backupId = void 0;
       if (!options.dryRun && options.backup !== false) {
-        console.log(chalk3.bold("\n\u{1F4E6} Creating backup..."));
+        console.log(chalk4.bold("\n\u{1F4E6} Creating backup..."));
         const backupResult = await this.backupManager.createBackup(
           changes.fromVersion,
           changes.toVersion
@@ -8827,19 +9434,19 @@ var SyncEngine = class {
       for (const conflict of changes.conflicts) {
         await this.resolveConflict(conflict);
       }
-      console.log(chalk3.bold("\n\u{1F504} Running migrations..."));
+      console.log(chalk4.bold("\n\u{1F504} Running migrations..."));
       const migrationResult = await this.migrationManager.runPendingMigrations();
       if (!migrationResult.success) {
         throw new Error(`Migration failed: ${migrationResult.failed.join(", ")}`);
       }
-      console.log(chalk3.bold("\n\u{1F4DD} Updating skills..."));
+      console.log(chalk4.bold("\n\u{1F4DD} Updating skills..."));
       const updateResult = await this.updateSkills(changes, options);
       await this.versionManager.updateVersion(changes.toVersion);
       if (backupId) {
         const allSkills = await this.versionManager.loadSkillHashes(paths.skills(paths.globalConfig()));
         await this.versionManager.saveInstalledSkills(allSkills);
       }
-      console.log(chalk3.green("\n\u2705 Update complete!"));
+      console.log(chalk4.green("\n\u2705 Update complete!"));
       this.displaySummary({
         success: true,
         backupId,
@@ -8854,7 +9461,7 @@ var SyncEngine = class {
       };
     } catch (error) {
       logger.error("Update failed:", error);
-      console.log(chalk3.red("\n\u274C Update failed"));
+      console.log(chalk4.red("\n\u274C Update failed"));
       return {
         success: false,
         newSkills: [],
@@ -8869,11 +9476,11 @@ var SyncEngine = class {
    */
   async rollback(backupId) {
     try {
-      console.log(chalk3.bold("\n\u{1F504} Rollback...\n"));
+      console.log(chalk4.bold("\n\u{1F504} Rollback...\n"));
       if (!backupId) {
         const backups = await this.backupManager.listBackups();
         if (backups.length === 0) {
-          console.log(chalk3.yellow("No backups available"));
+          console.log(chalk4.yellow("No backups available"));
           return false;
         }
         const { selectedBackup } = await inquirer3.prompt([{
@@ -8888,12 +9495,12 @@ var SyncEngine = class {
         backupId = selectedBackup;
       }
       if (!backupId) {
-        console.log(chalk3.yellow("No backup ID provided"));
+        console.log(chalk4.yellow("No backup ID provided"));
         return false;
       }
       const success = await this.backupManager.restoreBackup(backupId);
       if (success) {
-        console.log(chalk3.green("\u2713 Rollback complete"));
+        console.log(chalk4.green("\u2713 Rollback complete"));
         return true;
       }
       return false;
@@ -8906,36 +9513,36 @@ var SyncEngine = class {
    * Display update information
    */
   displayUpdateInfo(changes) {
-    console.log(chalk3.bold("\n\u{1F4E2} New version available!\n"));
-    console.log(`  ${chalk3.cyan("Current:")} ${changes.fromVersion}`);
-    console.log(`  ${chalk3.cyan("Latest:")}  ${changes.toVersion}
+    console.log(chalk4.bold("\n\u{1F4E2} New version available!\n"));
+    console.log(`  ${chalk4.cyan("Current:")} ${changes.fromVersion}`);
+    console.log(`  ${chalk4.cyan("Latest:")}  ${changes.toVersion}
 `);
   }
   /**
    * Display changes summary
    */
   async displayChanges(changes) {
-    console.log(chalk3.bold("\u{1F4CA} Changes detected:\n"));
+    console.log(chalk4.bold("\u{1F4CA} Changes detected:\n"));
     if (changes.newSkills.length > 0) {
-      console.log(chalk3.green("  New Skills:"));
+      console.log(chalk4.green("  New Skills:"));
       changes.newSkills.forEach((skill) => {
         console.log(`    + ${skill.name} (${skill.category})`);
       });
     }
     if (changes.modifiedSkills.length > 0) {
-      console.log(chalk3.yellow("  Updated Skills:"));
+      console.log(chalk4.yellow("  Updated Skills:"));
       changes.modifiedSkills.forEach((skill) => {
         console.log(`    ~ ${skill.name}`);
       });
     }
     if (changes.removedSkills.length > 0) {
-      console.log(chalk3.red("  Removed Skills:"));
+      console.log(chalk4.red("  Removed Skills:"));
       changes.removedSkills.forEach((skill) => {
         console.log(`    - ${skill.name}`);
       });
     }
     if (changes.conflicts.length > 0) {
-      console.log(chalk3.bold.red("  \u26A0\uFE0F  Conflicts:"));
+      console.log(chalk4.bold.red("  \u26A0\uFE0F  Conflicts:"));
       changes.conflicts.forEach((conflict) => {
         console.log(`    ! ${conflict.skillName} (user modified)`);
       });
@@ -8945,10 +9552,10 @@ var SyncEngine = class {
    * Resolve a conflict
    */
   async resolveConflict(conflict) {
-    console.log(chalk3.bold.red(`
+    console.log(chalk4.bold.red(`
 \u26A0\uFE0F  Conflict detected: ${conflict.skillName}
 `));
-    console.log(chalk3.yellow("Your version differs from official version."));
+    console.log(chalk4.yellow("Your version differs from official version."));
     const { action } = await inquirer3.prompt([{
       type: "list",
       name: "action",
@@ -8974,7 +9581,7 @@ var SyncEngine = class {
     if (action === "overwrite") {
       return;
     }
-    console.log(chalk3.yellow("  Your version will be preserved as -custom.md"));
+    console.log(chalk4.yellow("  Your version will be preserved as -custom.md"));
   }
   /**
    * Update skills based on changes
@@ -8990,21 +9597,21 @@ var SyncEngine = class {
         await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
       }
       newSkills.push(skill.name);
-      console.log(chalk3.green(`    + ${skill.name}`));
+      console.log(chalk4.green(`    + ${skill.name}`));
     }
     for (const skill of changes.modifiedSkills) {
       if (!options.dryRun) {
         await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
       }
       updatedSkills.push(skill.name);
-      console.log(chalk3.yellow(`    ~ ${skill.name}`));
+      console.log(chalk4.yellow(`    ~ ${skill.name}`));
     }
     for (const skill of changes.removedSkills) {
       if (!options.dryRun) {
         await this.archiveSkill(projectSkillsPath, skill);
       }
       removedSkills.push(skill.name);
-      console.log(chalk3.red(`    - ${skill.name} (archived)`));
+      console.log(chalk4.red(`    - ${skill.name} (archived)`));
     }
     return {
       newSkills,
@@ -9016,19 +9623,19 @@ var SyncEngine = class {
    * Install a skill
    */
   async installSkill(sourceDir, skill, targetDir) {
-    const sourcePath = join20(sourceDir, skill.category, `${skill.name}.md`);
-    const targetPath = join20(targetDir, skill.category, `${skill.name}.md`);
-    await mkdir13(dirname4(targetPath), { recursive: true });
+    const sourcePath = join22(sourceDir, skill.category, `${skill.name}.md`);
+    const targetPath = join22(targetDir, skill.category, `${skill.name}.md`);
+    await mkdir15(dirname4(targetPath), { recursive: true });
     await copyFile(sourcePath, targetPath);
   }
   /**
    * Archive a removed skill
    */
   async archiveSkill(targetDir, skill) {
-    const sourcePath = join20(targetDir, skill.category, `${skill.name}.md`);
-    const targetPath = join20(targetDir, skill.category, `${skill.name}-deprecated.md`);
+    const sourcePath = join22(targetDir, skill.category, `${skill.name}.md`);
+    const targetPath = join22(targetDir, skill.category, `${skill.name}-deprecated.md`);
     try {
-      const content = await readFile13(sourcePath, "utf-8");
+      const content = await readFile14(sourcePath, "utf-8");
       const deprecatedNotice = `---
 \u26A0\uFE0F  DEPRECATED: This skill has been removed
 
@@ -9037,11 +9644,11 @@ Reason: Check release notes for replacement
 ---
 
 ${content}`;
-      await mkdir13(dirname4(targetPath), { recursive: true });
-      await writeFile15(targetPath, deprecatedNotice);
+      await mkdir15(dirname4(targetPath), { recursive: true });
+      await writeFile17(targetPath, deprecatedNotice);
     } catch (error) {
       if (error.code === "ENOENT") {
-        console.log(chalk3.yellow(`    - ${skill.name} (not found, skipping)`));
+        console.log(chalk4.yellow(`    - ${skill.name} (not found, skipping)`));
       } else {
         throw error;
       }
@@ -9051,24 +9658,24 @@ ${content}`;
    * Display sync summary
    */
   displaySummary(result) {
-    console.log(chalk3.bold("\n\u{1F4CB} Summary:\n"));
-    console.log(`  Updated from: ${chalk3.cyan(result.backupId || "N/A")}`);
-    console.log(`  Updated to:   ${chalk3.cyan("current")}`);
+    console.log(chalk4.bold("\n\u{1F4CB} Summary:\n"));
+    console.log(`  Updated from: ${chalk4.cyan(result.backupId || "N/A")}`);
+    console.log(`  Updated to:   ${chalk4.cyan("current")}`);
     console.log();
     if (result.newSkills.length > 0) {
-      console.log(chalk3.green(`  ${result.newSkills.length} new skills installed`));
+      console.log(chalk4.green(`  ${result.newSkills.length} new skills installed`));
     }
     if (result.updatedSkills.length > 0) {
-      console.log(chalk3.yellow(`  ${result.updatedSkills.length} skills updated`));
+      console.log(chalk4.yellow(`  ${result.updatedSkills.length} skills updated`));
     }
     if (result.removedSkills.length > 0) {
-      console.log(chalk3.red(`  ${result.removedSkills.length} skills archived`));
+      console.log(chalk4.red(`  ${result.removedSkills.length} skills archived`));
     }
     if (result.migrationsRun.length > 0) {
-      console.log(chalk3.blue(`  ${result.migrationsRun.length} migrations run`));
+      console.log(chalk4.blue(`  ${result.migrationsRun.length} migrations run`));
     }
     if (result.backupId) {
-      console.log(chalk3.gray(`
+      console.log(chalk4.gray(`
   Rollback available: aikit sync rollback ${result.backupId}`));
     }
   }
@@ -9098,7 +9705,7 @@ function registerSyncCommand(program2) {
           break;
         default:
           logger.error(`Unknown subcommand: ${subcommand}`);
-          console.log(chalk4.gray("Available subcommands: check, preview, apply, rollback"));
+          console.log(chalk5.gray("Available subcommands: check, preview, apply, rollback"));
           process.exit(1);
       }
     }
@@ -9108,7 +9715,7 @@ function registerSyncCommand(program2) {
 // src/cli/commands/skills.ts
 init_esm_shims();
 init_config();
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 init_logger();
 function registerSkillsCommand(program2) {
   const skillsCmd = program2.command("skills").description("Manage skills");
@@ -9119,31 +9726,31 @@ function registerSkillsCommand(program2) {
     const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
     const toolConfigManager = new ToolConfigManager2(config);
     const tools = await toolConfigManager.listTools();
-    console.log(chalk5.bold("\n\u{1F4DA} Available Skills:\n"));
+    console.log(chalk6.bold("\n\u{1F4DA} Available Skills:\n"));
     for (const skill of skills) {
-      console.log(`  ${chalk5.cyan(skill.name)} - ${skill.description}`);
+      console.log(`  ${chalk6.cyan(skill.name)} - ${skill.description}`);
     }
-    console.log(chalk5.bold("\n\u{1F527} Available Tools:\n"));
+    console.log(chalk6.bold("\n\u{1F527} Available Tools:\n"));
     for (const tool of tools) {
       let statusIcon = "  ";
       let statusText = "";
       if (tool.status === "ready") {
-        statusIcon = chalk5.green("\u2713");
-        statusText = chalk5.gray("(ready)");
+        statusIcon = chalk6.green("\u2713");
+        statusText = chalk6.gray("(ready)");
       } else if (tool.status === "needs_config") {
-        statusIcon = chalk5.yellow("\u26A0");
-        statusText = chalk5.yellow("(needs config)");
+        statusIcon = chalk6.yellow("\u26A0");
+        statusText = chalk6.yellow("(needs config)");
       } else if (tool.status === "error") {
-        statusIcon = chalk5.red("\u2717");
-        statusText = chalk5.red("(error)");
+        statusIcon = chalk6.red("\u2717");
+        statusText = chalk6.red("(error)");
       }
-      console.log(`  ${statusIcon} ${chalk5.cyan(tool.name)} - ${tool.description} ${statusText}`);
+      console.log(`  ${statusIcon} ${chalk6.cyan(tool.name)} - ${tool.description} ${statusText}`);
       if (tool.errorMessage) {
-        console.log(`    ${chalk5.red("Error:")} ${tool.errorMessage}`);
+        console.log(`    ${chalk6.red("Error:")} ${tool.errorMessage}`);
       }
     }
     console.log();
-    console.log(chalk5.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
+    console.log(chalk6.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
   });
   skillsCmd.command("show <name>").description("Show skill details").action(async (name) => {
     const config = await loadConfig();
@@ -9153,11 +9760,11 @@ function registerSkillsCommand(program2) {
       logger.error(`Skill not found: ${name}`);
       process.exit(1);
     }
-    console.log(chalk5.bold(`
+    console.log(chalk6.bold(`
 \u{1F4D6} Skill: ${skill.name}
 `));
-    console.log(chalk5.gray(skill.description));
-    console.log(chalk5.bold("\nWorkflow:"));
+    console.log(chalk6.gray(skill.description));
+    console.log(chalk6.bold("\nWorkflow:"));
     console.log(skill.content);
   });
   skillsCmd.command("create <name>").description("Create a new skill").action(async (name) => {
@@ -9173,11 +9780,11 @@ function registerSkillsCommand(program2) {
     if (result.count === 0) {
       logger.info("Skills already in sync or no global skills to sync");
     } else {
-      console.log(chalk5.bold(`
+      console.log(chalk6.bold(`
 \u2713 Synced ${result.count} skills to project:
 `));
       for (const skill of result.synced) {
-        console.log(`  ${chalk5.cyan("\u2022")} ${skill}`);
+        console.log(`  ${chalk6.cyan("\u2022")} ${skill}`);
       }
       console.log();
     }
@@ -9193,7 +9800,7 @@ function registerSkillsCommand(program2) {
       await configureToolAction(toolName);
     } else {
       logger.error(`Unknown command: ${toolName || "unknown"} ${action || ""}`);
-      console.log(chalk5.gray("\nAvailable commands:"));
+      console.log(chalk6.gray("\nAvailable commands:"));
       console.log("  aikit skills list                    - List all skills and tools");
       console.log("  aikit skills show <name>              - Show skill details");
       console.log("  aikit skills config <tool-name>       - Configure a tool");
@@ -9211,20 +9818,20 @@ async function configureToolAction(toolName) {
   const tool = await toolConfigManager.getToolConfig(toolName);
   if (!tool) {
     logger.error(`Tool not found: ${toolName}`);
-    console.log(chalk5.gray("\nAvailable tools:"));
+    console.log(chalk6.gray("\nAvailable tools:"));
     const tools = await toolConfigManager.listTools();
     for (const t of tools) {
-      console.log(`  - ${chalk5.cyan(t.name)}`);
+      console.log(`  - ${chalk6.cyan(t.name)}`);
     }
     console.log();
-    console.log(chalk5.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
+    console.log(chalk6.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
     console.log();
     process.exit(1);
   }
-  console.log(chalk5.bold(`
+  console.log(chalk6.bold(`
 \u{1F527} Configuring: ${tool.name}
 `));
-  console.log(chalk5.gray(tool.description));
+  console.log(chalk6.gray(tool.description));
   console.log();
   if (tool.configMethod === "oauth") {
     if (toolName === "figma-analysis") {
@@ -9232,12 +9839,12 @@ async function configureToolAction(toolName) {
       const oauth = new FigmaOAuth2(toolConfigManager);
       try {
         const token = await oauth.authenticate();
-        console.log(chalk5.gray("\nValidating token..."));
+        console.log(chalk6.gray("\nValidating token..."));
         const isValid = await oauth.validateToken(token);
         if (isValid) {
           logger.success(`
 \u2705 ${tool.name} configured successfully!`);
-          console.log(chalk5.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+          console.log(chalk6.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
         } else {
           await toolConfigManager.updateToolConfig(toolName, {
             status: "error",
@@ -9268,9 +9875,9 @@ async function configureToolAction(toolName) {
 
 // src/cli/commands/misc.ts
 init_esm_shims();
-import chalk6 from "chalk";
-import { readFile as readFile15, writeFile as writeFile17 } from "fs/promises";
-import { join as join22 } from "path";
+import chalk7 from "chalk";
+import { readFile as readFile16, writeFile as writeFile19 } from "fs/promises";
+import { join as join24 } from "path";
 init_config();
 init_memory();
 init_beads();
@@ -9281,10 +9888,10 @@ function registerAgentsCommand(program2) {
     const config = await loadConfig();
     const manager = new AgentManager(config);
     const agents = manager.listAgents();
-    console.log(chalk6.bold("\n\u{1F916} Available Agents:\n"));
+    console.log(chalk7.bold("\n\u{1F916} Available Agents:\n"));
     for (const agent of agents) {
-      console.log(`  ${chalk6.cyan(`@${agent.name}`)} - ${agent.description}`);
-      console.log(chalk6.gray(`    Use when: ${agent.useWhen}`));
+      console.log(`  ${chalk7.cyan(`@${agent.name}`)} - ${agent.description}`);
+      console.log(chalk7.gray(`    Use when: ${agent.useWhen}`));
     }
     console.log();
   });
@@ -9296,13 +9903,13 @@ function registerCommandsCommand(program2) {
     const config = await loadConfig();
     const runner = new CommandRunner(config);
     const commands = await runner.listCommands();
-    console.log(chalk6.bold("\n\u26A1 Available Commands:\n"));
+    console.log(chalk7.bold("\n\u26A1 Available Commands:\n"));
     const groups = groupBy(commands, (c) => c.category);
     for (const [category, cmds] of Object.entries(groups)) {
-      console.log(chalk6.bold.yellow(`
+      console.log(chalk7.bold.yellow(`
   ${category}:`));
       for (const cmd of cmds) {
-        console.log(`    ${chalk6.cyan(`/${cmd.name}`)} - ${cmd.description}`);
+        console.log(`    ${chalk7.cyan(`/${cmd.name}`)} - ${cmd.description}`);
       }
     }
     console.log();
@@ -9314,15 +9921,15 @@ function registerModeCommand(program2) {
   modeCmd.command("get").description("Get current AIKit mode").action(async () => {
     const config = await loadConfig();
     const { mode } = config;
-    console.log(chalk6.bold("\n\u{1F4CB} Current Mode:\n"));
-    console.log(`  ${chalk6.cyan(mode || "build")}`);
+    console.log(chalk7.bold("\n\u{1F4CB} Current Mode:\n"));
+    console.log(`  ${chalk7.cyan(mode || "build")}`);
     console.log();
-    console.log(chalk6.bold("Available Modes:\n"));
-    console.log(`  ${chalk6.cyan("plan")} - Create detailed implementation plans`);
-    console.log(`  ${chalk6.cyan("build")} - Direct execution mode`);
-    console.log(`  ${chalk6.cyan("one-shot")} - End-to-end autonomous execution`);
+    console.log(chalk7.bold("Available Modes:\n"));
+    console.log(`  ${chalk7.cyan("plan")} - Create detailed implementation plans`);
+    console.log(`  ${chalk7.cyan("build")} - Direct execution mode`);
+    console.log(`  ${chalk7.cyan("one-shot")} - End-to-end autonomous execution`);
     console.log();
-    console.log(chalk6.gray('Use "aikit mode set <mode>" to change mode.'));
+    console.log(chalk7.gray('Use "aikit mode set <mode>" to change mode.'));
   });
   modeCmd.command("set <mode>").description("Set AIKit mode (plan, build, one-shot)").action(async (mode) => {
     const config = await loadConfig();
@@ -9330,16 +9937,16 @@ function registerModeCommand(program2) {
     try {
       const validModes = ["plan", "build", "one-shot"];
       if (!validModes.includes(mode)) {
-        console.log(chalk6.red(`Invalid mode. Available modes: ${validModes.join(", ")}`));
+        console.log(chalk7.red(`Invalid mode. Available modes: ${validModes.join(", ")}`));
         return;
       }
-      const configData = JSON.parse(await readFile15(join22(configPath, "aikit.json"), "utf-8"));
+      const configData = JSON.parse(await readFile16(join24(configPath, "aikit.json"), "utf-8"));
       configData.mode = mode;
-      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`));
+      await writeFile19(join24(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
+      console.log(chalk7.green(`\u2713 Mode set to: ${mode}`));
+      console.log(chalk7.gray(`Configuration updated at: ${configPath}/aikit.json`));
     } catch (error) {
-      console.log(chalk6.red(`Failed to set mode: ${error instanceof Error ? error.message : String(error)}`));
+      console.log(chalk7.red(`Failed to set mode: ${error instanceof Error ? error.message : String(error)}`));
     }
   });
   return modeCmd;
@@ -9350,9 +9957,9 @@ function registerToolsCommand(program2) {
     const config = await loadConfig();
     const registry = new ToolRegistry(config);
     const tools = await registry.listTools();
-    console.log(chalk6.bold("\n\u{1F527} Available Tools:\n"));
+    console.log(chalk7.bold("\n\u{1F527} Available Tools:\n"));
     for (const tool of tools) {
-      console.log(`  ${chalk6.cyan(tool.name)} - ${tool.description}`);
+      console.log(`  ${chalk7.cyan(tool.name)} - ${tool.description}`);
     }
     console.log();
   });
@@ -9364,10 +9971,10 @@ function registerPluginsCommand(program2) {
     const config = await loadConfig();
     const system = new PluginSystem(config);
     const plugins = await system.listPlugins();
-    console.log(chalk6.bold("\n\u{1F50C} Available Plugins:\n"));
+    console.log(chalk7.bold("\n\u{1F50C} Available Plugins:\n"));
     for (const plugin of plugins) {
-      const status = plugin.enabled ? chalk6.green("\u2713") : chalk6.gray("\u25CB");
-      console.log(`  ${status} ${chalk6.cyan(plugin.name)} - ${plugin.description}`);
+      const status = plugin.enabled ? chalk7.green("\u2713") : chalk7.gray("\u25CB");
+      console.log(`  ${status} ${chalk7.cyan(plugin.name)} - ${plugin.description}`);
     }
     console.log();
   });
@@ -9379,10 +9986,10 @@ function registerMemoryCommand(program2) {
     const config = await loadConfig();
     const memory = new MemoryManager(config);
     const entries = await memory.list();
-    console.log(chalk6.bold("\n\u{1F9E0} Memory Entries:\n"));
+    console.log(chalk7.bold("\n\u{1F9E0} Memory Entries:\n"));
     for (const entry of entries) {
-      console.log(`  ${chalk6.cyan(entry.key)} - ${entry.summary}`);
-      console.log(chalk6.gray(`    Updated: ${entry.updatedAt}`));
+      console.log(`  ${chalk7.cyan(entry.key)} - ${entry.summary}`);
+      console.log(chalk7.gray(`    Updated: ${entry.updatedAt}`));
     }
     console.log();
   });
@@ -9403,7 +10010,7 @@ function registerBeadsCommand(program2) {
   beadsCmd.command("status").description("Show current Beads status").action(async () => {
     const beads = new BeadsIntegration();
     const status = await beads.getStatus();
-    console.log(chalk6.bold("\n\u{1F4FF} Beads Status:\n"));
+    console.log(chalk7.bold("\n\u{1F4FF} Beads Status:\n"));
     console.log(`  Active tasks: ${status.activeTasks}`);
     console.log(`  Completed: ${status.completedTasks}`);
     console.log(`  Current: ${status.currentTask || "None"}`);
@@ -9413,12 +10020,12 @@ function registerBeadsCommand(program2) {
 }
 function registerStatusCommand(program2) {
   program2.command("status").description("Show AIKit status").action(async () => {
-    console.log(chalk6.bold(`
+    console.log(chalk7.bold(`
 \u{1F680} AIKit v${getVersion()}
 `));
     try {
       const config = await loadConfig();
-      console.log(chalk6.green("\u2713 Configuration loaded"));
+      console.log(chalk7.green("\u2713 Configuration loaded"));
       const skillEngine = new SkillEngine(config);
       const skills = await skillEngine.listSkills();
       console.log(`  Skills: ${skills.length}`);
@@ -9433,9 +10040,9 @@ function registerStatusCommand(program2) {
       console.log(`  Tools: ${tools.length}`);
       const beads = new BeadsIntegration();
       const beadsStatus = await beads.isInstalled();
-      console.log(`  Beads: ${beadsStatus ? chalk6.green("Installed") : chalk6.yellow("Not installed")}`);
+      console.log(`  Beads: ${beadsStatus ? chalk7.green("Installed") : chalk7.yellow("Not installed")}`);
     } catch (error) {
-      console.log(chalk6.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
+      console.log(chalk7.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
     }
     console.log();
   });
@@ -9466,6 +10073,12 @@ function registerSessionCommand(program2) {
   sessionCmd.command("search <query>").description("Search sessions by keyword").action(async (query) => {
     await searchSessions(query);
   });
+  sessionCmd.command("resume <sessionId>").description("Resume a past session (set as active)").action(async (sessionId) => {
+    await resumeSession(sessionId);
+  });
+  sessionCmd.command("use <sessionId>").description("Switch to a different session in current terminal").action(async (sessionId) => {
+    await switchSession(sessionId);
+  });
   return sessionCmd;
 }
 
@@ -9486,4 +10099,9 @@ registerBeadsCommand(program);
 registerSessionCommand(program);
 registerStatusCommand(program);
 program.parse();
+checkForUpdatesAsync().catch((err) => {
+  if (process.env.AIKIT_DEBUG) {
+    console.error("Update check failed:", err);
+  }
+});
 //# sourceMappingURL=cli.js.map