@tdsoft-tech/aikit 0.1.31 → 0.1.32

package/dist/cli.js

@@ -182,6 +182,756 @@ var init_version = __esm({
   }
 });
 
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = {
+      info(...args) {
+        console.log(chalk.blue("\u2139"), ...args);
+      },
+      success(...args) {
+        console.log(chalk.green("\u2713"), ...args);
+      },
+      warn(...args) {
+        console.log(chalk.yellow("\u26A0"), ...args);
+      },
+      error(...args) {
+        console.error(chalk.red("\u2716"), ...args);
+      },
+      debug(...args) {
+        if (process.env.DEBUG || process.env.AIKIT_DEBUG) {
+          console.log(chalk.gray("\u22EF"), ...args);
+        }
+      },
+      step(step, total, message) {
+        console.log(chalk.cyan(`[${step}/${total}]`), message);
+      },
+      header(message) {
+        console.log(chalk.bold.underline(`
+${message}
+`));
+      },
+      list(items, prefix = "\u2022") {
+        for (const item of items) {
+          console.log(`  ${prefix} ${item}`);
+        }
+      }
+    };
+  }
+});
+
+// src/core/database/schema.ts
+function initializeSchema(db) {
+  try {
+    logger.info("Initializing Figma database schema...");
+    db.pragma("foreign_keys = ON");
+    db.pragma("journal_mode = WAL");
+    Object.entries(SCHEMA_SQL).forEach(([tableName, sql]) => {
+      logger.debug(`Creating table: ${tableName}`);
+      db.exec(sql);
+    });
+    Object.entries(INDEX_SQL).forEach(([indexName, sql]) => {
+      logger.debug(`Creating index: ${indexName}`);
+      db.exec(sql);
+    });
+    Object.entries(TRIGGER_SQL).forEach(([triggerName, sql]) => {
+      logger.debug(`Creating trigger: ${triggerName}`);
+      db.exec(sql);
+    });
+    const currentVersion = getCurrentSchemaVersion(db);
+    if (currentVersion < DATABASE_VERSION) {
+      db.prepare("INSERT OR REPLACE INTO schema_version (version) VALUES (?)").run(DATABASE_VERSION);
+      logger.info(`Schema updated to version ${DATABASE_VERSION}`);
+    }
+    logger.info("Database schema initialized successfully");
+  } catch (error) {
+    logger.error(`Failed to initialize database schema: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+function getCurrentSchemaVersion(db) {
+  try {
+    const result = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    return result?.version || 0;
+  } catch {
+    return 0;
+  }
+}
+var DATABASE_VERSION, SCHEMA_SQL, INDEX_SQL, TRIGGER_SQL;
+var init_schema = __esm({
+  "src/core/database/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    DATABASE_VERSION = 1;
+    SCHEMA_SQL = {
+      // Files table - stores Figma file metadata
+      figma_files: `
+    CREATE TABLE IF NOT EXISTS figma_files (
+      id TEXT PRIMARY KEY,
+      url TEXT NOT NULL UNIQUE,
+      name TEXT,
+      file_key TEXT NOT NULL,
+      last_analyzed DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `,
+      // Screens table - stores screen/frame information
+      figma_screens: `
+    CREATE TABLE IF NOT EXISTS figma_screens (
+      id TEXT PRIMARY KEY,
+      file_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      width INTEGER,
+      height INTEGER,
+      type TEXT,
+      description TEXT,
+      children_count INTEGER,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Nodes table - stores hierarchical component structure
+      figma_nodes: `
+    CREATE TABLE IF NOT EXISTS figma_nodes (
+      id TEXT PRIMARY KEY,
+      file_id TEXT NOT NULL,
+      screen_id TEXT,
+      parent_id TEXT,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      content TEXT,
+      position_x REAL,
+      position_y REAL,
+      width REAL,
+      height REAL,
+      styles TEXT, -- JSON string
+      children_ids TEXT, -- JSON string array
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE,
+      FOREIGN KEY (screen_id) REFERENCES figma_screens(id) ON DELETE CASCADE,
+      FOREIGN KEY (parent_id) REFERENCES figma_nodes(id) ON DELETE CASCADE
+    )
+  `,
+      // Design tokens table - stores extracted design tokens
+      design_tokens: `
+    CREATE TABLE IF NOT EXISTS design_tokens (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id TEXT NOT NULL,
+      type TEXT NOT NULL, -- 'color', 'typography', 'spacing', 'component'
+      name TEXT NOT NULL,
+      value TEXT NOT NULL,
+      category TEXT,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Assets table - stores downloadable assets
+      figma_assets: `
+    CREATE TABLE IF NOT EXISTS figma_assets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      node_name TEXT,
+      node_type TEXT,
+      format TEXT, -- 'png', 'svg', 'jpg'
+      file_path TEXT,
+      url TEXT,
+      width INTEGER,
+      height INTEGER,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Schema version tracking
+      schema_version: `
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `
+    };
+    INDEX_SQL = {
+      // Files indexes
+      idx_files_url: "CREATE INDEX IF NOT EXISTS idx_files_url ON figma_files(url)",
+      idx_files_file_key: "CREATE INDEX IF NOT EXISTS idx_files_file_key ON figma_files(file_key)",
+      idx_files_last_analyzed: "CREATE INDEX IF NOT EXISTS idx_files_last_analyzed ON figma_files(last_analyzed)",
+      // Screens indexes
+      idx_screens_file_id: "CREATE INDEX IF NOT EXISTS idx_screens_file_id ON figma_screens(file_id)",
+      idx_screens_type: "CREATE INDEX IF NOT EXISTS idx_screens_type ON figma_screens(type)",
+      // Nodes indexes
+      idx_nodes_file_id: "CREATE INDEX IF NOT EXISTS idx_nodes_file_id ON figma_nodes(file_id)",
+      idx_nodes_screen_id: "CREATE INDEX IF NOT EXISTS idx_nodes_screen_id ON figma_nodes(screen_id)",
+      idx_nodes_parent_id: "CREATE INDEX IF NOT EXISTS idx_nodes_parent_id ON figma_nodes(parent_id)",
+      idx_nodes_type: "CREATE INDEX IF NOT EXISTS idx_nodes_type ON figma_nodes(type)",
+      // Design tokens indexes
+      idx_tokens_file_id: "CREATE INDEX IF NOT EXISTS idx_tokens_file_id ON design_tokens(file_id)",
+      idx_tokens_type: "CREATE INDEX IF NOT EXISTS idx_tokens_type ON design_tokens(type)",
+      idx_tokens_file_type: "CREATE INDEX IF NOT EXISTS idx_tokens_file_type ON design_tokens(file_id, type)",
+      // Assets indexes
+      idx_assets_file_id: "CREATE INDEX IF NOT EXISTS idx_assets_file_id ON figma_assets(file_id)",
+      idx_assets_node_id: "CREATE INDEX IF NOT EXISTS idx_assets_node_id ON figma_assets(node_id)",
+      idx_assets_format: "CREATE INDEX IF NOT EXISTS idx_assets_format ON figma_assets(format)"
+    };
+    TRIGGER_SQL = {
+      // Update timestamp trigger for files table
+      trigger_files_updated_at: `
+    CREATE TRIGGER IF NOT EXISTS trigger_files_updated_at
+    AFTER UPDATE ON figma_files
+    FOR EACH ROW
+    BEGIN
+      UPDATE figma_files SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END
+  `
+    };
+  }
+});
+
+// src/core/database/figma-db.ts
+import Database from "better-sqlite3";
+var FigmaDatabase;
+var init_figma_db = __esm({
+  "src/core/database/figma-db.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_schema();
+    FigmaDatabase = class {
+      db;
+      constructor(dbPath = ":memory:") {
+        try {
+          this.db = new Database(dbPath);
+          initializeSchema(this.db);
+          logger.info(`Figma database initialized at: ${dbPath}`);
+        } catch (error) {
+          logger.error(`Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Export database data to JSON
+       */
+      async exportData(fileId) {
+        try {
+          const files = fileId ? [await this.getFile(fileId)].filter(Boolean) : await this.listFiles();
+          const fileIds = files.map((f) => f.id);
+          let screens = [];
+          let nodes = [];
+          let tokens = [];
+          let assets = [];
+          for (const fId of fileIds) {
+            screens.push(...await this.getScreensByFile(fId));
+            nodes.push(...await this.getNodesByFile(fId));
+            tokens.push(...await this.getDesignTokensByFile(fId));
+            assets.push(...await this.getAssetsByFile(fId));
+          }
+          return {
+            files,
+            screens,
+            nodes,
+            tokens,
+            assets,
+            exported_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch (error) {
+          logger.error(`Failed to export data: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Import database data from JSON
+       */
+      async importData(data) {
+        try {
+          const stats = { files: 0, screens: 0, nodes: 0, tokens: 0, assets: 0 };
+          for (const file of data.files) {
+            await this.upsertFile(file);
+            stats.files++;
+          }
+          for (const screen of data.screens) {
+            await this.upsertScreen(screen);
+            stats.screens++;
+          }
+          for (const node of data.nodes) {
+            await this.upsertNode(node);
+            stats.nodes++;
+          }
+          for (const token of data.tokens) {
+            await this.upsertDesignToken(token);
+            stats.tokens++;
+          }
+          for (const asset of data.assets) {
+            await this.upsertAsset(asset);
+            stats.assets++;
+          }
+          logger.info(`Imported ${stats.files} files, ${stats.screens} screens, ${stats.nodes} nodes, ${stats.tokens} tokens, ${stats.assets} assets`);
+          return stats;
+        } catch (error) {
+          logger.error(`Failed to import data: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Utility Operations
+       */
+      async upsertFile(file) {
+        try {
+          const lastAnalyzed = file.last_analyzed instanceof Date ? file.last_analyzed.toISOString() : file.last_analyzed || null;
+          const existing = this.db.prepare("SELECT id FROM figma_files WHERE id = ?").get(file.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_files 
+          SET url = ?, name = ?, file_key = ?, last_analyzed = ?, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        `).run(file.url, file.name || null, file.file_key, lastAnalyzed, file.id);
+            return { id: file.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_files (id, url, name, file_key, last_analyzed)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(file.id, file.url, file.name || null, file.file_key, lastAnalyzed);
+            return { id: file.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert file: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getFile(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_files WHERE id = ?").get(id);
+          if (!row) return null;
+          return {
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          };
+        } catch (error) {
+          logger.error(`Failed to get file: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getFileByUrl(url) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_files WHERE url = ?").get(url);
+          if (!row) return null;
+          return {
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          };
+        } catch (error) {
+          logger.error(`Failed to get file by URL: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async deleteFile(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_files WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete file: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      async listFiles(options) {
+        try {
+          const limit = options?.limit || 50;
+          const offset = options?.offset || 0;
+          const orderBy = options?.orderBy || "updated_at";
+          const orderDirection = options?.orderDirection || "DESC";
+          const query = `
+        SELECT * FROM figma_files 
+        ORDER BY ${orderBy} ${orderDirection}
+        LIMIT ? OFFSET ?
+      `;
+          const rows = this.db.prepare(query).all(limit, offset);
+          return rows.map((row) => ({
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          }));
+        } catch (error) {
+          logger.error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      /**
+       * Screen Operations
+       */
+      async upsertScreen(screen) {
+        try {
+          const existing = this.db.prepare("SELECT id FROM figma_screens WHERE id = ?").get(screen.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_screens 
+          SET file_id = ?, name = ?, width = ?, height = ?, type = ?, description = ?, children_count = ?
+          WHERE id = ?
+        `).run(
+              screen.file_id,
+              screen.name,
+              screen.width || null,
+              screen.height || null,
+              screen.type || null,
+              screen.description || null,
+              screen.children_count || null,
+              screen.id
+            );
+            return { id: screen.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_screens (id, file_id, name, width, height, type, description, children_count)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              screen.id,
+              screen.file_id,
+              screen.name,
+              screen.width || null,
+              screen.height || null,
+              screen.type || null,
+              screen.description || null,
+              screen.children_count || null
+            );
+            return { id: screen.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert screen: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getScreen(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_screens WHERE id = ?").get(id);
+          return row || null;
+        } catch (error) {
+          logger.error(`Failed to get screen: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getScreensByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_screens WHERE file_id = ? ORDER BY name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get screens by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteScreen(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_screens WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete screen: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Node Operations
+       */
+      async upsertNode(node) {
+        try {
+          const existing = this.db.prepare("SELECT id FROM figma_nodes WHERE id = ?").get(node.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_nodes 
+          SET file_id = ?, screen_id = ?, parent_id = ?, name = ?, type = ?, content = ?,
+              position_x = ?, position_y = ?, width = ?, height = ?, styles = ?, children_ids = ?
+          WHERE id = ?
+        `).run(
+              node.file_id,
+              node.screen_id || null,
+              node.parent_id || null,
+              node.name,
+              node.type,
+              node.content || null,
+              node.position_x || null,
+              node.position_y || null,
+              node.width || null,
+              node.height || null,
+              node.styles || null,
+              node.children_ids || null,
+              node.id
+            );
+            return { id: node.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_nodes (id, file_id, screen_id, parent_id, name, type, content, 
+                                   position_x, position_y, width, height, styles, children_ids)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              node.id,
+              node.file_id,
+              node.screen_id || null,
+              node.parent_id || null,
+              node.name,
+              node.type,
+              node.content || null,
+              node.position_x || null,
+              node.position_y || null,
+              node.width || null,
+              node.height || null,
+              node.styles || null,
+              node.children_ids || null
+            );
+            return { id: node.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert node: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getNode(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_nodes WHERE id = ?").get(id);
+          return row || null;
+        } catch (error) {
+          logger.error(`Failed to get node: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getNodesByScreen(screenId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_nodes WHERE screen_id = ? ORDER BY name").all(screenId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get nodes by screen: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async getNodesByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_nodes WHERE file_id = ? ORDER BY name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get nodes by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteNode(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_nodes WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete node: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Design Token Operations
+       */
+      async upsertDesignToken(token) {
+        try {
+          const existing = this.db.prepare(`
+        SELECT id FROM design_tokens 
+        WHERE file_id = ? AND type = ? AND name = ?
+      `).get(token.file_id, token.type, token.name);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE design_tokens 
+          SET value = ?, category = ?
+          WHERE id = ?
+        `).run(token.value, token.category || null, existing.id);
+            return { id: existing.id.toString(), created: false, updated: true };
+          } else {
+            const result = this.db.prepare(`
+          INSERT INTO design_tokens (file_id, type, name, value, category)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(token.file_id, token.type, token.name, token.value, token.category || null);
+            return { id: result.lastInsertRowid.toString(), created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert design token: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getDesignTokensByFile(fileId, type) {
+        try {
+          const query = type ? "SELECT * FROM design_tokens WHERE file_id = ? AND type = ? ORDER BY name" : "SELECT * FROM design_tokens WHERE file_id = ? ORDER BY type, name";
+          const rows = type ? this.db.prepare(query).all(fileId, type) : this.db.prepare(query).all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get design tokens: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteDesignTokensByFile(fileId) {
+        try {
+          const result = this.db.prepare("DELETE FROM design_tokens WHERE file_id = ?").run(fileId);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete design tokens: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Asset Operations
+       */
+      async upsertAsset(asset) {
+        try {
+          const existing = this.db.prepare(`
+        SELECT id FROM figma_assets 
+        WHERE file_id = ? AND node_id = ?
+      `).get(asset.file_id, asset.node_id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_assets 
+          SET node_name = ?, node_type = ?, format = ?, file_path = ?, url = ?, width = ?, height = ?
+          WHERE id = ?
+        `).run(
+              asset.node_name || null,
+              asset.node_type || null,
+              asset.format || null,
+              asset.file_path || null,
+              asset.url || null,
+              asset.width || null,
+              asset.height || null,
+              existing.id
+            );
+            return { id: existing.id.toString(), created: false, updated: true };
+          } else {
+            const result = this.db.prepare(`
+          INSERT INTO figma_assets (file_id, node_id, node_name, node_type, format, file_path, url, width, height)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              asset.file_id,
+              asset.node_id,
+              asset.node_name || null,
+              asset.node_type || null,
+              asset.format || null,
+              asset.file_path || null,
+              asset.url || null,
+              asset.width || null,
+              asset.height || null
+            );
+            return { id: result.lastInsertRowid.toString(), created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert asset: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getAssetsByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_assets WHERE file_id = ? ORDER BY node_name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get assets by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteAssetsByFile(fileId) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_assets WHERE file_id = ?").run(fileId);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete assets by file: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Cache invalidation logic
+       */
+      async isCacheValid(url, maxAgeHours = 24) {
+        try {
+          const file = await this.getFileByUrl(url);
+          if (!file || !file.last_analyzed) return false;
+          const now = /* @__PURE__ */ new Date();
+          const ageHours = (now.getTime() - file.last_analyzed.getTime()) / (1e3 * 60 * 60);
+          return ageHours < maxAgeHours;
+        } catch (error) {
+          logger.error(`Failed to check cache validity: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Clear cache for a specific file
+       */
+      async clearFileCache(url) {
+        try {
+          const file = await this.getFileByUrl(url);
+          if (!file) return false;
+          await this.deleteDesignTokensByFile(file.id);
+          await this.deleteAssetsByFile(file.id);
+          const nodes = await this.getNodesByFile(file.id);
+          for (const node of nodes) {
+            await this.deleteNode(node.id);
+          }
+          const screens = await this.getScreensByFile(file.id);
+          for (const screen of screens) {
+            await this.deleteScreen(screen.id);
+          }
+          return await this.deleteFile(file.id);
+        } catch (error) {
+          logger.error(`Failed to clear file cache: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Clear all expired cache entries
+       */
+      async clearExpiredCache(maxAgeHours = 24 * 7) {
+        try {
+          const cutoffDate = new Date(Date.now() - maxAgeHours * 60 * 60 * 1e3);
+          const expiredFiles = this.db.prepare(`
+        SELECT * FROM figma_files 
+        WHERE last_analyzed < ? OR last_analyzed IS NULL
+      `).all(cutoffDate.toISOString());
+          let clearedCount = 0;
+          for (const file of expiredFiles) {
+            if (await this.clearFileCache(file.url)) {
+              clearedCount++;
+            }
+          }
+          return clearedCount;
+        } catch (error) {
+          logger.error(`Failed to clear expired cache: ${error instanceof Error ? error.message : String(error)}`);
+          return 0;
+        }
+      }
+      async close() {
+        try {
+          this.db.close();
+          logger.info("Database connection closed");
+        } catch (error) {
+          logger.error(`Failed to close database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      async vacuum() {
+        try {
+          this.db.exec("VACUUM");
+          logger.info("Database vacuumed");
+        } catch (error) {
+          logger.error(`Failed to vacuum database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      async getStats() {
+        try {
+          const files = this.db.prepare("SELECT COUNT(*) as count FROM figma_files").get();
+          const screens = this.db.prepare("SELECT COUNT(*) as count FROM figma_screens").get();
+          const nodes = this.db.prepare("SELECT COUNT(*) as count FROM figma_nodes").get();
+          const tokens = this.db.prepare("SELECT COUNT(*) as count FROM design_tokens").get();
+          const assets = this.db.prepare("SELECT COUNT(*) as count FROM figma_assets").get();
+          return {
+            files: files.count,
+            screens: screens.count,
+            nodes: nodes.count,
+            tokens: tokens.count,
+            assets: assets.count
+          };
+        } catch (error) {
+          logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
+          return { files: 0, screens: 0, nodes: 0, tokens: 0, assets: 0 };
+        }
+      }
+    };
+  }
+});
+
 // src/core/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -239,15 +989,36 @@ function deepMerge(base, override) {
   }
   return result;
 }
-var ConfigSchema, Config;
+var PlatformConfigSchema, ConfigSchema, Config;
 var init_config = __esm({
   "src/core/config.ts"() {
     "use strict";
     init_esm_shims();
     init_paths();
     init_version();
+    init_figma_db();
+    PlatformConfigSchema = z.object({
+      /**
+       * Primary platform to use (affects default behavior)
+       */
+      primary: z.enum(["opencode", "claude"]).default("opencode"),
+      /**
+       * Enable OpenCode platform support
+       * Default: true (OpenCode is the primary focus)
+       */
+      opencode: z.boolean().default(true),
+      /**
+       * Enable Claude Code platform support
+       * Default: false (archived, can be re-enabled later)
+       */
+      claude: z.boolean().default(false)
+    }).default({});
     ConfigSchema = z.object({
       version: z.string(),
+      /**
+       * Platform configuration - controls which platforms are active
+       */
+      platform: PlatformConfigSchema,
       skills: z.object({
         enabled: z.boolean().default(true),
         directory: z.string().optional()
@@ -279,6 +1050,11 @@ var init_config = __esm({
         specFile: z.string().default("spec.md"),
         reviewFile: z.string().default("review.md")
       }).default({}),
+      database: z.object({
+        enabled: z.boolean().default(true),
+        path: z.string().optional()
+        // If not provided, will use default path
+      }).default({}),
       mcp: z.object({
         context7: z.boolean().default(false),
         githubGrep: z.boolean().default(false),
@@ -318,12 +1094,43 @@ var init_config = __esm({
       get antiHallucination() {
         return this.config.antiHallucination;
       }
+      get database() {
+        return this.config.database;
+      }
       get mode() {
         return this.config.mode;
       }
+      get platform() {
+        return this.config.platform;
+      }
       get configPath() {
         return this.config.configPath;
       }
+      /**
+       * Check if a specific platform is enabled
+       */
+      isPlatformEnabled(platform) {
+        return this.config.platform[platform] ?? false;
+      }
+      /**
+       * Get the primary platform
+       */
+      getPrimaryPlatform() {
+        return this.config.platform.primary;
+      }
+      /**
+       * Get list of all enabled platforms
+       */
+      getEnabledPlatforms() {
+        const platforms = [];
+        if (this.config.platform.opencode) {
+          platforms.push("opencode");
+        }
+        if (this.config.platform.claude) {
+          platforms.push("claude");
+        }
+        return platforms;
+      }
       get projectPath() {
         return this.config.projectPath;
       }
@@ -331,49 +1138,20 @@ var init_config = __esm({
        * Get path to a specific resource
        */
       getPath(resource) {
+        if (resource === "database") {
+          return this.config.database.path || join3(this.configPath, "figma.db");
+        }
         return paths[resource](this.configPath);
       }
-    };
-  }
-});
-
-// src/utils/logger.ts
-import chalk from "chalk";
-var logger;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    init_esm_shims();
-    logger = {
-      info(...args) {
-        console.log(chalk.blue("\u2139"), ...args);
-      },
-      success(...args) {
-        console.log(chalk.green("\u2713"), ...args);
-      },
-      warn(...args) {
-        console.log(chalk.yellow("\u26A0"), ...args);
-      },
-      error(...args) {
-        console.error(chalk.red("\u2716"), ...args);
-      },
-      debug(...args) {
-        if (process.env.DEBUG || process.env.AIKIT_DEBUG) {
-          console.log(chalk.gray("\u22EF"), ...args);
-        }
-      },
-      step(step, total, message) {
-        console.log(chalk.cyan(`[${step}/${total}]`), message);
-      },
-      header(message) {
-        console.log(chalk.bold.underline(`
-${message}
-`));
-      },
-      list(items, prefix = "\u2022") {
-        for (const item of items) {
-          console.log(`  ${prefix} ${item}`);
+      /**
+       * Get database instance
+       */
+      getDatabase() {
+        if (this.config.database?.enabled === false) {
+          throw new Error("Database is disabled in configuration");
         }
+        const dbPath = this.getPath("database");
+        return new FigmaDatabase(dbPath);
       }
     };
   }
@@ -407,8 +1185,8 @@ var init_memory = __esm({
         for (const subDir of subDirs) {
           const dirPath = join6(memoryPath, subDir);
           try {
-            const { readdir: readdir12 } = await import("fs/promises");
-            const files = await readdir12(dirPath);
+            const { readdir: readdir11 } = await import("fs/promises");
+            const files = await readdir11(dirPath);
             for (const file of files) {
               if (!file.endsWith(".md")) continue;
               const content = await readFile4(join6(dirPath, file), "utf-8");
@@ -611,8 +1389,10 @@ var init_figma_mcp = __esm({
     init_logger();
     FigmaMcpClient = class {
       apiKey;
-      constructor(apiKey, _configManager) {
+      database;
+      constructor(apiKey, _configManager, database) {
         this.apiKey = apiKey;
+        this.database = database;
       }
       /**
        * Fetch helper with simple retry/backoff for 429/5xx
@@ -695,14 +1475,22 @@ ${text}`);
         return data;
       }
       /**
-       * Extract design tokens from Figma file
+       * Extract design tokens from Figma file and optionally persist to database
        */
       async extractDesignTokens(url, downloadAssets = true, assetsDir) {
-        const fileData = await this.getFileData(url);
         const fileKey = this.extractFileKey(url);
         if (!fileKey) {
           throw new Error(`Invalid Figma URL: ${url}`);
         }
+        if (this.database) {
+          const cachedData = await this.getFromDatabase(fileKey);
+          if (cachedData) {
+            logger.info(`\u26A1 Using cached data from database (analyzed ${this.getTimeAgo(cachedData.last_analyzed)})`);
+            return cachedData.tokens;
+          }
+        }
+        logger.info("\u23F3 Fetching fresh data from Figma API...");
+        const fileData = await this.getFileData(url);
         const tokens = {
           colors: [],
           typography: [],
@@ -747,7 +1535,226 @@ ${text}`);
             logger.warn(`Failed to download assets: ${error instanceof Error ? error.message : String(error)}`);
           }
         }
-        return tokens;
+        if (this.database) {
+          await this.persistToDatabase(url, fileKey, tokens);
+        }
+        return tokens;
+      }
+      /**
+       * Persist extracted tokens to database
+       */
+      async persistToDatabase(url, fileKey, tokens) {
+        if (!this.database) return;
+        try {
+          logger.info("Persisting Figma data to database...");
+          const fileId = fileKey;
+          await this.database.upsertFile({
+            id: fileId,
+            url,
+            name: url.split("/").pop() || "Figma Design",
+            file_key: fileKey,
+            last_analyzed: /* @__PURE__ */ new Date()
+          });
+          for (const screen of tokens.screens) {
+            await this.database.upsertScreen({
+              id: screen.id,
+              file_id: fileId,
+              name: screen.name,
+              width: screen.width,
+              height: screen.height,
+              type: screen.type,
+              children_count: screen.childrenCount
+            });
+          }
+          if (tokens.structure?.nodes) {
+            for (const node of tokens.structure.nodes) {
+              await this.database.upsertNode({
+                id: node.id,
+                file_id: fileId,
+                screen_id: this.findScreenIdForNode(node.id, tokens.screens),
+                parent_id: this.findParentId(node.id, tokens.structure.nodes),
+                name: node.name,
+                type: node.type,
+                content: node.content,
+                position_x: node.position?.x,
+                position_y: node.position?.y,
+                width: node.position?.width,
+                height: node.position?.height,
+                styles: node.styles ? JSON.stringify(node.styles) : void 0,
+                children_ids: node.children ? JSON.stringify(node.children) : void 0
+              });
+            }
+          }
+          for (const color of tokens.colors) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "color",
+              name: color.name,
+              value: color.hex,
+              category: "color"
+            });
+          }
+          for (const typo of tokens.typography) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "typography",
+              name: typo.name,
+              value: JSON.stringify({
+                fontFamily: typo.fontFamily,
+                fontSize: typo.fontSize,
+                fontWeight: typo.fontWeight,
+                lineHeight: typo.lineHeight
+              }),
+              category: "typography"
+            });
+          }
+          for (const component of tokens.components) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "component",
+              name: component.name,
+              value: component.type,
+              category: component.description
+            });
+          }
+          if (tokens.assets) {
+            for (const asset of tokens.assets) {
+              await this.database.upsertAsset({
+                file_id: fileId,
+                node_id: asset.nodeId,
+                node_name: asset.nodeName,
+                node_type: asset.nodeType,
+                format: asset.format,
+                file_path: asset.path,
+                url: asset.url,
+                width: asset.width,
+                height: asset.height
+              });
+            }
+          }
+          logger.info("Successfully persisted Figma data to database");
+        } catch (error) {
+          logger.error(`Failed to persist to database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+       * Get cached data from database
+       */
+      async getFromDatabase(fileKey) {
+        if (!this.database) return null;
+        try {
+          const file = await this.database.getFile(fileKey);
+          if (!file || !file.last_analyzed) return null;
+          const cacheAge = Date.now() - file.last_analyzed.getTime();
+          const maxAge = 24 * 60 * 60 * 1e3;
+          if (cacheAge > maxAge) {
+            logger.info("Cache expired, fetching fresh data...");
+            return null;
+          }
+          const screens = await this.database.getScreensByFile(fileKey);
+          const nodes = await this.database.getNodesByFile(fileKey);
+          const tokenRecords = await this.database.getDesignTokensByFile(fileKey);
+          const assets = await this.database.getAssetsByFile(fileKey);
+          const tokens = {
+            colors: tokenRecords.filter((t) => t.type === "color").map((t) => ({ name: t.name, hex: t.value, rgba: t.value })),
+            typography: tokenRecords.filter((t) => t.type === "typography").map((t) => {
+              const parsed = JSON.parse(t.value);
+              return {
+                name: t.name,
+                fontFamily: parsed.fontFamily,
+                fontSize: parsed.fontSize,
+                fontWeight: parsed.fontWeight,
+                lineHeight: parsed.lineHeight,
+                letterSpacing: parsed.letterSpacing
+              };
+            }),
+            spacing: {
+              unit: 8,
+              scale: [4, 8, 12, 16, 24, 32, 48, 64]
+            },
+            components: tokenRecords.filter((t) => t.type === "component").map((t) => ({ name: t.name, type: t.value, description: t.category })),
+            screens: screens.map((s) => ({
+              id: s.id,
+              name: s.name,
+              width: s.width || 0,
+              height: s.height || 0,
+              type: s.type || "FRAME",
+              description: s.description,
+              childrenCount: s.children_count
+            })),
+            breakpoints: [375, 768, 1024, 1280, 1920],
+            structure: {
+              nodes: nodes.map((n) => ({
+                id: n.id,
+                name: n.name,
+                type: n.type,
+                content: n.content,
+                position: n.position_x !== void 0 ? {
+                  x: n.position_x,
+                  y: n.position_y || 0,
+                  width: n.width || 0,
+                  height: n.height || 0
+                } : void 0,
+                styles: n.styles ? JSON.parse(n.styles) : void 0,
+                children: n.children_ids ? JSON.parse(n.children_ids) : void 0
+              })),
+              hierarchy: this.buildHierarchy(nodes)
+            },
+            assets: assets.map((a) => ({
+              nodeId: a.node_id,
+              nodeName: a.node_name || "",
+              nodeType: a.node_type || "",
+              format: a.format || "png",
+              path: a.file_path || "",
+              url: a.url || "",
+              width: a.width,
+              height: a.height
+            }))
+          };
+          return { tokens, last_analyzed: file.last_analyzed };
+        } catch (error) {
+          logger.warn(`Failed to retrieve from database: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      /**
+       * Build hierarchy string from nodes
+       */
+      buildHierarchy(nodes) {
+        return nodes.map((n) => `${n.type} "${n.name}" [${n.id}]`).join("\n");
+      }
+      /**
+       * Get human-readable time ago
+       */
+      getTimeAgo(date) {
+        const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+        if (seconds < 60) return `${seconds} seconds ago`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) return `${minutes} minutes ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24) return `${hours} hours ago`;
+        const days = Math.floor(hours / 24);
+        return `${days} days ago`;
+      }
+      /**
+       * Helper to find which screen a node belongs to
+       */
+      findScreenIdForNode(nodeId, screens) {
+        if (screens.find((s) => s.id === nodeId)) {
+          return nodeId;
+        }
+        return void 0;
+      }
+      /**
+       * Helper to find parent node ID
+       */
+      findParentId(nodeId, nodes) {
+        for (const node of nodes) {
+          if (node.children?.includes(nodeId)) {
+            return node.id;
+          }
+        }
+        return void 0;
       }
       /**
        * Recursively extract colors from nodes
@@ -1019,11 +2026,66 @@ ${text}`);
 var figma_screen_developer_exports = {};
 __export(figma_screen_developer_exports, {
   checkCurrentCodeStatus: () => checkCurrentCodeStatus,
-  compareCodeWithFigma: () => compareCodeWithFigma
+  compareCodeWithFigma: () => compareCodeWithFigma,
+  getCachedFigmaData: () => getCachedFigmaData
 });
 import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
 import { join as join8 } from "path";
 import { existsSync as existsSync3 } from "fs";
+async function getCachedFigmaData(url, database) {
+  if (!database) return null;
+  try {
+    const file = await database.getFileByUrl(url);
+    if (!file) return null;
+    const screens = await database.getScreensByFile(file.id);
+    const nodes = await database.getNodesByFile(file.id);
+    const tokens = await database.getDesignTokensByFile(file.id);
+    const assets = await database.getAssetsByFile(file.id);
+    return {
+      screens: screens.map((s) => ({
+        id: s.id,
+        name: s.name,
+        width: s.width,
+        height: s.height,
+        type: s.type,
+        childrenCount: s.children_count
+      })),
+      nodes: nodes.map((n) => ({
+        id: n.id,
+        name: n.name,
+        type: n.type,
+        content: n.content,
+        position: n.position_x ? {
+          x: n.position_x,
+          y: n.position_y,
+          width: n.width,
+          height: n.height
+        } : void 0,
+        styles: n.styles ? JSON.parse(n.styles) : void 0,
+        children: n.children_ids ? JSON.parse(n.children_ids) : void 0
+      })),
+      tokens: tokens.map((t) => ({
+        type: t.type,
+        name: t.name,
+        value: t.value,
+        category: t.category
+      })),
+      assets: assets.map((a) => ({
+        nodeId: a.node_id,
+        nodeName: a.node_name,
+        nodeType: a.node_type,
+        format: a.format,
+        path: a.file_path,
+        url: a.url,
+        width: a.width,
+        height: a.height
+      }))
+    };
+  } catch (error) {
+    logger.warn(`Failed to get cached Figma data: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
 async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   const status = {
     hasHTML: false,
@@ -1083,7 +2145,12 @@ async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   }
   return status;
 }
-async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath = process.cwd()) {
+async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath = process.cwd(), database, figmaUrl) {
+  let cachedData;
+  if (database && figmaUrl) {
+    cachedData = await getCachedFigmaData(figmaUrl, database);
+  }
+  const dataToUse = cachedData || figmaTokens;
   const codeStatus = await checkCurrentCodeStatus(projectPath);
   const result = {
     missingSections: [],
@@ -1091,17 +2158,18 @@ async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath =
     needsUpdate: false,
     recommendations: []
   };
-  const selectedScreen = figmaTokens.screens?.find((s) => s.id === selectedScreenId);
+  const selectedScreen = dataToUse.screens?.find((s) => s.id === selectedScreenId);
   if (!selectedScreen) {
     result.recommendations.push("Selected screen not found in Figma design");
     return result;
   }
   const figmaSections = [];
-  if (figmaTokens.structure?.nodes) {
-    const screenNode = figmaTokens.structure.nodes.find((n) => n.id === selectedScreenId);
+  if (dataToUse.structure?.nodes || dataToUse.nodes) {
+    const nodes = dataToUse.structure?.nodes || dataToUse.nodes;
+    const screenNode = nodes.find((n) => n.id === selectedScreenId);
     if (screenNode?.children) {
       screenNode.children.forEach((childId) => {
-        const childNode = figmaTokens.structure.nodes.find((n) => n.id === childId);
+        const childNode = nodes.find((n) => n.id === childId);
         if (childNode && (childNode.type === "FRAME" || childNode.type === "COMPONENT")) {
           const sectionName = childNode.name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-");
           figmaSections.push(sectionName);
@@ -1578,104 +2646,328 @@ type: ${type}
 `);
             });
           }
-          content = content.replace(
-            /updated:\s*.+/,
-            `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
-          );
-          await writeFile5(filePath, content);
-          return true;
-        } catch {
-          return false;
+          content = content.replace(
+            /updated:\s*.+/,
+            `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+          );
+          await writeFile5(filePath, content);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Complete a bead with quality gates
+       */
+      async completeBead(id) {
+        const gates = [
+          { name: "Type Check", command: "npm run typecheck" },
+          { name: "Tests", command: "npm run test" },
+          { name: "Lint", command: "npm run lint" },
+          { name: "Build", command: "npm run build" }
+        ];
+        const results = [];
+        for (const gate of gates) {
+          try {
+            await execAsync(gate.command, { cwd: this.projectPath });
+            results.push({ name: gate.name, passed: true });
+            logger.success(`${gate.name}: passed`);
+          } catch (error) {
+            results.push({
+              name: gate.name,
+              passed: false,
+              error: error instanceof Error ? error.message.slice(0, 200) : "Failed"
+            });
+            logger.error(`${gate.name}: failed`);
+          }
+        }
+        const allPassed = results.every((r) => r.passed);
+        if (allPassed) {
+          await this.updateBeadStatus(id, "completed");
+          await this.addNote(id, "Task completed - all quality gates passed");
+          const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+          const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const config = await loadConfig2(this.projectPath);
+          const memory = new MemoryManager2(config);
+          await memory.createHandoff({
+            completed: [id],
+            inProgress: [],
+            remaining: [],
+            context: `Auto-generated handoff for completed task: ${id}`,
+            nextSteps: ["Review completed work", "Start new task if needed"]
+          });
+        } else {
+          await this.addNote(id, "Completion attempted but quality gates failed");
+        }
+        return {
+          success: allPassed,
+          gates: results,
+          handoffCreated: allPassed
+        };
+      }
+      /**
+       * Get current active bead
+       */
+      async getCurrentBead() {
+        const beads = await this.listBeads();
+        return beads.find((b) => b.status === "in-progress") || null;
+      }
+      /**
+       * Parse a bead file
+       */
+      parseBeadFile(fileName, content) {
+        try {
+          const id = fileName.replace(".md", "");
+          const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+          const frontmatter = frontmatterMatch?.[1] || "";
+          const getValue = (key) => {
+            const match = frontmatter.match(new RegExp(`${key}:\\s*(.+)`));
+            return match?.[1]?.trim() || "";
+          };
+          const titleMatch = content.match(/^# (.+)/m);
+          const title = getValue("title") || titleMatch?.[1] || id;
+          const descMatch = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
+          const description = descMatch?.[1]?.trim() || "";
+          const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
+          const notesContent = notesMatch?.[1] || "";
+          const notes = notesContent.split("\n").filter((line) => line.trim().startsWith("-")).map((line) => line.replace(/^-\s*/, "").trim());
+          const type = getValue("type");
+          return {
+            id,
+            title,
+            description,
+            status: getValue("status") || "todo",
+            type,
+            createdAt: new Date(getValue("created") || Date.now()),
+            updatedAt: new Date(getValue("updated") || Date.now()),
+            notes
+          };
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/core/tool-config.ts
+var tool_config_exports = {};
+__export(tool_config_exports, {
+  ToolConfigManager: () => ToolConfigManager
+});
+import { readFile as readFile7, writeFile as writeFile7, mkdir as mkdir7, access as access4, constants as constants4 } from "fs/promises";
+import { join as join11 } from "path";
+import { homedir as homedir2 } from "os";
+import { z as z3 } from "zod";
+var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
+var init_tool_config = __esm({
+  "src/core/tool-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    ToolConfigSchema = z3.object({
+      name: z3.string(),
+      status: z3.enum(["ready", "needs_config", "error"]),
+      description: z3.string(),
+      configMethod: z3.enum(["oauth", "manual", "none"]),
+      config: z3.record(z3.unknown()).optional(),
+      errorMessage: z3.string().optional()
+    });
+    REGISTERED_TOOLS = [
+      {
+        name: "figma-analysis",
+        description: "Analyze Figma designs and extract design tokens using Figma API",
+        configMethod: "oauth"
+      }
+      // Add more tools here as needed
+    ];
+    ToolConfigManager = class {
+      config;
+      toolsConfigPath;
+      constructor(config) {
+        this.config = config;
+        this.toolsConfigPath = join11(this.config.configPath, "config", "tools.json");
+      }
+      /**
+       * Get all registered tools with their current status
+       */
+      async listTools() {
+        const savedConfigs = await this.loadConfigs();
+        const tools = [];
+        for (const tool of REGISTERED_TOOLS) {
+          const saved = savedConfigs[tool.name];
+          const toolConfig = {
+            ...tool,
+            status: this.determineStatus(tool, saved),
+            config: saved?.config,
+            errorMessage: saved?.errorMessage
+          };
+          tools.push(toolConfig);
+        }
+        return tools;
+      }
+      /**
+       * Get configuration for a specific tool
+       */
+      async getToolConfig(toolName) {
+        const tools = await this.listTools();
+        return tools.find((t) => t.name === toolName) || null;
+      }
+      /**
+       * Update tool configuration
+       */
+      async updateToolConfig(toolName, updates) {
+        const savedConfigs = await this.loadConfigs();
+        const tool = REGISTERED_TOOLS.find((t) => t.name === toolName);
+        if (!tool) {
+          throw new Error(`Tool not found: ${toolName}`);
+        }
+        const existing = savedConfigs[toolName] || {};
+        savedConfigs[toolName] = {
+          ...existing,
+          ...updates
+        };
+        await this.saveConfigs(savedConfigs);
+      }
+      /**
+       * Check if a tool is ready to use
+       */
+      async isToolReady(toolName) {
+        const toolConfig = await this.getToolConfig(toolName);
+        const isReady = toolConfig?.status === "ready";
+        logger.info(`\u{1F50D} Tool ready check for ${toolName}:`, {
+          hasConfig: !!toolConfig,
+          status: toolConfig?.status,
+          isReady
+        });
+        return isReady;
+      }
+      /**
+       * Get API key for a tool (if configured)
+       */
+      async getApiKey(toolName) {
+        const toolConfig = await this.getToolConfig(toolName);
+        logger.info(`\u{1F50D} Getting API key for ${toolName}:`, {
+          hasConfig: !!toolConfig,
+          hasApiKey: !!toolConfig?.config?.apiKey,
+          status: toolConfig?.status,
+          apiKeyLength: typeof toolConfig?.config?.apiKey === "string" ? toolConfig.config.apiKey.length : 0
+        });
+        if (toolConfig?.config?.apiKey && typeof toolConfig.config.apiKey === "string") {
+          return toolConfig.config.apiKey;
+        }
+        return null;
+      }
+      /**
+       * Determine tool status based on configuration
+       */
+      determineStatus(tool, saved) {
+        if (tool.configMethod === "none") {
+          logger.info(`\u{1F50D} Tool ${tool.name} uses 'none' config method - marking as ready`);
+          return "ready";
+        }
+        if (saved?.errorMessage) {
+          logger.warn(`\u{1F50D} Tool ${tool.name} has error: ${saved.errorMessage}`);
+          return "error";
+        }
+        if (tool.configMethod === "oauth" || tool.configMethod === "manual") {
+          const hasApiKey = saved?.config?.apiKey && typeof saved.config.apiKey === "string" && saved.config.apiKey.length > 0;
+          logger.info(`\u{1F50D} Tool ${tool.name} status check:`, {
+            configMethod: tool.configMethod,
+            hasSaved: !!saved,
+            hasConfig: !!saved?.config,
+            hasApiKey,
+            apiKeyLength: typeof saved?.config?.apiKey === "string" ? saved.config.apiKey.length : 0
+          });
+          if (hasApiKey) {
+            return "ready";
+          }
+          return "needs_config";
         }
+        logger.warn(`\u{1F50D} Tool ${tool.name} fell through to default 'needs_config'`);
+        return "needs_config";
       }
       /**
-       * Complete a bead with quality gates
+       * Load saved configurations
+       * Checks both global and project configs, project takes precedence
        */
-      async completeBead(id) {
-        const gates = [
-          { name: "Type Check", command: "npm run typecheck" },
-          { name: "Tests", command: "npm run test" },
-          { name: "Lint", command: "npm run lint" },
-          { name: "Build", command: "npm run build" }
-        ];
-        const results = [];
-        for (const gate of gates) {
-          try {
-            await execAsync(gate.command, { cwd: this.projectPath });
-            results.push({ name: gate.name, passed: true });
-            logger.success(`${gate.name}: passed`);
-          } catch (error) {
-            results.push({
-              name: gate.name,
-              passed: false,
-              error: error instanceof Error ? error.message.slice(0, 200) : "Failed"
-            });
-            logger.error(`${gate.name}: failed`);
-          }
+      async loadConfigs() {
+        const globalConfigPath = join11(homedir2(), ".config", "aikit", "config", "tools.json");
+        let configs = {};
+        try {
+          await access4(globalConfigPath, constants4.R_OK);
+          const content = await readFile7(globalConfigPath, "utf-8");
+          configs = JSON.parse(content);
+          logger.info("Loaded global tool configs");
+        } catch {
         }
-        const allPassed = results.every((r) => r.passed);
-        if (allPassed) {
-          await this.updateBeadStatus(id, "completed");
-          await this.addNote(id, "Task completed - all quality gates passed");
-          const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
-          const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const config = await loadConfig2(this.projectPath);
-          const memory = new MemoryManager2(config);
-          await memory.createHandoff({
-            completed: [id],
-            inProgress: [],
-            remaining: [],
-            context: `Auto-generated handoff for completed task: ${id}`,
-            nextSteps: ["Review completed work", "Start new task if needed"]
-          });
-        } else {
-          await this.addNote(id, "Completion attempted but quality gates failed");
+        try {
+          await access4(this.toolsConfigPath, constants4.R_OK);
+          const content = await readFile7(this.toolsConfigPath, "utf-8");
+          const projectConfigs = JSON.parse(content);
+          configs = { ...configs, ...projectConfigs };
+          logger.info("Loaded project tool configs");
+        } catch {
         }
-        return {
-          success: allPassed,
-          gates: results,
-          handoffCreated: allPassed
-        };
+        return configs;
       }
       /**
-       * Get current active bead
+       * Save configurations
        */
-      async getCurrentBead() {
-        const beads = await this.listBeads();
-        return beads.find((b) => b.status === "in-progress") || null;
+      async saveConfigs(configs) {
+        const configDir = join11(this.config.configPath, "config");
+        await mkdir7(configDir, { recursive: true });
+        await writeFile7(this.toolsConfigPath, JSON.stringify(configs, null, 2));
       }
       /**
-       * Parse a bead file
+       * Configure Claude Desktop MCP server for a tool
+       * This adds the MCP server configuration to Claude Desktop's config file
        */
-      parseBeadFile(fileName, content) {
+      async configureMcpServer(toolName, apiKey) {
+        if (toolName !== "figma-analysis") {
+          logger.info(`MCP server configuration not implemented for tool: ${toolName}`);
+          return;
+        }
+        const isWindows = process.platform === "win32";
+        const claudeConfigBase = isWindows ? process.env.APPDATA || join11(homedir2(), "AppData", "Roaming") : join11(homedir2(), ".config");
+        const claudeConfigPath = join11(claudeConfigBase, "claude", "claude_desktop_config.json");
         try {
-          const id = fileName.replace(".md", "");
-          const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-          const frontmatter = frontmatterMatch?.[1] || "";
-          const getValue = (key) => {
-            const match = frontmatter.match(new RegExp(`${key}:\\s*(.+)`));
-            return match?.[1]?.trim() || "";
-          };
-          const titleMatch = content.match(/^# (.+)/m);
-          const title = getValue("title") || titleMatch?.[1] || id;
-          const descMatch = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
-          const description = descMatch?.[1]?.trim() || "";
-          const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
-          const notesContent = notesMatch?.[1] || "";
-          const notes = notesContent.split("\n").filter((line) => line.trim().startsWith("-")).map((line) => line.replace(/^-\s*/, "").trim());
-          const type = getValue("type");
-          return {
-            id,
-            title,
-            description,
-            status: getValue("status") || "todo",
-            type,
-            createdAt: new Date(getValue("created") || Date.now()),
-            updatedAt: new Date(getValue("updated") || Date.now()),
-            notes
+          let claudeConfig = {};
+          try {
+            const content = await readFile7(claudeConfigPath, "utf-8");
+            claudeConfig = JSON.parse(content);
+          } catch {
+            claudeConfig = {};
+          }
+          if (!claudeConfig.mcpServers) {
+            claudeConfig.mcpServers = {};
+          }
+          claudeConfig.mcpServers.figma = {
+            command: "npx",
+            args: ["-y", "figma-developer-mcp", `--figma-oauth-token=${apiKey}`, "--stdio"]
           };
-        } catch {
-          return null;
+          const claudeConfigDir = join11(claudeConfigBase, "claude");
+          await mkdir7(claudeConfigDir, { recursive: true });
+          await writeFile7(claudeConfigPath, JSON.stringify(claudeConfig, null, 2));
+          logger.success("\u2705 Claude Desktop MCP server configured");
+          logger.info(`   Config file: ${claudeConfigPath}`);
+          logger.info("");
+          logger.info("\u26A0\uFE0F  IMPORTANT: Restart Claude Desktop for changes to take effect");
+        } catch (error) {
+          logger.warn(`Could not configure MCP server automatically: ${error instanceof Error ? error.message : String(error)}`);
+          logger.info("");
+          logger.info("Please configure manually:");
+          logger.info(`1. Edit: ${claudeConfigPath}`);
+          logger.info('2. Add the following to "mcpServers":');
+          logger.info(JSON.stringify({
+            figma: {
+              command: "npx",
+              args: ["-y", "figma-developer-mcp"],
+              env: {
+                FIGMA_OAUTH_TOKEN: apiKey
+              }
+            }
+          }, null, 2));
         }
       }
     };
@@ -1688,8 +2980,8 @@ __export(sessions_exports, {
   SessionManager: () => SessionManager,
   formatSession: () => formatSession
 });
-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 { readFile as readFile9, writeFile as writeFile11, readdir as readdir7, mkdir as mkdir11, access as access5, constants as constants5 } from "fs/promises";
+import { join as join16 } from "path";
 import matter3 from "gray-matter";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -1721,8 +3013,8 @@ var init_sessions = __esm({
       aikitDir;
       constructor(projectPath) {
         this.projectPath = projectPath || process.cwd();
-        this.aikitDir = join15(this.projectPath, ".aikit");
-        this.sessionsDir = join15(this.aikitDir, "sessions");
+        this.aikitDir = join16(this.projectPath, ".aikit");
+        this.sessionsDir = join16(this.aikitDir, "sessions");
       }
       /**
        * Get current terminal's TTY path
@@ -1758,7 +3050,7 @@ var init_sessions = __esm({
        */
       async getSessionTrackerPath() {
         const identifier = await this.getTerminalIdentifier();
-        return join15(this.sessionsDir, `.current-${identifier}-session`);
+        return join16(this.sessionsDir, `.current-${identifier}-session`);
       }
       /**
        * Switch to a different session in the current terminal
@@ -1769,7 +3061,7 @@ var init_sessions = __esm({
           throw new Error(`Session not found: ${sessionId}`);
         }
         const sessionFile = await this.getSessionTrackerPath();
-        await writeFile10(sessionFile, sessionId);
+        await writeFile11(sessionFile, sessionId);
       }
       /**
        * Initialize the current terminal's session file
@@ -1778,9 +3070,9 @@ var init_sessions = __esm({
       async initTerminalSession() {
         const sessionFile = await this.getSessionTrackerPath();
         try {
-          await access4(sessionFile);
+          await access5(sessionFile);
         } catch {
-          await writeFile10(sessionFile, "");
+          await writeFile11(sessionFile, "");
         }
         return { tracker: sessionFile };
       }
@@ -1797,7 +3089,7 @@ var init_sessions = __esm({
        */
       async ensureAikitExists() {
         try {
-          await access4(this.aikitDir, constants4.R_OK);
+          await access5(this.aikitDir, constants5.R_OK);
         } catch {
           throw new Error(
             `AIKit not initialized in current directory (${this.projectPath}). Run 'aikit init' first to initialize AIKit in this directory.`
@@ -1809,7 +3101,7 @@ var init_sessions = __esm({
        */
       async init() {
         await this.ensureAikitExists();
-        await mkdir10(this.sessionsDir, { recursive: true });
+        await mkdir11(this.sessionsDir, { recursive: true });
       }
       /**
        * Start a new session
@@ -1939,9 +3231,9 @@ var init_sessions = __esm({
        */
       async getSession(id) {
         await this.ensureAikitExists();
-        const filePath = join15(this.sessionsDir, `${id}.md`);
+        const filePath = join16(this.sessionsDir, `${id}.md`);
         try {
-          const content = await readFile8(filePath, "utf-8");
+          const content = await readFile9(filePath, "utf-8");
           const { data, content: body } = matter3(content);
           const updates = this.parseUpdates(body);
           return {
@@ -2025,7 +3317,7 @@ var init_sessions = __esm({
       async getActiveSessionId() {
         const sessionFile = await this.getSessionTrackerPath();
         try {
-          const content = await readFile8(sessionFile, "utf-8");
+          const content = await readFile9(sessionFile, "utf-8");
           return content.trim() || null;
         } catch {
           return null;
@@ -2037,7 +3329,7 @@ var init_sessions = __esm({
        */
       async setActiveSession(id) {
         const sessionFile = await this.getSessionTrackerPath();
-        await writeFile10(sessionFile, id);
+        await writeFile11(sessionFile, id);
       }
       /**
        * Clear active session for current terminal
@@ -2045,7 +3337,7 @@ var init_sessions = __esm({
       async clearActiveSession() {
         const sessionFile = await this.getSessionTrackerPath();
         try {
-          await writeFile10(sessionFile, "");
+          await writeFile11(sessionFile, "");
         } catch {
         }
       }
@@ -2053,7 +3345,7 @@ var init_sessions = __esm({
        * Save session to file
        */
       async saveSession(session) {
-        const filePath = join15(this.sessionsDir, `${session.id}.md`);
+        const filePath = join16(this.sessionsDir, `${session.id}.md`);
         const updatesMarkdown = session.updates.map((update) => {
           const date = new Date(update.timestamp);
           const dateStr = date.toLocaleString();
@@ -2102,7 +3394,7 @@ ${updatesMarkdown}
 ${this.generateSummary(session)}
 `;
         const fileContent = matter3.stringify(content, frontmatter);
-        await writeFile10(filePath, fileContent);
+        await writeFile11(filePath, fileContent);
       }
       /**
        * Generate session summary
@@ -2193,200 +3485,64 @@ ${this.generateSummary(session)}
             notesLines.push(line);
           }
         }
-        if (currentUpdate) {
-          currentUpdate.notes = notesLines.join("\n").trim();
-          updates.push(currentUpdate);
-        }
-        return updates;
-      }
-      /**
-       * Get git state
-       */
-      async getGitState() {
-        try {
-          const { stdout: branch } = await execAsync2("git rev-parse --abbrev-ref HEAD");
-          const { stdout: log } = await execAsync2("git log --oneline | wc -l");
-          return {
-            branch: branch.trim(),
-            commits: parseInt(log.trim(), 10)
-          };
-        } catch {
-          return { branch: "main" };
-        }
-      }
-      /**
-       * Get modified files
-       */
-      async getModifiedFiles() {
-        try {
-          const { stdout } = await execAsync2("git status --porcelain");
-          const lines = stdout.trim().split("\n");
-          return lines.filter((line) => line.trim()).map((line) => line.substring(3));
-        } catch {
-          return [];
-        }
-      }
-      /**
-       * Get current Beads task
-       * 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 = 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 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")) {
-              return {
-                id,
-                status: statusMatch[1]
-              };
-            }
-          }
-          return null;
-        } catch {
-          return null;
-        }
-      }
-    };
-  }
-});
-
-// src/core/tool-config.ts
-var tool_config_exports = {};
-__export(tool_config_exports, {
-  ToolConfigManager: () => ToolConfigManager
-});
-import { readFile as 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({
-  "src/core/tool-config.ts"() {
-    "use strict";
-    init_esm_shims();
-    ToolConfigSchema = z3.object({
-      name: z3.string(),
-      status: z3.enum(["ready", "needs_config", "error"]),
-      description: z3.string(),
-      configMethod: z3.enum(["oauth", "manual", "none"]),
-      config: z3.record(z3.unknown()).optional(),
-      errorMessage: z3.string().optional()
-    });
-    REGISTERED_TOOLS = [
-      {
-        name: "figma-analysis",
-        description: "Analyze Figma designs and extract design tokens using Figma API",
-        configMethod: "oauth"
-      }
-      // Add more tools here as needed
-    ];
-    ToolConfigManager = class {
-      config;
-      toolsConfigPath;
-      constructor(config) {
-        this.config = config;
-        this.toolsConfigPath = join23(this.config.configPath, "config", "tools.json");
-      }
-      /**
-       * Get all registered tools with their current status
-       */
-      async listTools() {
-        const savedConfigs = await this.loadConfigs();
-        const tools = [];
-        for (const tool of REGISTERED_TOOLS) {
-          const saved = savedConfigs[tool.name];
-          const toolConfig = {
-            ...tool,
-            status: this.determineStatus(tool, saved),
-            config: saved?.config,
-            errorMessage: saved?.errorMessage
-          };
-          tools.push(toolConfig);
-        }
-        return tools;
-      }
-      /**
-       * Get configuration for a specific tool
-       */
-      async getToolConfig(toolName) {
-        const tools = await this.listTools();
-        return tools.find((t) => t.name === toolName) || null;
-      }
-      /**
-       * Update tool configuration
-       */
-      async updateToolConfig(toolName, updates) {
-        const savedConfigs = await this.loadConfigs();
-        const tool = REGISTERED_TOOLS.find((t) => t.name === toolName);
-        if (!tool) {
-          throw new Error(`Tool not found: ${toolName}`);
-        }
-        const existing = savedConfigs[toolName] || {};
-        savedConfigs[toolName] = {
-          ...existing,
-          ...updates
-        };
-        await this.saveConfigs(savedConfigs);
-      }
-      /**
-       * Check if a tool is ready to use
-       */
-      async isToolReady(toolName) {
-        const toolConfig = await this.getToolConfig(toolName);
-        return toolConfig?.status === "ready";
-      }
-      /**
-       * Get API key for a tool (if configured)
-       */
-      async getApiKey(toolName) {
-        const toolConfig = await this.getToolConfig(toolName);
-        if (toolConfig?.config?.apiKey && typeof toolConfig.config.apiKey === "string") {
-          return toolConfig.config.apiKey;
+        if (currentUpdate) {
+          currentUpdate.notes = notesLines.join("\n").trim();
+          updates.push(currentUpdate);
         }
-        return null;
+        return updates;
       }
       /**
-       * Determine tool status based on configuration
+       * Get git state
        */
-      determineStatus(tool, saved) {
-        if (tool.configMethod === "none") {
-          return "ready";
-        }
-        if (saved?.errorMessage) {
-          return "error";
-        }
-        if (tool.configMethod === "oauth" || tool.configMethod === "manual") {
-          if (saved?.config?.apiKey && typeof saved.config.apiKey === "string" && saved.config.apiKey.length > 0) {
-            return "ready";
-          }
-          return "needs_config";
+      async getGitState() {
+        try {
+          const { stdout: branch } = await execAsync2("git rev-parse --abbrev-ref HEAD");
+          const { stdout: log } = await execAsync2("git log --oneline | wc -l");
+          return {
+            branch: branch.trim(),
+            commits: parseInt(log.trim(), 10)
+          };
+        } catch {
+          return { branch: "main" };
         }
-        return "needs_config";
       }
       /**
-       * Load saved configurations
+       * Get modified files
        */
-      async loadConfigs() {
+      async getModifiedFiles() {
         try {
-          await access7(this.toolsConfigPath, constants5.R_OK);
-          const content = await readFile15(this.toolsConfigPath, "utf-8");
-          return JSON.parse(content);
+          const { stdout } = await execAsync2("git status --porcelain");
+          const lines = stdout.trim().split("\n");
+          return lines.filter((line) => line.trim()).map((line) => line.substring(3));
         } catch {
-          return {};
+          return [];
         }
       }
       /**
-       * Save configurations
+       * 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 saveConfigs(configs) {
-        const configDir = join23(this.config.configPath, "config");
-        await mkdir16(configDir, { recursive: true });
-        await writeFile18(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+      async getCurrentBeadsTask() {
+        const beadsDir = join16(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 readFile9(join16(beadsDir, file), "utf-8");
+            const statusMatch = content.match(/^status:\s*(\w+)/m);
+            const id = file.replace(".md", "");
+            if (statusMatch && (statusMatch[1] === "in-progress" || statusMatch[1] === "todo")) {
+              return {
+                id,
+                status: statusMatch[1]
+              };
+            }
+          }
+          return null;
+        } catch {
+          return null;
+        }
       }
     };
   }
@@ -5643,7 +6799,15 @@ This will guide you through setting up your Figma Personal Access Token.`;
       }
       try {
         const { FigmaMcpClient: FigmaMcpClient2 } = await Promise.resolve().then(() => (init_figma_mcp(), figma_mcp_exports));
-        const client = new FigmaMcpClient2(apiKey, configManager);
+        let database;
+        try {
+          if (context?.config) {
+            database = context.config.getDatabase();
+          }
+        } catch (error) {
+          logger.info("Database not available for Figma persistence");
+        }
+        const client = new FigmaMcpClient2(apiKey, configManager, database);
         const assetsDir = "./assets/images";
         const tokens = await client.extractDesignTokens(url, false, assetsDir);
         let result = `# Figma Design Analysis
@@ -5874,25 +7038,6 @@ Please check:
       }
     }
   },
-  {
-    name: "analyze_figma",
-    description: "Analyze a Figma design URL and extract all design tokens automatically. The URL should be provided in the user input after the command.",
-    args: {
-      url: {
-        type: "string",
-        description: "Figma design URL to analyze",
-        required: true
-      }
-    },
-    async execute({ url }) {
-      return `Figma analysis tool called for: ${url}
-
-Next steps:
-1. Use @vision agent to analyze the design
-2. Extract all design tokens
-3. Save to memory/research/figma-analysis.md`;
-    }
-  },
   {
     name: "develop_figma_screen",
     description: "Smart workflow to develop a specific Figma screen: check current code, pull needed assets, plan, and develop. User just needs to confirm the screen number/name.",
@@ -5924,7 +7069,15 @@ Next steps:
       try {
         const { FigmaMcpClient: FigmaMcpClient2 } = await Promise.resolve().then(() => (init_figma_mcp(), figma_mcp_exports));
         const { checkCurrentCodeStatus: checkCurrentCodeStatus2, compareCodeWithFigma: compareCodeWithFigma2 } = await Promise.resolve().then(() => (init_figma_screen_developer(), figma_screen_developer_exports));
-        const client = new FigmaMcpClient2(apiKey, configManager);
+        let database;
+        try {
+          if (context?.config) {
+            database = context.config.getDatabase();
+          }
+        } catch (error) {
+          logger.info("Database not available for Figma persistence");
+        }
+        const client = new FigmaMcpClient2(apiKey, configManager, database);
         const tokens = await client.extractDesignTokens(figmaUrl, false, "./assets/images");
         const screenIdStr = String(screenId);
         const selectedScreen = tokens.screens?.find(
@@ -6485,12 +7638,15 @@ ${argsDesc}
   }
 };
 
+// src/index.ts
+init_tool_config();
+
 // src/core/plugins.ts
 init_esm_shims();
 init_paths();
 init_logger();
-import { readdir as readdir6, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
-import { join as join11, basename as basename3, extname as extname4 } from "path";
+import { readdir as readdir6, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
+import { join as join12, basename as basename3, extname as extname4 } from "path";
 var PluginSystem = class {
   config;
   plugins = /* @__PURE__ */ new Map();
@@ -6588,9 +7744,9 @@ var PluginSystem = class {
   async createPlugin(name, options) {
     const configPath = options.global ? paths.globalConfig() : this.config.configPath;
     const pluginsDir = paths.plugins(configPath);
-    await mkdir7(pluginsDir, { recursive: true });
+    await mkdir8(pluginsDir, { recursive: true });
     const fileName = `${name}.ts`;
-    const filePath = join11(pluginsDir, fileName);
+    const filePath = join12(pluginsDir, fileName);
     const content = `import { Plugin } from 'aikit';
 
 /**
@@ -6606,7 +7762,7 @@ ${options.code}
 
 export default ${toPascalCase(name)}Plugin;
 `;
-    await writeFile7(filePath, content);
+    await writeFile8(filePath, content);
   }
   /**
    * Process event queue
@@ -6680,7 +7836,7 @@ export default ${toPascalCase(name)}Plugin;
     }
     for (const file of files) {
       if (extname4(file) !== ".ts" && extname4(file) !== ".js") continue;
-      const filePath = join11(dir, file);
+      const filePath = join12(dir, file);
       const name = basename3(file, extname4(file));
       this.plugins.set(name, {
         name,
@@ -6827,9 +7983,9 @@ async function getLatestVersion(packageName) {
 // src/utils/update-cache.ts
 init_esm_shims();
 init_paths();
-import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir9 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var CACHE_FILE = ".update-cache.json";
 var DEFAULT_CACHE = {
   lastCheckTime: 0,
@@ -6838,7 +7994,7 @@ var DEFAULT_CACHE = {
 };
 function getCachePath() {
   const configDir = paths.globalConfig();
-  return join12(configDir, CACHE_FILE);
+  return join13(configDir, CACHE_FILE);
 }
 async function readCache() {
   try {
@@ -6846,7 +8002,7 @@ async function readCache() {
     if (!existsSync5(cachePath)) {
       return DEFAULT_CACHE;
     }
-    const content = await readFile7(cachePath, "utf-8");
+    const content = await readFile8(cachePath, "utf-8");
     const data = JSON.parse(content);
     return { ...DEFAULT_CACHE, ...data };
   } catch {
@@ -6858,9 +8014,9 @@ async function writeCache(data) {
     const cachePath = getCachePath();
     const configDir = paths.globalConfig();
     if (!existsSync5(configDir)) {
-      await mkdir8(configDir, { recursive: true });
+      await mkdir9(configDir, { recursive: true });
     }
-    await writeFile8(cachePath, JSON.stringify(data, null, 2), "utf-8");
+    await writeFile9(cachePath, JSON.stringify(data, null, 2), "utf-8");
   } catch {
   }
 }
@@ -6899,16 +8055,16 @@ async function incrementError(error) {
 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";
+import { writeFile as writeFile10, mkdir as mkdir10 } from "fs/promises";
+import { join as join14 } from "path";
 async function spawnUpdateProcess(targetVersion) {
   try {
     const configDir = paths.globalConfig();
-    const logsDir = join13(configDir, "logs");
-    await mkdir9(logsDir, { recursive: true });
+    const logsDir = join14(configDir, "logs");
+    await mkdir10(logsDir, { recursive: true });
     const scriptContent = generateUpdateScript(targetVersion, logsDir);
-    const scriptPath = join13(configDir, "update-script.js");
-    await writeFile9(scriptPath, scriptContent, "utf-8");
+    const scriptPath = join14(configDir, "update-script.js");
+    await writeFile10(scriptPath, scriptContent, "utf-8");
     const child = spawn(process.execPath, [scriptPath], {
       detached: true,
       stdio: "ignore",
@@ -7082,8 +8238,8 @@ init_beads();
 init_esm_shims();
 import { execSync } from "child_process";
 import { existsSync as existsSync6 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join15 } from "path";
+import { homedir as homedir3 } from "os";
 var CliPlatform = /* @__PURE__ */ ((CliPlatform2) => {
   CliPlatform2["OPENCODE"] = "opencode";
   CliPlatform2["CLAUDE"] = "claude";
@@ -7096,8 +8252,8 @@ var CliDetector = class {
    */
   static async checkOpenCode() {
     try {
-      const opencodePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".config");
-      const opencodeConfig = join14(opencodePath, "opencode", "opencode.json");
+      const opencodePath = process.platform === "win32" ? process.env.APPDATA || join15(homedir3(), "AppData", "Roaming") : join15(homedir3(), ".config");
+      const opencodeConfig = join15(opencodePath, "opencode", "opencode.json");
       let installed = existsSync6(opencodeConfig);
       let version;
       if (installed) {
@@ -7202,14 +8358,14 @@ var CliDetector = class {
    */
   static async detectPlatforms() {
     const platforms = [];
-    const opencodePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".config");
+    const opencodePath = process.platform === "win32" ? process.env.APPDATA || join15(homedir3(), "AppData", "Roaming") : join15(homedir3(), ".config");
     platforms.push({
       platform: "opencode" /* OPENCODE */,
       displayName: "OpenCode",
-      installed: existsSync6(join14(opencodePath, "opencode", "opencode.json")),
+      installed: existsSync6(join15(opencodePath, "opencode", "opencode.json")),
       configPath: opencodePath
     });
-    const claudePath = process.platform === "win32" ? process.env.APPDATA || join14(homedir2(), "AppData", "Roaming") : join14(homedir2(), ".claude");
+    const claudePath = process.platform === "win32" ? process.env.APPDATA || join15(homedir3(), "AppData", "Roaming") : join15(homedir3(), ".claude");
     platforms.push({
       platform: "claude" /* CLAUDE */,
       displayName: "Claude Code CLI",
@@ -7247,15 +8403,15 @@ init_paths();
 // src/cli/helpers.ts
 init_esm_shims();
 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 { mkdir as mkdir12, writeFile as writeFile12, readFile as readFile10, access as access6 } from "fs/promises";
+import { join as join17, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execSync as execSync2 } from "child_process";
 init_config();
 init_logger();
 init_paths();
-async function initializeConfig(configDir, _isGlobal) {
+async function initializeConfig(configDir, _isGlobal, platformConfig) {
   const dirs = [
     "",
     "skills",
@@ -7274,10 +8430,17 @@ async function initializeConfig(configDir, _isGlobal) {
     "memory/research"
   ];
   for (const dir of dirs) {
-    await mkdir11(join16(configDir, dir), { recursive: true });
+    await mkdir12(join17(configDir, dir), { recursive: true });
   }
+  const platform = platformConfig || {
+    primary: "opencode",
+    opencode: true,
+    claude: false
+    // Archived - can be re-enabled later
+  };
   const defaultConfig = {
     version: getVersion(),
+    platform,
     skills: { enabled: true },
     agents: { enabled: true, default: "build" },
     commands: { enabled: true },
@@ -7285,10 +8448,11 @@ async function initializeConfig(configDir, _isGlobal) {
     plugins: { enabled: true },
     memory: { enabled: true },
     beads: { enabled: true },
-    antiHallucination: { enabled: true }
+    antiHallucination: { enabled: true },
+    database: { enabled: true, path: ".aikit/figma.db" }
   };
-  await writeFile11(
-    join16(configDir, "aikit.json"),
+  await writeFile12(
+    join17(configDir, "aikit.json"),
     JSON.stringify(defaultConfig, null, 2)
   );
   const agentsMd = `# AIKit Agent Rules
@@ -7311,20 +8475,20 @@ async function initializeConfig(configDir, _isGlobal) {
 ## Project-Specific Rules
 Add your project-specific rules here.
 `;
-  await writeFile11(join16(configDir, "AGENTS.md"), agentsMd);
+  await writeFile12(join17(configDir, "AGENTS.md"), agentsMd);
 }
 async function configureMcpServer(projectPath) {
   const currentFile = fileURLToPath3(import.meta.url);
   const currentDir = dirname2(currentFile);
-  const aikitPath = join16(currentDir, "..", "..");
-  const mcpServerPath = join16(aikitPath, "dist", "mcp-server.js");
+  const aikitPath = join17(currentDir, "..", "..");
+  const mcpServerPath = join17(aikitPath, "dist", "mcp-server.js");
   const configLocations = [
     // Global config (most common)
-    join16(homedir3(), ".config", "opencode", "opencode.json"),
+    join17(homedir4(), ".config", "opencode", "opencode.json"),
     // Project-level config
-    join16(projectPath, ".opencode", "opencode.json"),
+    join17(projectPath, ".opencode", "opencode.json"),
     // Alternative global location
-    join16(homedir3(), ".opencode", "opencode.json")
+    join17(homedir4(), ".opencode", "opencode.json")
   ];
   const mcpServerConfig = {
     type: "local",
@@ -7333,12 +8497,12 @@ async function configureMcpServer(projectPath) {
   };
   for (const configPath of configLocations) {
     try {
-      const configDir = join16(configPath, "..");
-      await mkdir11(configDir, { recursive: true });
+      const configDir = join17(configPath, "..");
+      await mkdir12(configDir, { recursive: true });
       let config = {};
       if (existsSync7(configPath)) {
         try {
-          const existing = await readFile9(configPath, "utf-8");
+          const existing = await readFile10(configPath, "utf-8");
           config = JSON.parse(existing);
         } catch {
           config = {};
@@ -7348,7 +8512,7 @@ async function configureMcpServer(projectPath) {
         config.mcp = {};
       }
       config.mcp.aikit = mcpServerConfig;
-      await writeFile11(configPath, JSON.stringify(config, null, 2));
+      await writeFile12(configPath, JSON.stringify(config, null, 2));
       logger.success(`
 \u2705 MCP server configured: ${configPath}`);
       logger.info(`   Server: node ${mcpServerPath}`);
@@ -7357,9 +8521,9 @@ async function configureMcpServer(projectPath) {
       continue;
     }
   }
-  const instructionsPath = join16(projectPath, ".opencode", "MCP_SETUP.md");
-  await mkdir11(join16(projectPath, ".opencode"), { recursive: true });
-  await writeFile11(instructionsPath, `# AIKit MCP Server Configuration
+  const instructionsPath = join17(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir12(join17(projectPath, ".opencode"), { recursive: true });
+  await writeFile12(instructionsPath, `# AIKit MCP Server Configuration
 
 ## Automatic Setup Failed
 
@@ -7531,50 +8695,18 @@ Analyze a Figma design and extract design tokens
 ## Examples
 - \`/analyze-figma https://www.figma.com/design/...\`
 
-## \u26A0\uFE0F CRITICAL: Extract URL FIRST!
-
-**BEFORE ANYTHING ELSE**: Look at the user's FULL input message (all lines) and find the Figma URL. It's ALWAYS there - never ask for it!
-
-**The URL pattern**: Look for text containing \`figma.com/design/\` anywhere in the user's message.
-
-**Example of what user input looks like**:
-\`\`\`
-/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
-Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
-\`\`\`
-
-**Extract the complete URL** (combine if split):
-\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
-
 ## Workflow
 
-**IMPORTANT**: When user provides a Figma URL, you MUST immediately:
+Analyze a Figma design and extract all design tokens automatically using Figma API.
 
-**Step 1: Extract URL from User Input**
+**Step 1: Extract Figma URL**
+
+The Figma URL is provided as: \`$ARGUMENTS\`
 
-**CRITICAL**: The URL is ALWAYS in the user's input message! DO NOT ask for it - just extract it!
-
-**MANDATORY**: You MUST extract the URL before proceeding. This is not optional!
-
-**How to Extract**:
-1. **Read the ENTIRE user input message** - look at ALL lines, not just the first line
-2. **Search for ANY text containing** \`figma.com/design/\` - this is the URL
-3. **URL may appear in different formats**:
-   - On same line: \`/analyze-figma https://www.figma.com/design/...\`
-   - Split across lines
-4. **Extract the COMPLETE URL**:
-   - Start from \`https://\` or \`http://\`
-   - Include everything until the end of the line or next whitespace
-   - If URL is split, combine ALL parts into one complete URL
-5. **Include ALL query parameters**: \`?node-id=...\`, \`&t=...\`, etc.
-
-**CRITICAL RULES**:
-- \u2705 DO: Read the ENTIRE user message (all lines)
-- \u2705 DO: Look for \`figma.com/design/\` anywhere in the message
-- \u2705 DO: Combine split lines into one URL
-- \u274C DO NOT: Ask user for URL - it's ALWAYS in the input
-- \u274C DO NOT: Skip this step - URL extraction is MANDATORY
-- \u274C DO NOT: Proceed without extracting URL first
+Extract the URL from \`$ARGUMENTS\`:
+- The URL pattern: \`https://www.figma.com/design/...\` or \`http://www.figma.com/design/...\`
+- Extract the ENTIRE URL including all query parameters
+- If URL contains spaces or line breaks, clean and combine them
 
 **Step 2: Check Tool Configuration**
 
@@ -7582,56 +8714,50 @@ Before calling the tool, verify that Figma tool is configured:
 - If not configured, inform user to run: \`aikit skills figma-analysis config\`
 - The tool requires a Figma Personal Access Token
 
-**Step 3: Call MCP Tool read_figma_design**
+**Step 3: Call MCP Tool**
 
-Use the MCP tool \`read_figma_design\` with the extracted URL:
+Use the MCP Figma tool to analyze the design:
 \`\`\`
-Use tool: read_figma_design
-Arguments: { "url": "[extracted URL]" }
+Use MCP tool: mcp__figma__get_figma_data
+Arguments: {
+  "fileKey": "[extracted file key from URL]"
+}
 \`\`\`
 
-**Step 4: Format and Save**
-
-Format extracted tokens as structured markdown and save using memory-update tool.
-
-**Step 5: Report Results**
-
-Report what was extracted:
-- Number of screens found
-- Number of colors in palette
-- Typography styles found
-- Components identified
+**Step 4: Format and Save Results**
 
-## Critical Instructions
+Format extracted tokens as structured markdown with:
+- Colors (from fills and strokes)
+- Typography (font families, sizes, weights, line heights)
+- Spacing system
+- Components
+- Screens/Frames
+- Layout information
 
-- **DO NOT** ask user to "share the Figma URL" - they already provided it in the command
-- **DO NOT** wait for confirmation - just start analyzing immediately
-- **DO** extract URL from full user input message
-- **DO** call MCP tool \`read_figma_design\` immediately
-- **DO** save to memory automatically`;
+**Category**: design`;
 }
 async function installToOpenCode(_opencodePath) {
   const projectPath = process.cwd();
-  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 });
+  const opencodeCommandDir = join17(projectPath, ".opencode", "command");
+  const aikitDir = join17(projectPath, ".aikit");
+  const opencodeAgentDir = join17(paths.opencodeConfig(), "agent");
+  await mkdir12(opencodeCommandDir, { recursive: true });
+  await mkdir12(join17(aikitDir, "skills"), { recursive: true });
+  await mkdir12(opencodeAgentDir, { recursive: true });
   for (const [name, content] of Object.entries(AGENT_FILES)) {
-    const filePath = join16(opencodeAgentDir, `${name}.md`);
+    const filePath = join17(opencodeAgentDir, `${name}.md`);
     try {
-      await access5(filePath);
-      const existingContent = await readFile9(filePath, "utf8");
+      await access6(filePath);
+      const existingContent = await readFile10(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 writeFile11(filePath, updatedContent, "utf8");
+        await writeFile12(filePath, updatedContent, "utf8");
       }
     } catch {
-      await writeFile11(filePath, content, "utf8");
+      await writeFile12(filePath, content, "utf8");
     }
   }
   const config = await loadConfig();
@@ -7693,27 +8819,6 @@ ${cmd.description}
 ## Examples
 ${examples}
 
-## \u26A0\uFE0F CRITICAL: The User Has Already Provided Arguments!
-
-**The user has provided arguments with this command!**
-
-The arguments are available in this command response - look at the command workflow below, which now includes explicit instructions to use the provided arguments.
-
-**YOUR JOB**:
-1. Follow the command workflow steps
-2. The workflow will tell you to look at "Arguments Provided" section
-3. Use those arguments - do NOT ask the user for this information!
-4. They have already provided it - extract and use it!
-
-**Example Scenario**:
-- User runs: \`/${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!
-
-**DO NOT**: Ask "Please provide a task description"
-**DO**: Follow the workflow and use the arguments provided in it!
-
 ## Workflow
 ${cmd.content}
 
@@ -7722,8 +8827,8 @@ ${cmd.content}
   }
   let count = 0;
   for (const [name, content] of Object.entries(opencodeCommands)) {
-    const filePath = join16(opencodeCommandDir, `${name}.md`);
-    await writeFile11(filePath, content.trim());
+    const filePath = join17(opencodeCommandDir, `${name}.md`);
+    await writeFile12(filePath, content.trim());
     logger.info(`  \u2713 Created /${name} command`);
     count++;
   }
@@ -8133,19 +9238,19 @@ init_esm_shims();
 // src/platform/opencode-adapter.ts
 init_esm_shims();
 init_paths();
-import { readFile as readFile10, writeFile as writeFile12, mkdir as mkdir12, access as access6 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile11, writeFile as writeFile13, mkdir as mkdir13, access as access7 } from "fs/promises";
+import { join as join18 } from "path";
 var OpenCodeAdapter = class {
   platform = "opencode" /* OPENCODE */;
   displayName = "OpenCode";
   getCommandsDir() {
-    return join17(process.cwd(), ".opencode", "command");
+    return join18(process.cwd(), ".opencode", "command");
   }
   getSkillsDir() {
-    return join17(process.cwd(), ".opencode", "skill");
+    return join18(process.cwd(), ".opencode", "skill");
   }
   getAgentsDir() {
-    return join17(paths.opencodeConfig(), "agent");
+    return join18(paths.opencodeConfig(), "agent");
   }
   async transformCommand(command) {
     const name = command.name.replace(/:/g, "-");
@@ -8168,39 +9273,41 @@ var OpenCodeAdapter = class {
   }
   async installCommand(name, content) {
     const dir = this.getCommandsDir();
-    await mkdir12(dir, { recursive: true });
-    await writeFile12(join17(dir, `${name}.md`), content);
+    await mkdir13(dir, { recursive: true });
+    await writeFile13(join18(dir, `${name}.md`), content);
   }
   async installSkill(_name, directory, files) {
     const baseDir = this.getSkillsDir();
-    const targetDir = directory ? join17(baseDir, directory) : baseDir;
-    await mkdir12(targetDir, { recursive: true });
+    const targetDir = directory ? join18(baseDir, directory) : baseDir;
+    await mkdir13(targetDir, { recursive: true });
     for (const [filename, content] of Object.entries(files)) {
-      await writeFile12(join17(targetDir, filename), content);
+      await writeFile13(join18(targetDir, filename), content);
     }
   }
   async installAgent(name, content) {
     const dir = this.getAgentsDir();
-    await mkdir12(dir, { recursive: true });
-    const filePath = join17(dir, `${name}.md`);
+    await mkdir13(dir, { recursive: true });
+    const filePath = join18(dir, `${name}.md`);
     try {
-      await access6(filePath);
-      const existingContent = await readFile10(filePath, "utf-8");
+      await access7(filePath);
+      const existingContent = await readFile11(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 writeFile12(filePath, updatedContent, "utf-8");
+        await writeFile13(filePath, updatedContent, "utf-8");
       }
     } catch {
-      await writeFile12(filePath, content, "utf-8");
+      await writeFile13(filePath, content, "utf-8");
     }
   }
   generateCommandContent(command) {
     const examples = command.examples.map((e) => {
       return `- \`${e}\``;
     }).join("\n");
+    let workflow = command.content;
+    workflow = workflow.replace(/\$ARGUMENTS/g, "$ARGUMENTS").replace(/\$1/g, "$1").replace(/\$2/g, "$2").replace(/\$3/g, "$3").replace(/\$4/g, "$4").replace(/\$5/g, "$5");
     return `# Command: /${command.name}
 
 ## Description
@@ -8212,29 +9319,8 @@ ${command.description}
 ## Examples
 ${examples}
 
-## \u26A0\uFE0F CRITICAL: The User Has Already Provided Arguments!
-
-**The user has provided arguments with this command!**
-
-The arguments are available in this command response - look at the command workflow below, which now includes explicit instructions to use the provided arguments.
-
-**YOUR JOB**:
-1. Follow the command workflow steps
-2. The workflow will tell you to look at "Arguments Provided" section
-3. Use those arguments - do NOT ask the user for this information!
-4. They have already provided it - extract and use it!
-
-**Example Scenario**:
-- User runs: \`/${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!
-
-**DO NOT**: Ask "Please provide a task description"
-**DO**: Follow the workflow and use the arguments provided in it!
-
 ## Workflow
-${command.content}
+${workflow}
 
 **Category**: ${command.category}`;
   }
@@ -8269,8 +9355,8 @@ ${agent.systemPrompt}`;
 // src/platform/claude-adapter.ts
 init_esm_shims();
 init_paths();
-import { writeFile as writeFile13, mkdir as mkdir13 } from "fs/promises";
-import { join as join18 } from "path";
+import { writeFile as writeFile14, mkdir as mkdir14 } from "fs/promises";
+import { join as join19 } from "path";
 import matter4 from "gray-matter";
 var ClaudeAdapter = class {
   platform = "claude" /* CLAUDE */;
@@ -8307,28 +9393,27 @@ var ClaudeAdapter = class {
   }
   async installCommand(name, content) {
     const dir = this.getCommandsDir();
-    await mkdir13(dir, { recursive: true });
-    await writeFile13(join18(dir, `${name}.md`), content);
+    await mkdir14(dir, { recursive: true });
+    await writeFile14(join19(dir, `${name}.md`), content);
     this.installedCommands.push(name);
   }
   async installSkill(_name, directory, files) {
     const baseDir = this.getSkillsDir();
-    const targetDir = join18(baseDir, directory);
-    await mkdir13(targetDir, { recursive: true });
+    const targetDir = join19(baseDir, directory);
+    await mkdir14(targetDir, { recursive: true });
     for (const [filename, content] of Object.entries(files)) {
-      await writeFile13(join18(targetDir, filename), content);
+      await writeFile14(join19(targetDir, filename), content);
     }
   }
   async installAgent(name, content) {
     const dir = this.getAgentsDir();
-    await mkdir13(dir, { recursive: true });
-    await writeFile13(join18(dir, `${name}.md`), content);
+    await mkdir14(dir, { recursive: true });
+    await writeFile14(join19(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: \/[a-z_]*[\s-]+\n+/g, "");
-    workflow = workflow.replace(/\$ARGUMENTS/g, "$ARGUMENTS").replace(/\$1/g, "$1").replace(/\$2/g, "$2");
+    workflow = workflow.replace(/\$ARGUMENTS/g, "$ARGUMENTS").replace(/\$1/g, "$1").replace(/\$2/g, "$2").replace(/\$3/g, "$3").replace(/\$4/g, "$4").replace(/\$5/g, "$5");
     const frontmatter = {
       description: command.description,
       argumentHint: command.usage.replace(/^\//, "").replace(/<[^>]+>/g, "[args]")
@@ -8375,7 +9460,7 @@ ${skill.content}
    */
   async generateCommandsManifest() {
     const commandsDir = this.getCommandsDir();
-    const manifestPath = join18(commandsDir, "commands.json");
+    const manifestPath = join19(commandsDir, "commands.json");
     const sortedCommands = [...this.installedCommands].sort();
     const manifest = {
       commands: sortedCommands,
@@ -8384,7 +9469,7 @@ ${skill.content}
       generatedBy: "aikit",
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile13(manifestPath, JSON.stringify(manifest, null, 2));
+    await writeFile14(manifestPath, JSON.stringify(manifest, null, 2));
   }
 };
 
@@ -8399,54 +9484,98 @@ function createAdapter(platform) {
       throw new Error(`Unsupported platform: ${platform}`);
   }
 }
+function platformTypeToCliPlatform(type) {
+  switch (type) {
+    case "opencode":
+      return "opencode" /* OPENCODE */;
+    case "claude":
+      return "claude" /* CLAUDE */;
+  }
+}
+function getEnabledAdapters(config) {
+  const enabledPlatforms = config.getEnabledPlatforms();
+  return enabledPlatforms.map(
+    (platform) => createAdapter(platformTypeToCliPlatform(platform))
+  );
+}
 var SUPPORTED_PLATFORMS = [
-  { platform: "opencode" /* OPENCODE */, name: "OpenCode" },
-  { platform: "claude" /* CLAUDE */, name: "Claude Code CLI" }
+  { platform: "opencode" /* OPENCODE */, name: "OpenCode", configKey: "opencode" },
+  { platform: "claude" /* CLAUDE */, name: "Claude Code CLI", configKey: "claude" }
 ];
 
 // src/cli/commands/init.ts
+function getPlatformConfig(choice) {
+  switch (choice) {
+    case "opencode":
+      return { opencode: true, claude: false, primary: "opencode" };
+    case "claude":
+      return { opencode: false, claude: true, primary: "claude" };
+    case "both":
+      return { opencode: true, claude: true, primary: "opencode" };
+  }
+}
 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) => {
+  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").option("--opencode", "Use OpenCode only").option("--claude", "Use Claude Code only").option("--both", "Use both OpenCode and Claude Code").action(async (platformArg, options) => {
     const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
     console.log(chalk3.bold("\n\u{1F680} AIKit Setup\n"));
     logger.info(`Initializing AIKit in ${configDir}...`);
     try {
-      await initializeConfig(configDir, options.global);
-      logger.success("\u2713 Configuration created");
-      if (!options.global) {
-        let selectedPlatform;
-        if (platformArg) {
-          selectedPlatform = CliDetector.matchPlatform(platformArg);
-        } else {
-          const platforms = await CliDetector.detectPlatforms();
-          const installed = CliDetector.filterInstalledPlatforms(platforms);
-          console.log(chalk3.bold("\n\u{1F50D} Available CLI Tools\n"));
-          for (const p of platforms) {
-            const status = p.installed ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
-            console.log(`  ${status} ${p.displayName}`);
+      let platformChoice;
+      if (options.opencode) {
+        platformChoice = "opencode";
+      } else if (options.claude) {
+        platformChoice = "claude";
+      } else if (options.both) {
+        platformChoice = "both";
+      } else if (platformArg) {
+        const mapped = CliDetector.matchPlatform(platformArg);
+        platformChoice = mapped === "claude" /* CLAUDE */ ? "claude" : "opencode";
+      } else {
+        console.log(chalk3.bold("\n\u{1F4E6} Select Your AI Coding Platform\n"));
+        const { choice } = await inquirer.prompt([
+          {
+            type: "list",
+            name: "choice",
+            message: "Which platform(s) do you want to use?",
+            choices: [
+              {
+                name: `${chalk3.green("\u25CF")} OpenCode ${chalk3.gray("(recommended)")}`,
+                value: "opencode"
+              },
+              {
+                name: `${chalk3.yellow("\u25CF")} Claude Code ${chalk3.yellow("(Beta)")}`,
+                value: "claude"
+              },
+              {
+                name: `${chalk3.cyan("\u25CF")} Both Platforms ${chalk3.gray("(OpenCode + Claude Code)")}`,
+                value: "both"
+              }
+            ],
+            default: "opencode"
           }
-          const { platform } = await inquirer.prompt([
-            {
-              type: "list",
-              name: "platform",
-              message: "Which CLI tool do you want to configure AIKit for?",
-              choices: platforms.map((p) => ({
-                name: p.displayName,
-                value: p.platform
-              })),
-              default: installed[0]?.platform || "opencode" /* OPENCODE */
-            }
-          ]);
-          selectedPlatform = platform;
+        ]);
+        platformChoice = choice;
+        if (platformChoice === "claude" || platformChoice === "both") {
+          console.log(chalk3.yellow("\n\u26A0\uFE0F  Claude Code support is in Beta"));
+          console.log(chalk3.gray("   Some features may be limited or experimental.\n"));
         }
-        logger.info(`Selected platform: ${selectedPlatform}`);
+      }
+      const platformConfig = getPlatformConfig(platformChoice);
+      await initializeConfig(configDir, options.global, platformConfig);
+      logger.success("\u2713 Configuration created");
+      console.log(chalk3.bold("\n\u{1F4CB} Platform Configuration:"));
+      console.log(`   OpenCode:    ${platformConfig.opencode ? chalk3.green("enabled") : chalk3.gray("disabled")}`);
+      console.log(`   Claude Code: ${platformConfig.claude ? chalk3.yellow("enabled (Beta)") : chalk3.gray("disabled")}`);
+      console.log(`   Primary:     ${chalk3.cyan(platformConfig.primary)}
+`);
+      if (!options.global) {
         const config = await loadConfig();
         const engine = new SkillEngine(config);
         const result = await engine.syncSkillsToProject();
         if (result.count > 0) {
           logger.success(`\u2713 Synced ${result.count} skills`);
         }
-        if (selectedPlatform === "claude" /* CLAUDE */) {
+        if (platformConfig.claude) {
           const cliTools = await CliDetector.checkAll();
           const claudeTool = cliTools.find((t) => t.name === "claude" /* CLAUDE */);
           if (claudeTool && !claudeTool.installed) {
@@ -8483,15 +9612,22 @@ function registerInitCommand(program2) {
         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);
+        const enabledAdapters = getEnabledAdapters(config);
+        for (const adapter of enabledAdapters) {
+          logger.info(`Installing AIKit for ${adapter.displayName}...`);
+          await installToPlatform(adapter, config);
+        }
         console.log(chalk3.bold("\n\u2728 AIKit is ready!\n"));
-        if (selectedPlatform === "opencode" /* OPENCODE */) {
+        if (platformConfig.primary === "opencode") {
           showOpenCodeUsage();
-        } else if (selectedPlatform === "claude" /* CLAUDE */) {
+        } else {
           showClaudeUsage();
         }
+        console.log(chalk3.gray("\u2501".repeat(50)));
+        console.log(chalk3.gray("\nSwitch platforms anytime:"));
+        console.log(chalk3.gray("  aikit platform enable claude"));
+        console.log(chalk3.gray("  aikit platform disable opencode"));
+        console.log(chalk3.gray("  aikit platform status\n"));
       }
     } catch (error) {
       logger.error("Failed to initialize AIKit:", error);
@@ -8524,6 +9660,10 @@ async function installToPlatform(adapter, config) {
     await adapter.installAgent(name, content);
     logger.info(`  \u2713 Created ${name} agent`);
   }
+  if (adapter.platform === "claude" /* CLAUDE */ && adapter.generateCommandsManifest) {
+    await adapter.generateCommandsManifest();
+    logger.success("\u2713 Generated commands manifest");
+  }
 }
 function showOpenCodeUsage() {
   console.log("Usage in OpenCode:");
@@ -8537,7 +9677,7 @@ function showOpenCodeUsage() {
   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(chalk3.yellow("Claude Code (Beta) Usage:"));
   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");
@@ -8551,9 +9691,42 @@ init_logger();
 import inquirer2 from "inquirer";
 init_config();
 init_sessions();
+function cliPlatformToType(platform) {
+  switch (platform) {
+    case "opencode" /* OPENCODE */:
+      return "opencode";
+    case "claude" /* CLAUDE */:
+      return "claude";
+    default:
+      return "opencode";
+  }
+}
 function registerInstallCommand(program2) {
-  program2.command("install [platform]").description("Install AIKit to specific CLI tool configuration").action(async (platformArg) => {
+  program2.command("install [platform]").description("Install AIKit to specific CLI tool configuration").option("--all", "Install to all enabled platforms").option("--force", "Force install even if platform is disabled in config").action(async (platformArg, options) => {
     try {
+      const config = await loadConfig();
+      const enabledPlatforms = config.getEnabledPlatforms();
+      logger.info("Platform Configuration:");
+      logger.info(`  Primary: ${config.getPrimaryPlatform()}`);
+      logger.info(`  OpenCode: ${config.isPlatformEnabled("opencode") ? "enabled" : "disabled"}`);
+      logger.info(`  Claude Code: ${config.isPlatformEnabled("claude") ? "enabled (archived)" : "disabled (archived)"}`);
+      logger.info("");
+      if (enabledPlatforms.length === 0) {
+        logger.error("No platforms enabled in config!");
+        logger.info("Enable at least one platform in .aikit/aikit.json:");
+        logger.info('  { "platform": { "opencode": true } }');
+        process.exit(1);
+      }
+      if (options.all) {
+        logger.info(`Installing to all enabled platforms: ${enabledPlatforms.join(", ")}`);
+        const adapters = getEnabledAdapters(config);
+        for (const adapter2 of adapters) {
+          await installToAdapter(adapter2, config);
+        }
+        logger.success(`
+\u2713 AIKit installed to ${enabledPlatforms.length} platform(s)!`);
+        return;
+      }
       let selectedPlatform;
       if (platformArg) {
         selectedPlatform = CliDetector.matchPlatform(platformArg);
@@ -8562,23 +9735,48 @@ function registerInstallCommand(program2) {
           logger.info(`Supported platforms: ${Object.values(CliPlatform).join(", ")}`);
           process.exit(1);
         }
+        const platformType = cliPlatformToType(selectedPlatform);
+        if (!config.isPlatformEnabled(platformType) && !options.force) {
+          logger.warn(`Platform '${platformType}' is disabled in config.`);
+          logger.info("To enable it, update .aikit/aikit.json:");
+          logger.info(`  { "platform": { "${platformType}": true } }`);
+          logger.info("Or use --force to install anyway.");
+          process.exit(1);
+        }
       } else {
         const platforms = await CliDetector.detectPlatforms();
-        const installedPlatforms = CliDetector.filterInstalledPlatforms(platforms);
-        const defaultPlatform = installedPlatforms.length > 0 ? installedPlatforms[0].platform : platforms[0]?.platform;
-        const { platform } = await inquirer2.prompt([
-          {
-            type: "list",
-            name: "platform",
-            message: "Which CLI tool do you want to install AIKit for?",
-            choices: platforms.map((p) => ({
-              name: p.displayName,
-              value: p.platform
-            })),
-            default: defaultPlatform
-          }
-        ]);
-        selectedPlatform = platform;
+        const availablePlatforms = platforms.filter((p) => {
+          const platformInfo = SUPPORTED_PLATFORMS.find((sp) => sp.platform === p.platform);
+          return platformInfo && config.isPlatformEnabled(platformInfo.configKey);
+        });
+        if (availablePlatforms.length === 0) {
+          logger.error("No enabled platforms detected!");
+          logger.info("Enable platforms in .aikit/aikit.json");
+          process.exit(1);
+        }
+        if (availablePlatforms.length === 1) {
+          selectedPlatform = availablePlatforms[0].platform;
+          logger.info(`Using only enabled platform: ${availablePlatforms[0].displayName}`);
+        } else {
+          const primaryPlatform = config.getPrimaryPlatform();
+          const defaultChoice = availablePlatforms.find((p) => {
+            const platformInfo = SUPPORTED_PLATFORMS.find((sp) => sp.platform === p.platform);
+            return platformInfo?.configKey === primaryPlatform;
+          })?.platform || availablePlatforms[0].platform;
+          const { platform } = await inquirer2.prompt([
+            {
+              type: "list",
+              name: "platform",
+              message: "Which CLI tool do you want to install AIKit for?",
+              choices: availablePlatforms.map((p) => ({
+                name: `${p.displayName}${p.installed ? " (installed)" : ""}`,
+                value: p.platform
+              })),
+              default: defaultChoice
+            }
+          ]);
+          selectedPlatform = platform;
+        }
       }
       logger.info(`Installing AIKit for ${selectedPlatform}...`);
       const sessionManager = new SessionManager();
@@ -8586,50 +9784,62 @@ function registerInstallCommand(program2) {
       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;
-      const commandRunner = config.commands.enabled ? new CommandRunner(config) : null;
-      const agentManager = config.agents.enabled ? new AgentManager(config) : null;
-      if (commandRunner) {
-        const commands = await commandRunner.listCommands();
-        logger.info(`Installing ${commands.length} commands...`);
-        for (const command of commands) {
-          const { name, content } = await adapter.transformCommand(command);
-          await adapter.installCommand(name, content);
-          logger.info(`  \u2713 Created ${name} command`);
-        }
-      }
-      if (skillEngine) {
-        const skills = await skillEngine.listSkills();
-        logger.info(`Installing ${skills.length} skills...`);
-        for (const skill of skills) {
-          const { name, directory, files } = await adapter.transformSkill(skill);
-          await adapter.installSkill(name, directory, files);
-          logger.info(`  \u2713 Created ${name} skill`);
-        }
-      }
-      if (agentManager) {
-        const agents = await agentManager.listAgents();
-        logger.info(`Installing ${agents.length} agents...`);
-        for (const agent of agents) {
-          const { name, content } = await adapter.transformAgent(agent);
-          await adapter.installAgent(name, content);
-          logger.info(`  \u2713 Created ${name} agent`);
-        }
-      }
-      if (selectedPlatform === "claude" && adapter.generateCommandsManifest) {
-        await adapter.generateCommandsManifest();
-        logger.success("\u2713 Generated commands manifest");
-      }
+      await installToAdapter(adapter, config);
       logger.success(`
 \u2713 AIKit installed to ${adapter.displayName}!`);
+      const disabledPlatforms = SUPPORTED_PLATFORMS.filter((p) => !config.isPlatformEnabled(p.configKey));
+      if (disabledPlatforms.length > 0) {
+        logger.info("");
+        logger.info("Note: Some platforms are disabled:");
+        disabledPlatforms.forEach((p) => {
+          logger.info(`  - ${p.name}: Enable with { "platform": { "${p.configKey}": true } }`);
+        });
+      }
     } catch (error) {
       logger.error("Failed to install:", error);
       process.exit(1);
     }
   });
 }
+async function installToAdapter(adapter, config) {
+  const skillEngine = config.skills.enabled ? new SkillEngine(config) : null;
+  const commandRunner = config.commands.enabled ? new CommandRunner(config) : null;
+  const agentManager = config.agents.enabled ? new AgentManager(config) : null;
+  logger.info(`
+\u{1F4E6} Installing to ${adapter.displayName}...`);
+  if (commandRunner) {
+    const commands = await commandRunner.listCommands();
+    logger.info(`Installing ${commands.length} commands...`);
+    for (const command of commands) {
+      const { name, content } = await adapter.transformCommand(command);
+      await adapter.installCommand(name, content);
+      logger.info(`  \u2713 Created ${name} command`);
+    }
+  }
+  if (skillEngine) {
+    const skills = await skillEngine.listSkills();
+    logger.info(`Installing ${skills.length} skills...`);
+    for (const skill of skills) {
+      const { name, directory, files } = await adapter.transformSkill(skill);
+      await adapter.installSkill(name, directory, files);
+      logger.info(`  \u2713 Created ${name} skill`);
+    }
+  }
+  if (agentManager) {
+    const agents = await agentManager.listAgents();
+    logger.info(`Installing ${agents.length} agents...`);
+    for (const agent of agents) {
+      const { name, content } = await adapter.transformAgent(agent);
+      await adapter.installAgent(name, content);
+      logger.info(`  \u2713 Created ${name} agent`);
+    }
+  }
+  if (adapter.platform === "claude" && adapter.generateCommandsManifest) {
+    await adapter.generateCommandsManifest();
+    logger.success("\u2713 Generated commands manifest");
+  }
+}
 
 // src/cli/commands/sync.ts
 init_esm_shims();
@@ -8638,8 +9848,8 @@ import chalk5 from "chalk";
 
 // src/core/sync-engine.ts
 init_esm_shims();
-import { readFile as readFile14, writeFile as writeFile17, copyFile, mkdir as mkdir15 } from "fs/promises";
-import { join as join22, dirname as dirname4 } from "path";
+import { readFile as readFile15, writeFile as writeFile18, copyFile, mkdir as mkdir16 } from "fs/promises";
+import { join as join23, dirname as dirname4 } from "path";
 import inquirer3 from "inquirer";
 import chalk4 from "chalk";
 
@@ -8647,8 +9857,8 @@ import chalk4 from "chalk";
 init_esm_shims();
 init_paths();
 init_logger();
-import { readFile as readFile11, readdir as readdir9, writeFile as writeFile14, stat } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile12, readdir as readdir8, writeFile as writeFile15, stat } from "fs/promises";
+import { join as join20 } from "path";
 import { createHash } from "crypto";
 var VersionManager = class {
   config;
@@ -8659,9 +9869,9 @@ var VersionManager = class {
    * Get current installed version
    */
   async getCurrentVersion() {
-    const versionPath = join19(paths.globalConfig(), ".version.json");
+    const versionPath = join20(paths.globalConfig(), ".version.json");
     try {
-      const content = await readFile11(versionPath, "utf-8");
+      const content = await readFile12(versionPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -8672,7 +9882,7 @@ var VersionManager = class {
    */
   getPackageVersion() {
     try {
-      const packageJson = __require(join19(process.cwd(), "package.json"));
+      const packageJson = __require(join20(process.cwd(), "package.json"));
       return packageJson.version || "0.0.0";
     } catch {
       return "0.0.0";
@@ -8730,9 +9940,9 @@ var VersionManager = class {
     const removedSkills = [];
     const conflicts = [];
     const installedSkills = /* @__PURE__ */ new Map();
-    const installedPath = join19(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join20(paths.globalConfig(), ".installed-skills.json");
     try {
-      const installedData = await readFile11(installedPath, "utf-8");
+      const installedData = await readFile12(installedPath, "utf-8");
       const installedList = JSON.parse(installedData);
       installedList.forEach((skill) => {
         installedSkills.set(skill.name, skill);
@@ -8780,9 +9990,9 @@ var VersionManager = class {
     const hashes = [];
     try {
       const loadFromDir = async (dir) => {
-        const files = await readdir9(dir);
+        const files = await readdir8(dir);
         for (const file of files) {
-          const filePath = join19(dir, file);
+          const filePath = join20(dir, file);
           const stats = await stat(filePath);
           if (stats.isDirectory()) {
             await loadFromDir(filePath);
@@ -8808,7 +10018,7 @@ var VersionManager = class {
    */
   async calculateSkillHash(filePath) {
     try {
-      const content = await readFile11(filePath, "utf-8");
+      const content = await readFile12(filePath, "utf-8");
       return createHash("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -8829,9 +10039,9 @@ var VersionManager = class {
    * Save installed skills info
    */
   async saveInstalledSkills(skills) {
-    const installedPath = join19(paths.globalConfig(), ".installed-skills.json");
+    const installedPath = join20(paths.globalConfig(), ".installed-skills.json");
     try {
-      await writeFile14(installedPath, JSON.stringify(skills, null, 2));
+      await writeFile15(installedPath, JSON.stringify(skills, null, 2));
     } catch (error) {
       logger.error("Failed to save installed skills info:", error);
     }
@@ -8852,8 +10062,8 @@ var VersionManager = class {
       packageVersion: this.getPackageVersion(),
       migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
     };
-    const versionPath = join19(paths.globalConfig(), ".version.json");
-    await writeFile14(versionPath, JSON.stringify(updated, null, 2));
+    const versionPath = join20(paths.globalConfig(), ".version.json");
+    await writeFile15(versionPath, JSON.stringify(updated, null, 2));
   }
   /**
    * Check if migration is needed
@@ -8868,8 +10078,8 @@ var VersionManager = class {
 // src/core/backup-manager.ts
 init_esm_shims();
 init_logger();
-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 { readFile as readFile13, writeFile as writeFile16, readdir as readdir9, stat as stat2, unlink as unlink2, mkdir as mkdir15 } from "fs/promises";
+import { join as join21, dirname as dirname3 } from "path";
 import { createHash as createHash2 } from "crypto";
 var BackupManager = class {
   configPath;
@@ -8877,7 +10087,7 @@ var BackupManager = class {
   maxBackups;
   constructor(configPath, maxBackups = 5) {
     this.configPath = configPath;
-    this.backupsDir = join20(configPath, ".backups");
+    this.backupsDir = join21(configPath, ".backups");
     this.maxBackups = maxBackups;
   }
   /**
@@ -8885,10 +10095,10 @@ var BackupManager = class {
    */
   async createBackup(fromVersion, toVersion) {
     try {
-      await mkdir14(this.backupsDir, { recursive: true });
+      await mkdir15(this.backupsDir, { recursive: true });
       const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-      const backupPath = join20(this.backupsDir, `${backupId}-v${toVersion}`);
-      await mkdir14(backupPath, { recursive: true });
+      const backupPath = join21(this.backupsDir, `${backupId}-v${toVersion}`);
+      await mkdir15(backupPath, { recursive: true });
       logger.info(`Creating backup: ${backupPath}`);
       const files = [];
       const backupItems = [
@@ -8909,8 +10119,8 @@ var BackupManager = class {
         files,
         success: true
       };
-      const manifestPath = join20(backupPath, "backup-manifest.json");
-      await writeFile15(manifestPath, JSON.stringify(manifest, null, 2));
+      const manifestPath = join21(backupPath, "backup-manifest.json");
+      await writeFile16(manifestPath, JSON.stringify(manifest, null, 2));
       await this.cleanupOldBackups();
       logger.success(`\u2713 Backup created: ${backupId}`);
       return backupId;
@@ -8923,20 +10133,20 @@ var BackupManager = class {
    * Backup a file or directory
    */
   async backupItem(sourceDir, item, targetDir) {
-    const sourcePath = join20(sourceDir, item);
-    const targetPath = join20(targetDir, item);
+    const sourcePath = join21(sourceDir, item);
+    const targetPath = join21(targetDir, item);
     const files = [];
     try {
       const stats = await stat2(sourcePath);
       if (stats.isDirectory()) {
-        await mkdir14(targetPath, { recursive: true });
-        const entries = await readdir10(sourcePath);
+        await mkdir15(targetPath, { recursive: true });
+        const entries = await readdir9(sourcePath);
         for (const entry of entries) {
           const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
           files.push(...entryFiles);
         }
       } else if (stats.isFile()) {
-        await mkdir14(dirname3(targetPath), { recursive: true });
+        await mkdir15(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
         const hash = await this.calculateHash(targetPath);
         files.push({
@@ -8954,15 +10164,15 @@ var BackupManager = class {
    * Copy file with hash calculation
    */
   async copyFile(source, target) {
-    const content = await readFile12(source);
-    await writeFile15(target, content);
+    const content = await readFile13(source);
+    await writeFile16(target, content);
   }
   /**
    * Calculate file hash
    */
   async calculateHash(filePath) {
     try {
-      const content = await readFile12(filePath);
+      const content = await readFile13(filePath);
       return createHash2("sha256").update(content).digest("hex");
     } catch {
       return "";
@@ -8973,13 +10183,13 @@ var BackupManager = class {
    */
   async listBackups() {
     try {
-      const entries = await readdir10(this.backupsDir);
+      const entries = await readdir9(this.backupsDir);
       const backups = [];
       for (const entry of entries) {
-        const backupPath = join20(this.backupsDir, entry);
-        const manifestPath = join20(backupPath, "backup-manifest.json");
+        const backupPath = join21(this.backupsDir, entry);
+        const manifestPath = join21(backupPath, "backup-manifest.json");
         try {
-          const manifestContent = await readFile12(manifestPath, "utf-8");
+          const manifestContent = await readFile13(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           const size = await this.calculateBackupSize(backupPath);
           backups.push({
@@ -9005,9 +10215,9 @@ var BackupManager = class {
     let totalSize = 0;
     try {
       const calculate = async (dir) => {
-        const entries = await readdir10(dir);
+        const entries = await readdir9(dir);
         for (const entry of entries) {
-          const entryPath = join20(dir, entry);
+          const entryPath = join21(dir, entry);
           const stats = await stat2(entryPath);
           if (stats.isDirectory()) {
             await calculate(entryPath);
@@ -9039,9 +10249,9 @@ var BackupManager = class {
         return false;
       }
       for (const file of backup.manifest.files) {
-        const sourcePath = join20(backup.path, file.path);
-        const targetPath = join20(this.configPath, file.path);
-        await mkdir14(dirname3(targetPath), { recursive: true });
+        const sourcePath = join21(backup.path, file.path);
+        const targetPath = join21(this.configPath, file.path);
+        await mkdir15(dirname3(targetPath), { recursive: true });
         await this.copyFile(sourcePath, targetPath);
       }
       logger.success(`\u2713 Backup restored: ${backupId}`);
@@ -9056,10 +10266,10 @@ var BackupManager = class {
    */
   async validateBackup(backup) {
     try {
-      const manifestPath = join20(backup.path, "backup-manifest.json");
-      await readFile12(manifestPath, "utf-8");
+      const manifestPath = join21(backup.path, "backup-manifest.json");
+      await readFile13(manifestPath, "utf-8");
       for (const file of backup.manifest.files) {
-        const filePath = join20(backup.path, file.path);
+        const filePath = join21(backup.path, file.path);
         await stat2(filePath);
         const currentHash = await this.calculateHash(filePath);
         if (currentHash !== file.hash) {
@@ -9083,9 +10293,9 @@ var BackupManager = class {
       if (!backup) {
         return false;
       }
-      const entries = await readdir10(backup.path);
+      const entries = await readdir9(backup.path);
       for (const entry of entries) {
-        const entryPath = join20(backup.path, entry);
+        const entryPath = join21(backup.path, entry);
         const stats = await stat2(entryPath);
         if (stats.isDirectory()) {
           await this.removeDirectory(entryPath);
@@ -9104,9 +10314,9 @@ var BackupManager = class {
    * Remove directory recursively
    */
   async removeDirectory(dirPath) {
-    const entries = await readdir10(dirPath);
+    const entries = await readdir9(dirPath);
     for (const entry of entries) {
-      const entryPath = join20(dirPath, entry);
+      const entryPath = join21(dirPath, entry);
       const stats = await stat2(entryPath);
       if (stats.isDirectory()) {
         await this.removeDirectory(entryPath);
@@ -9152,14 +10362,14 @@ var BackupManager = class {
 // src/core/migration-manager.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile13, writeFile as writeFile16, readdir as readdir11 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile14, writeFile as writeFile17, readdir as readdir10 } from "fs/promises";
+import { join as join22 } from "path";
 var MigrationManager = class {
   configPath;
   migrationsDir;
   constructor(configPath) {
     this.configPath = configPath;
-    this.migrationsDir = join21(process.cwd(), "src/core/migrations");
+    this.migrationsDir = join22(process.cwd(), "src/core/migrations");
   }
   /**
    * Load all available migrations
@@ -9167,11 +10377,11 @@ var MigrationManager = class {
   async loadMigrations() {
     const migrations = [];
     try {
-      const files = await readdir11(this.migrationsDir);
+      const files = await readdir10(this.migrationsDir);
       for (const file of files) {
         if (file.endsWith(".js") && file.startsWith("migrate-")) {
           try {
-            const module = await import(join21(this.migrationsDir, file));
+            const module = await import(join22(this.migrationsDir, file));
             const migration = module.default || module.migration;
             if (migration) {
               migrations.push(migration);
@@ -9190,9 +10400,9 @@ var MigrationManager = class {
    * Get applied migrations
    */
   async getAppliedMigrations() {
-    const migrationHistoryPath = join21(this.configPath, ".migration-history.json");
+    const migrationHistoryPath = join22(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile13(migrationHistoryPath, "utf-8");
+      const content = await readFile14(migrationHistoryPath, "utf-8");
       const history = JSON.parse(content);
       return history.filter((m) => m.status === "completed").map((m) => m.to);
     } catch {
@@ -9278,16 +10488,16 @@ var MigrationManager = class {
    * Update migration history
    */
   async updateMigrationHistory(entries) {
-    const historyPath = join21(this.configPath, ".migration-history.json");
+    const historyPath = join22(this.configPath, ".migration-history.json");
     try {
       let history = [];
       try {
-        const content = await readFile13(historyPath, "utf-8");
+        const content = await readFile14(historyPath, "utf-8");
         history = JSON.parse(content);
       } catch {
       }
       history.push(...entries);
-      await writeFile16(historyPath, JSON.stringify(history, null, 2));
+      await writeFile17(historyPath, JSON.stringify(history, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history:", error);
     }
@@ -9296,14 +10506,14 @@ var MigrationManager = class {
    * Update migration history status
    */
   async updateMigrationHistoryStatus(version, status) {
-    const historyPath = join21(this.configPath, ".migration-history.json");
+    const historyPath = join22(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile13(historyPath, "utf-8");
+      const content = await readFile14(historyPath, "utf-8");
       const history = JSON.parse(content);
       const updated = history.map(
         (m) => m.to === version ? { ...m, status } : m
       );
-      await writeFile16(historyPath, JSON.stringify(updated, null, 2));
+      await writeFile17(historyPath, JSON.stringify(updated, null, 2));
     } catch (error) {
       logger.error("Failed to update migration history status:", error);
     }
@@ -9312,9 +10522,9 @@ var MigrationManager = class {
    * Get migration history
    */
   async getMigrationHistory() {
-    const historyPath = join21(this.configPath, ".migration-history.json");
+    const historyPath = join22(this.configPath, ".migration-history.json");
     try {
-      const content = await readFile13(historyPath, "utf-8");
+      const content = await readFile14(historyPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return [];
@@ -9623,19 +10833,19 @@ var SyncEngine = class {
    * Install a skill
    */
   async installSkill(sourceDir, skill, targetDir) {
-    const sourcePath = join22(sourceDir, skill.category, `${skill.name}.md`);
-    const targetPath = join22(targetDir, skill.category, `${skill.name}.md`);
-    await mkdir15(dirname4(targetPath), { recursive: true });
+    const sourcePath = join23(sourceDir, skill.category, `${skill.name}.md`);
+    const targetPath = join23(targetDir, skill.category, `${skill.name}.md`);
+    await mkdir16(dirname4(targetPath), { recursive: true });
     await copyFile(sourcePath, targetPath);
   }
   /**
    * Archive a removed skill
    */
   async archiveSkill(targetDir, skill) {
-    const sourcePath = join22(targetDir, skill.category, `${skill.name}.md`);
-    const targetPath = join22(targetDir, skill.category, `${skill.name}-deprecated.md`);
+    const sourcePath = join23(targetDir, skill.category, `${skill.name}.md`);
+    const targetPath = join23(targetDir, skill.category, `${skill.name}-deprecated.md`);
     try {
-      const content = await readFile14(sourcePath, "utf-8");
+      const content = await readFile15(sourcePath, "utf-8");
       const deprecatedNotice = `---
 \u26A0\uFE0F  DEPRECATED: This skill has been removed
 
@@ -9644,8 +10854,8 @@ Reason: Check release notes for replacement
 ---
 
 ${content}`;
-      await mkdir15(dirname4(targetPath), { recursive: true });
-      await writeFile17(targetPath, deprecatedNotice);
+      await mkdir16(dirname4(targetPath), { recursive: true });
+      await writeFile18(targetPath, deprecatedNotice);
     } catch (error) {
       if (error.code === "ENOENT") {
         console.log(chalk4.yellow(`    - ${skill.name} (not found, skipping)`));
@@ -9844,6 +11054,8 @@ async function configureToolAction(toolName) {
         if (isValid) {
           logger.success(`
 \u2705 ${tool.name} configured successfully!`);
+          console.log(chalk6.gray("\nConfiguring Claude Desktop MCP server..."));
+          await toolConfigManager.configureMcpServer(toolName, token);
           console.log(chalk6.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
         } else {
           await toolConfigManager.updateToolConfig(toolName, {
@@ -9876,7 +11088,7 @@ async function configureToolAction(toolName) {
 // src/cli/commands/misc.ts
 init_esm_shims();
 import chalk7 from "chalk";
-import { readFile as readFile16, writeFile as writeFile19 } from "fs/promises";
+import { readFile as readFile16, writeFile as writeFile19, mkdir as mkdir17 } from "fs/promises";
 import { join as join24 } from "path";
 init_config();
 init_memory();
@@ -10018,6 +11230,107 @@ function registerBeadsCommand(program2) {
   });
   return beadsCmd;
 }
+function registerPlatformCommand(program2) {
+  const platformCmd = program2.command("platform").description("Manage platform toggles (OpenCode/Claude Code)");
+  platformCmd.command("status").description("Show platform configuration status").action(async () => {
+    const config = await loadConfig();
+    const { platform } = config;
+    const enabledPlatforms = config.getEnabledPlatforms();
+    console.log(chalk7.bold("\n\u{1F5A5}\uFE0F  Platform Configuration:\n"));
+    console.log(`  Primary: ${chalk7.cyan(platform.primary)}`);
+    console.log();
+    console.log("  Platforms:");
+    console.log(`    ${platform.opencode ? chalk7.green("\u2713") : chalk7.gray("\u25CB")} OpenCode   ${platform.opencode ? chalk7.green("(enabled)") : chalk7.gray("(disabled)")}`);
+    console.log(`    ${platform.claude ? chalk7.green("\u2713") : chalk7.gray("\u25CB")} Claude Code ${platform.claude ? chalk7.green("(enabled)") : chalk7.yellow("(archived)")}`);
+    console.log();
+    if (enabledPlatforms.length === 0) {
+      console.log(chalk7.yellow('\u26A0 No platforms enabled! Run "aikit platform enable opencode" to enable.'));
+    } else {
+      console.log(chalk7.gray(`Enabled: ${enabledPlatforms.join(", ")}`));
+    }
+    console.log();
+    console.log(chalk7.gray("Commands:"));
+    console.log(chalk7.gray("  aikit platform enable <platform>   Enable a platform"));
+    console.log(chalk7.gray("  aikit platform disable <platform>  Disable a platform"));
+    console.log(chalk7.gray("  aikit platform primary <platform>  Set primary platform"));
+    console.log();
+  });
+  platformCmd.command("enable <platform>").description("Enable a platform (opencode, claude)").action(async (platform) => {
+    await togglePlatform(platform, true);
+  });
+  platformCmd.command("disable <platform>").description("Disable a platform (opencode, claude)").action(async (platform) => {
+    await togglePlatform(platform, false);
+  });
+  platformCmd.command("primary <platform>").description("Set primary platform (opencode, claude)").action(async (platform) => {
+    const validPlatforms = ["opencode", "claude"];
+    if (!validPlatforms.includes(platform)) {
+      console.log(chalk7.red(`Invalid platform. Available: ${validPlatforms.join(", ")}`));
+      return;
+    }
+    const config = await loadConfig();
+    const configPath = config.configPath;
+    try {
+      let configData = {};
+      try {
+        configData = JSON.parse(await readFile16(join24(configPath, "aikit.json"), "utf-8"));
+      } catch {
+      }
+      if (!configData.platform) {
+        configData.platform = {};
+      }
+      configData.platform.primary = platform;
+      configData.platform[platform] = true;
+      await mkdir17(configPath, { recursive: true });
+      await writeFile19(join24(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
+      console.log(chalk7.green(`\u2713 Primary platform set to: ${platform}`));
+      console.log(chalk7.gray(`Configuration updated at: ${configPath}/aikit.json`));
+      console.log();
+      console.log(chalk7.gray('Run "aikit install" to apply changes.'));
+    } catch (error) {
+      console.log(chalk7.red(`Failed to set primary platform: ${error instanceof Error ? error.message : String(error)}`));
+    }
+  });
+  return platformCmd;
+}
+async function togglePlatform(platform, enable) {
+  const validPlatforms = ["opencode", "claude"];
+  if (!validPlatforms.includes(platform)) {
+    console.log(chalk7.red(`Invalid platform. Available: ${validPlatforms.join(", ")}`));
+    return;
+  }
+  const config = await loadConfig();
+  const configPath = config.configPath;
+  try {
+    let configData = {};
+    try {
+      configData = JSON.parse(await readFile16(join24(configPath, "aikit.json"), "utf-8"));
+    } catch {
+    }
+    if (!configData.platform) {
+      configData.platform = {
+        primary: "opencode",
+        opencode: true,
+        claude: false
+      };
+    }
+    configData.platform[platform] = enable;
+    await mkdir17(configPath, { recursive: true });
+    await writeFile19(join24(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
+    const action = enable ? "enabled" : "disabled";
+    const emoji = enable ? "\u2713" : "\u25CB";
+    console.log(chalk7.green(`${emoji} Platform ${platform} ${action}`));
+    console.log(chalk7.gray(`Configuration updated at: ${configPath}/aikit.json`));
+    console.log();
+    if (enable) {
+      console.log(chalk7.gray('Run "aikit install" to install AIKit for this platform.'));
+    } else {
+      console.log(chalk7.gray(`Note: Existing ${platform} files will remain but won't be updated.`));
+      console.log(chalk7.gray(`Use "aikit platform enable ${platform}" to re-enable later.`));
+    }
+  } catch (error) {
+    console.log(chalk7.red(`Failed to ${enable ? "enable" : "disable"} platform: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
 function registerStatusCommand(program2) {
   program2.command("status").description("Show AIKit status").action(async () => {
     console.log(chalk7.bold(`
@@ -10026,6 +11339,9 @@ function registerStatusCommand(program2) {
     try {
       const config = await loadConfig();
       console.log(chalk7.green("\u2713 Configuration loaded"));
+      const enabledPlatforms = config.getEnabledPlatforms();
+      console.log(`  Primary Platform: ${chalk7.cyan(config.getPrimaryPlatform())}`);
+      console.log(`  Enabled Platforms: ${enabledPlatforms.length > 0 ? enabledPlatforms.join(", ") : chalk7.yellow("none")}`);
       const skillEngine = new SkillEngine(config);
       const skills = await skillEngine.listSkills();
       console.log(`  Skills: ${skills.length}`);
@@ -10092,6 +11408,7 @@ registerSkillsCommand(program);
 registerAgentsCommand(program);
 registerCommandsCommand(program);
 registerModeCommand(program);
+registerPlatformCommand(program);
 registerToolsCommand(program);
 registerPluginsCommand(program);
 registerMemoryCommand(program);