@tdsoft-tech/aikit 0.1.9 → 0.1.12

package/dist/cli.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -735,8 +741,8 @@ var init_memory = __esm({
         for (const subDir of subDirs) {
           const dirPath = join8(memoryPath, subDir);
           try {
-            const { readdir: readdir7 } = await import("fs/promises");
-            const files = await readdir7(dirPath);
+            const { readdir: readdir10 } = await import("fs/promises");
+            const files = await readdir10(dirPath);
             for (const file of files) {
               if (!file.endsWith(".md")) continue;
               const content = await readFile5(join8(dirPath, file), "utf-8");
@@ -797,8 +803,8 @@ var init_memory = __esm({
           const subDir = type === "observation" ? "observations" : type === "handoff" ? "handoffs" : type === "research" ? "research" : "";
           filePath = join8(memoryPath, subDir, `${key}.md`);
         }
-        const { dirname: dirname2 } = await import("path");
-        await mkdir4(dirname2(filePath), { recursive: true });
+        const { dirname: dirname4 } = await import("path");
+        await mkdir4(dirname4(filePath), { recursive: true });
         if (options?.append) {
           try {
             const existing = await readFile5(filePath, "utf-8");
@@ -928,8 +934,8 @@ var tool_config_exports = {};
 __export(tool_config_exports, {
   ToolConfigManager: () => ToolConfigManager
 });
-import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8, access as access4, constants as constants4 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile11, writeFile as writeFile12, mkdir as mkdir10, access as access4, constants as constants4 } from "fs/promises";
+import { join as join17 } from "path";
 import { z as z3 } from "zod";
 var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
 var init_tool_config = __esm({
@@ -957,7 +963,7 @@ var init_tool_config = __esm({
       toolsConfigPath;
       constructor(config) {
         this.config = config;
-        this.toolsConfigPath = join13(this.config.configPath, "config", "tools.json");
+        this.toolsConfigPath = join17(this.config.configPath, "config", "tools.json");
       }
       /**
        * Get all registered tools with their current status
@@ -1041,7 +1047,7 @@ var init_tool_config = __esm({
       async loadConfigs() {
         try {
           await access4(this.toolsConfigPath, constants4.R_OK);
-          const content = await readFile7(this.toolsConfigPath, "utf-8");
+          const content = await readFile11(this.toolsConfigPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -1051,9 +1057,9 @@ var init_tool_config = __esm({
        * Save configurations
        */
       async saveConfigs(configs) {
-        const configDir = join13(this.config.configPath, "config");
-        await mkdir8(configDir, { recursive: true });
-        await writeFile8(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+        const configDir = join17(this.config.configPath, "config");
+        await mkdir10(configDir, { recursive: true });
+        await writeFile12(this.toolsConfigPath, JSON.stringify(configs, null, 2));
       }
     };
   }
@@ -1100,8 +1106,8 @@ var init_figma_oauth = __esm({
         console.log('3. Give it a name (e.g., "AIKit")');
         console.log("4. Copy the token (you won't see it again!)");
         console.log("5. Paste it here when prompted\n");
-        const { default: inquirer2 } = await import("inquirer");
-        const { token } = await inquirer2.prompt([
+        const { default: inquirer3 } = await import("inquirer");
+        const { token } = await inquirer3.prompt([
           {
             type: "password",
             name: "token",
@@ -1131,14 +1137,14 @@ var init_figma_oauth = __esm({
        * Alternative: Manual token input
        */
       async authenticateManual() {
-        const { default: inquirer2 } = await import("inquirer");
+        const { default: inquirer3 } = await import("inquirer");
         console.log("\n\u{1F510} Figma Authentication (Manual)\n");
         console.log("To get your Figma Personal Access Token:");
         console.log("1. Visit: https://www.figma.com/developers/api#access-tokens");
         console.log('2. Scroll to "Personal access tokens"');
         console.log('3. Click "Create new token"');
         console.log("4. Copy the token and paste it below\n");
-        const { token } = await inquirer2.prompt([
+        const { token } = await inquirer3.prompt([
           {
             type: "password",
             name: "token",
@@ -1191,8 +1197,8 @@ var init_figma_oauth = __esm({
 // src/cli.ts
 init_esm_shims();
 import { Command } from "commander";
-import chalk2 from "chalk";
-import inquirer from "inquirer";
+import chalk3 from "chalk";
+import inquirer2 from "inquirer";
 
 // src/index.ts
 init_esm_shims();
@@ -1765,6 +1771,51 @@ For diagrams:
 - Map to code structure
 - Note data flow`,
     delegatesTo: []
+  },
+  {
+    name: "one-shot",
+    displayName: "@one-shot",
+    description: "End-to-end autonomous task execution (beta)",
+    useWhen: "Complete tasks autonomously from start to finish with minimal intervention",
+    capabilities: [
+      "Gather requirements interactively",
+      "Create detailed implementation plans",
+      "Execute tasks with dynamic agent selection",
+      "Run quality gates until all pass",
+      "Multi-level verification",
+      "Auto-recovery from failures",
+      "Generate completion proof"
+    ],
+    systemPrompt: `You are the one-shot agent. Your role is to execute tasks autonomously from start to finish.
+
+## Workflow Phases
+
+1. **REQUIREMENTS**: Gather task type, scope, dependencies, success criteria
+2. **PLANNING**: Create detailed plan with @planner, recommend skills/tools
+3. **COMPLEXITY**: Auto-split large tasks (>30min, >10 files, >500 lines)
+4. **EXECUTION**: Execute with parallel tasks, dynamic agent delegation
+5. **TESTING**: Run quality gates (typecheck, test, lint, build) until all pass
+6. **VERIFICATION**: Multi-level verification (gates + manual + deployment)
+7. **COMPLETION**: Generate proof, update tracking, collect feedback
+
+## Quality Gates (Must ALL Pass)
+- npm run typecheck - No type errors
+- npm run test - All tests pass
+- npm run lint - No linting errors
+- npm run build - Build succeeds
+
+## Error Recovery (3 Levels)
+- Level 1: Auto-fix (type errors, lint --fix)
+- Level 2: Alternative approach via @review
+- Level 3: User intervention + follow-up task creation
+
+## Best Practices
+- Use for straightforward tasks first
+- Consider /plan + /implement for complex features
+- Review changes before final approval
+
+\u26A0\uFE0F This mode is experimental. Start with simpler tasks.`,
+    delegatesTo: ["planner", "build", "review", "scout", "explore", "vision"]
   }
 ];
 var AgentManager = class {
@@ -2037,6 +2088,95 @@ Before marking complete:
 2. Display summary to user
 3. Propose next actions
 4. Continue from where left off`
+  },
+  {
+    name: "one-shot",
+    description: "End-to-end autonomous task execution (beta)",
+    category: "core",
+    usage: "/one-shot <task description>",
+    examples: ["/one-shot Add user authentication", "/one-shot Fix navigation bug"],
+    content: `One-Shot Mode (beta) - End-to-end autonomous task execution.
+
+\u26A0\uFE0F  This mode is experimental. Use for straightforward tasks first.
+
+## Workflow
+
+**Phase 1: Requirements Gathering**
+- Interactive selection of task type (Feature, Bug Fix, Refactoring, etc.)
+- Scope clarification
+- Dependencies identification
+- Success criteria definition
+- User selects progress level (Minimal/Moderate/Detailed/Quiet)
+
+**Phase 2: Planning**
+- Delegate to @planner agent
+- Create detailed implementation plan
+- Recommend relevant skills and tools
+- Create Beads task for tracking
+
+**Phase 3: Complexity Check & Auto-Split**
+- Analyze task complexity
+- Split into multiple beads if needed:
+  * Time > 30 minutes
+  * >10 files affected
+  * >500 lines to change
+  * Touches >2 sub-systems
+
+**Phase 4: Execution**
+- Build dependency graph
+- Execute tasks in parallel (max 3 concurrent)
+- Dynamic agent selection (@build \u2192 @review \u2192 @scout \u2192 ...)
+- Integrate skills (TDD, debugging, etc.)
+- Smart terminal access (auto-allow/ask/forbid)
+
+**Phase 5: Enhanced Testing & Validation**
+- Auto-generate test scripts for new functionality
+- Run quality gates: typecheck, test, lint, build
+- Execute sample commands (with user approval)
+- Validate logs semantically with historical comparison
+- Retry loop (max 3 attempts) with:
+  * Auto-fix type errors, lint errors
+  * Alternative approaches from @review
+  * User intervention on final failure
+
+**Phase 6: Multi-Level Verification**
+- All quality gates passed \u2713
+- Manual verification confirmation
+- Deployment approval (if needed)
+- Rollback confirmation (if verification fails)
+
+**Phase 7: Completion**
+- Generate proof of completion
+  * Files changed
+  * Test results
+  * Build output
+  * Deployment status
+- Update Beads task \u2192 completed
+- Store proof in bead notes
+- Collect beta feedback
+
+## Quality Gates (Must ALL Pass)
+- \`npm run typecheck\` - No type errors
+- \`npm run test\` - All tests pass
+- \`npm run lint\` - No linting errors
+- \`npm run build\` - Build succeeds
+
+## Success Criteria
+- All tests passing
+- No regressions
+- Manual verification
+- Deployment complete (if applicable)
+- Beads task completed with proof
+
+## Error Handling
+- **Level 1**: Auto-fix (type errors, lint --fix)
+- **Level 2**: Alternative approach (@review delegation)
+- **Level 3**: User intervention + follow-up bead creation
+
+## Tips
+\u2713 Use for straightforward tasks first
+\u2713 Consider /plan + /implement for complex features
+\u2713 Review changes before final approval`
   },
   // Quick Actions
   {
@@ -4221,11 +4361,1058 @@ var CliDetector = class {
 // src/cli.ts
 init_logger();
 init_paths();
+
+// src/core/sync-engine.ts
+init_esm_shims();
+import { readFile as readFile10, writeFile as writeFile11, copyFile, mkdir as mkdir9 } from "fs/promises";
+import { join as join16, dirname as dirname3 } from "path";
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+
+// src/core/version-manager.ts
+init_esm_shims();
+init_paths();
+init_logger();
+import { readFile as readFile7, readdir as readdir7, writeFile as writeFile8, stat } from "fs/promises";
+import { join as join13 } from "path";
+import { createHash } from "crypto";
+var VersionManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get current installed version
+   */
+  async getCurrentVersion() {
+    const versionPath = join13(paths.globalConfig(), ".version.json");
+    try {
+      const content = await readFile7(versionPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get package version from package.json
+   */
+  getPackageVersion() {
+    try {
+      const packageJson = __require(join13(process.cwd(), "package.json"));
+      return packageJson.version || "0.0.0";
+    } catch {
+      return "0.0.0";
+    }
+  }
+  /**
+   * Check for updates
+   */
+  async checkForUpdates() {
+    const installed = await this.getCurrentVersion();
+    const packageVersion = this.getPackageVersion();
+    if (!installed) {
+      return {
+        hasUpdate: true,
+        fromVersion: "none",
+        toVersion: packageVersion,
+        newSkills: [],
+        modifiedSkills: [],
+        removedSkills: [],
+        conflicts: [],
+        configChanges: ["Initial version tracking"]
+      };
+    }
+    const hasUpdate = installed.installedVersion !== packageVersion;
+    if (!hasUpdate) {
+      return {
+        hasUpdate: false,
+        fromVersion: installed.installedVersion,
+        toVersion: packageVersion,
+        newSkills: [],
+        modifiedSkills: [],
+        removedSkills: [],
+        conflicts: [],
+        configChanges: []
+      };
+    }
+    const changes = await this.detectChanges();
+    return {
+      hasUpdate: true,
+      fromVersion: installed.installedVersion,
+      toVersion: packageVersion,
+      ...changes
+    };
+  }
+  /**
+   * Detect changes between versions
+   */
+  async detectChanges() {
+    const globalSkillsPath = paths.skills(paths.globalConfig());
+    const projectSkillsPath = paths.skills(this.config.configPath);
+    const sourceSkills = await this.loadSkillHashes(globalSkillsPath);
+    const userSkills = await this.loadSkillHashes(projectSkillsPath);
+    const newSkills = [];
+    const modifiedSkills = [];
+    const removedSkills = [];
+    const conflicts = [];
+    const installedSkills = /* @__PURE__ */ new Map();
+    const installedPath = join13(paths.globalConfig(), ".installed-skills.json");
+    try {
+      const installedData = await readFile7(installedPath, "utf-8");
+      const installedList = JSON.parse(installedData);
+      installedList.forEach((skill) => {
+        installedSkills.set(skill.name, skill);
+      });
+    } catch {
+    }
+    for (const sourceSkill of sourceSkills) {
+      const installed = installedSkills.get(sourceSkill.name);
+      const user = userSkills.find((s) => s.name === sourceSkill.name);
+      if (!installed) {
+        newSkills.push(sourceSkill);
+      } else if (installed.hash !== sourceSkill.hash) {
+        modifiedSkills.push(sourceSkill);
+        if (user && user.hash !== installed.hash) {
+          conflicts.push({
+            skillName: sourceSkill.name,
+            userHash: user.hash,
+            sourceHash: sourceSkill.hash,
+            installedHash: installed.hash,
+            userModified: user.hash !== installed.hash,
+            sourceModified: sourceSkill.hash !== installed.hash
+          });
+        }
+      }
+    }
+    for (const [name, installedSkill] of installedSkills.entries()) {
+      const existsInSource = sourceSkills.find((s) => s.name === name);
+      if (!existsInSource) {
+        removedSkills.push(installedSkill);
+      }
+    }
+    return {
+      newSkills,
+      modifiedSkills,
+      removedSkills,
+      conflicts,
+      configChanges: []
+      // Will be detected separately
+    };
+  }
+  /**
+   * Load skill hashes from directory
+   */
+  async loadSkillHashes(skillsPath) {
+    const hashes = [];
+    try {
+      const loadFromDir = async (dir) => {
+        const files = await readdir7(dir);
+        for (const file of files) {
+          const filePath = join13(dir, file);
+          const stats = await stat(filePath);
+          if (stats.isDirectory()) {
+            await loadFromDir(filePath);
+          } else if (file.endsWith(".md")) {
+            const hash = await this.calculateSkillHash(filePath);
+            hashes.push({
+              path: filePath,
+              name: file.replace(".md", ""),
+              hash,
+              category: this.extractCategory(dir, skillsPath)
+            });
+          }
+        }
+      };
+      await loadFromDir(skillsPath);
+    } catch (error) {
+      logger.debug(`Could not load skills from ${skillsPath}:`, error);
+    }
+    return hashes;
+  }
+  /**
+   * Calculate hash for a skill file
+   */
+  async calculateSkillHash(filePath) {
+    try {
+      const content = await readFile7(filePath, "utf-8");
+      return createHash("sha256").update(content).digest("hex");
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Extract category from path
+   */
+  extractCategory(filePath, basePath) {
+    const relative = filePath.replace(basePath + "/", "");
+    const parts = relative.split("/");
+    if (parts.length > 1) {
+      return parts[0];
+    }
+    return "uncategorized";
+  }
+  /**
+   * Save installed skills info
+   */
+  async saveInstalledSkills(skills) {
+    const installedPath = join13(paths.globalConfig(), ".installed-skills.json");
+    try {
+      await writeFile8(installedPath, JSON.stringify(skills, null, 2));
+    } catch (error) {
+      logger.error("Failed to save installed skills info:", error);
+    }
+  }
+  /**
+   * Update version file
+   */
+  async updateVersion(version, migration) {
+    const current = await this.getCurrentVersion() || {
+      installedVersion: "0.0.0",
+      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+      packageVersion: "0.0.0",
+      migrationHistory: []
+    };
+    const updated = {
+      installedVersion: version,
+      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+      packageVersion: this.getPackageVersion(),
+      migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
+    };
+    const versionPath = join13(paths.globalConfig(), ".version.json");
+    await writeFile8(versionPath, JSON.stringify(updated, null, 2));
+  }
+  /**
+   * Check if migration is needed
+   */
+  async needsMigration() {
+    const current = await this.getCurrentVersion();
+    const packageVersion = this.getPackageVersion();
+    return current?.installedVersion !== packageVersion;
+  }
+};
+
+// src/core/backup-manager.ts
+init_esm_shims();
+init_logger();
+import { readFile as readFile8, writeFile as writeFile9, readdir as readdir8, stat as stat2, unlink, mkdir as mkdir8 } from "fs/promises";
+import { join as join14, dirname as dirname2 } from "path";
+import { createHash as createHash2 } from "crypto";
+var BackupManager = class {
+  configPath;
+  backupsDir;
+  maxBackups;
+  constructor(configPath, maxBackups = 5) {
+    this.configPath = configPath;
+    this.backupsDir = join14(configPath, ".backups");
+    this.maxBackups = maxBackups;
+  }
+  /**
+   * Create backup before update
+   */
+  async createBackup(fromVersion, toVersion) {
+    try {
+      await mkdir8(this.backupsDir, { recursive: true });
+      const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      const backupPath = join14(this.backupsDir, `${backupId}-v${toVersion}`);
+      await mkdir8(backupPath, { recursive: true });
+      logger.info(`Creating backup: ${backupPath}`);
+      const files = [];
+      const backupItems = [
+        "skills/",
+        "aikit.json",
+        "AGENTS.md",
+        "config/"
+      ];
+      for (const item of backupItems) {
+        const files2 = await this.backupItem(this.configPath, item, backupPath);
+        files2.push(...files2);
+      }
+      const manifest = {
+        backupId,
+        fromVersion,
+        toVersion,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        files,
+        success: true
+      };
+      const manifestPath = join14(backupPath, "backup-manifest.json");
+      await writeFile9(manifestPath, JSON.stringify(manifest, null, 2));
+      await this.cleanupOldBackups();
+      logger.success(`\u2713 Backup created: ${backupId}`);
+      return backupId;
+    } catch (error) {
+      logger.error("Failed to create backup:", error);
+      return null;
+    }
+  }
+  /**
+   * Backup a file or directory
+   */
+  async backupItem(sourceDir, item, targetDir) {
+    const sourcePath = join14(sourceDir, item);
+    const targetPath = join14(targetDir, item);
+    const files = [];
+    try {
+      const stats = await stat2(sourcePath);
+      if (stats.isDirectory()) {
+        await mkdir8(targetPath, { recursive: true });
+        const entries = await readdir8(sourcePath);
+        for (const entry of entries) {
+          const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
+          files.push(...entryFiles);
+        }
+      } else if (stats.isFile()) {
+        await mkdir8(dirname2(targetPath), { recursive: true });
+        await this.copyFile(sourcePath, targetPath);
+        const hash = await this.calculateHash(targetPath);
+        files.push({
+          path: item,
+          hash,
+          size: stats.size
+        });
+      }
+    } catch (error) {
+      logger.debug(`Could not backup ${item}:`, error);
+    }
+    return files;
+  }
+  /**
+   * Copy file with hash calculation
+   */
+  async copyFile(source, target) {
+    const content = await readFile8(source);
+    await writeFile9(target, content);
+  }
+  /**
+   * Calculate file hash
+   */
+  async calculateHash(filePath) {
+    try {
+      const content = await readFile8(filePath);
+      return createHash2("sha256").update(content).digest("hex");
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * List available backups
+   */
+  async listBackups() {
+    try {
+      const entries = await readdir8(this.backupsDir);
+      const backups = [];
+      for (const entry of entries) {
+        const backupPath = join14(this.backupsDir, entry);
+        const manifestPath = join14(backupPath, "backup-manifest.json");
+        try {
+          const manifestContent = await readFile8(manifestPath, "utf-8");
+          const manifest = JSON.parse(manifestContent);
+          const size = await this.calculateBackupSize(backupPath);
+          backups.push({
+            manifest,
+            path: backupPath,
+            size
+          });
+        } catch {
+        }
+      }
+      backups.sort(
+        (a, b) => new Date(b.manifest.timestamp).getTime() - new Date(a.manifest.timestamp).getTime()
+      );
+      return backups;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Calculate backup directory size
+   */
+  async calculateBackupSize(backupPath) {
+    let totalSize = 0;
+    try {
+      const calculate = async (dir) => {
+        const entries = await readdir8(dir);
+        for (const entry of entries) {
+          const entryPath = join14(dir, entry);
+          const stats = await stat2(entryPath);
+          if (stats.isDirectory()) {
+            await calculate(entryPath);
+          } else {
+            totalSize += stats.size;
+          }
+        }
+      };
+      await calculate(backupPath);
+    } catch {
+    }
+    return totalSize;
+  }
+  /**
+   * Restore from backup
+   */
+  async restoreBackup(backupId) {
+    try {
+      const backups = await this.listBackups();
+      const backup = backups.find((b) => b.manifest.backupId === backupId);
+      if (!backup) {
+        logger.error(`Backup not found: ${backupId}`);
+        return false;
+      }
+      logger.info(`Restoring from backup: ${backupId}`);
+      const isValid = await this.validateBackup(backup);
+      if (!isValid) {
+        logger.error("Backup validation failed");
+        return false;
+      }
+      for (const file of backup.manifest.files) {
+        const sourcePath = join14(backup.path, file.path);
+        const targetPath = join14(this.configPath, file.path);
+        await mkdir8(dirname2(targetPath), { recursive: true });
+        await this.copyFile(sourcePath, targetPath);
+      }
+      logger.success(`\u2713 Backup restored: ${backupId}`);
+      return true;
+    } catch (error) {
+      logger.error("Failed to restore backup:", error);
+      return false;
+    }
+  }
+  /**
+   * Validate backup integrity
+   */
+  async validateBackup(backup) {
+    try {
+      const manifestPath = join14(backup.path, "backup-manifest.json");
+      await readFile8(manifestPath, "utf-8");
+      for (const file of backup.manifest.files) {
+        const filePath = join14(backup.path, file.path);
+        await stat2(filePath);
+        const currentHash = await this.calculateHash(filePath);
+        if (currentHash !== file.hash) {
+          logger.warn(`File hash mismatch: ${file.path}`);
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      logger.debug("Backup validation failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Delete backup
+   */
+  async deleteBackup(backupId) {
+    try {
+      const backups = await this.listBackups();
+      const backup = backups.find((b) => b.manifest.backupId === backupId);
+      if (!backup) {
+        return false;
+      }
+      const entries = await readdir8(backup.path);
+      for (const entry of entries) {
+        const entryPath = join14(backup.path, entry);
+        const stats = await stat2(entryPath);
+        if (stats.isDirectory()) {
+          await this.removeDirectory(entryPath);
+        } else {
+          await unlink(entryPath);
+        }
+      }
+      logger.success(`\u2713 Backup deleted: ${backupId}`);
+      return true;
+    } catch (error) {
+      logger.error("Failed to delete backup:", error);
+      return false;
+    }
+  }
+  /**
+   * Remove directory recursively
+   */
+  async removeDirectory(dirPath) {
+    const entries = await readdir8(dirPath);
+    for (const entry of entries) {
+      const entryPath = join14(dirPath, entry);
+      const stats = await stat2(entryPath);
+      if (stats.isDirectory()) {
+        await this.removeDirectory(entryPath);
+      } else {
+        await unlink(entryPath);
+      }
+    }
+    await unlink(dirPath);
+  }
+  /**
+   * Cleanup old backups (keep only maxBackups)
+   */
+  async cleanupOldBackups() {
+    try {
+      const backups = await this.listBackups();
+      if (backups.length <= this.maxBackups) {
+        return;
+      }
+      const toDelete = backups.slice(this.maxBackups);
+      for (const backup of toDelete) {
+        await this.deleteBackup(backup.manifest.backupId);
+      }
+      logger.info(`Cleaned up ${toDelete.length} old backup(s)`);
+    } catch (error) {
+      logger.error("Failed to cleanup old backups:", error);
+    }
+  }
+  /**
+   * Format backup size for display
+   */
+  formatSize(bytes) {
+    const units = ["B", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+  }
+};
+
+// src/core/migration-manager.ts
+init_esm_shims();
+init_logger();
+import { readFile as readFile9, writeFile as writeFile10, readdir as readdir9 } from "fs/promises";
+import { join as join15 } from "path";
+var MigrationManager = class {
+  configPath;
+  migrationsDir;
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.migrationsDir = join15(process.cwd(), "src/core/migrations");
+  }
+  /**
+   * Load all available migrations
+   */
+  async loadMigrations() {
+    const migrations = [];
+    try {
+      const files = await readdir9(this.migrationsDir);
+      for (const file of files) {
+        if (file.endsWith(".js") && file.startsWith("migrate-")) {
+          try {
+            const module = await import(join15(this.migrationsDir, file));
+            const migration = module.default || module.migration;
+            if (migration) {
+              migrations.push(migration);
+            }
+          } catch (error) {
+            logger.warn(`Failed to load migration ${file}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug("Could not load migrations:", error);
+    }
+    return migrations.sort((a, b) => a.version.localeCompare(b.version));
+  }
+  /**
+   * Get applied migrations
+   */
+  async getAppliedMigrations() {
+    const migrationHistoryPath = join15(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile9(migrationHistoryPath, "utf-8");
+      const history = JSON.parse(content);
+      return history.filter((m) => m.status === "completed").map((m) => m.to);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Run pending migrations
+   */
+  async runPendingMigrations() {
+    const appliedMigrations = await this.getAppliedMigrations();
+    const allMigrations = await this.loadMigrations();
+    const pendingMigrations = allMigrations.filter(
+      (m) => !appliedMigrations.includes(m.version)
+    );
+    if (pendingMigrations.length === 0) {
+      logger.info("No pending migrations");
+      return { success: true, applied: [], failed: [] };
+    }
+    logger.info(`Running ${pendingMigrations.length} pending migration(s)...`);
+    const applied = [];
+    const failed = [];
+    const migrationHistory = [];
+    for (const migration of pendingMigrations) {
+      try {
+        logger.info(`Running migration: ${migration.version}`);
+        logger.info(`  ${migration.description}`);
+        await migration.up();
+        applied.push(migration.version);
+        migrationHistory.push({
+          from: "previous",
+          to: migration.version,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "completed"
+        });
+        logger.success(`\u2713 Migration completed: ${migration.version}`);
+      } catch (error) {
+        logger.error(`\u2717 Migration failed: ${migration.version}`, error);
+        failed.push(migration.version);
+        migrationHistory.push({
+          from: "previous",
+          to: migration.version,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "failed"
+        });
+        break;
+      }
+    }
+    await this.updateMigrationHistory(migrationHistory);
+    return {
+      success: failed.length === 0,
+      applied,
+      failed
+    };
+  }
+  /**
+   * Rollback migration
+   */
+  async rollbackMigration(version) {
+    try {
+      const applied = await this.getAppliedMigrations();
+      if (!applied.includes(version)) {
+        logger.error(`Migration not found in applied list: ${version}`);
+        return false;
+      }
+      const allMigrations = await this.loadMigrations();
+      const migration = allMigrations.find((m) => m.version === version);
+      if (!migration) {
+        logger.error(`Migration file not found: ${version}`);
+        return false;
+      }
+      logger.info(`Rolling back migration: ${version}`);
+      await migration.down();
+      await this.updateMigrationHistoryStatus(version, "rolled-back");
+      logger.success(`\u2713 Migration rolled back: ${version}`);
+      return true;
+    } catch (error) {
+      logger.error("Failed to rollback migration:", error);
+      return false;
+    }
+  }
+  /**
+   * Update migration history
+   */
+  async updateMigrationHistory(entries) {
+    const historyPath = join15(this.configPath, ".migration-history.json");
+    try {
+      let history = [];
+      try {
+        const content = await readFile9(historyPath, "utf-8");
+        history = JSON.parse(content);
+      } catch {
+      }
+      history.push(...entries);
+      await writeFile10(historyPath, JSON.stringify(history, null, 2));
+    } catch (error) {
+      logger.error("Failed to update migration history:", error);
+    }
+  }
+  /**
+   * Update migration history status
+   */
+  async updateMigrationHistoryStatus(version, status) {
+    const historyPath = join15(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile9(historyPath, "utf-8");
+      const history = JSON.parse(content);
+      const updated = history.map(
+        (m) => m.to === version ? { ...m, status } : m
+      );
+      await writeFile10(historyPath, JSON.stringify(updated, null, 2));
+    } catch (error) {
+      logger.error("Failed to update migration history status:", error);
+    }
+  }
+  /**
+   * Get migration history
+   */
+  async getMigrationHistory() {
+    const historyPath = join15(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile9(historyPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if migration is needed for version
+   */
+  async needsMigration(_fromVersion) {
+    const applied = await this.getAppliedMigrations();
+    const allMigrations = await this.loadMigrations();
+    const pendingMigrations = allMigrations.filter(
+      (m) => !applied.includes(m.version)
+    );
+    return pendingMigrations.length > 0;
+  }
+};
+
+// src/core/sync-engine.ts
+init_logger();
+init_paths();
+var SyncEngine = class {
+  versionManager;
+  backupManager;
+  migrationManager;
+  constructor(config) {
+    this.versionManager = new VersionManager(config);
+    this.backupManager = new BackupManager(config.configPath);
+    this.migrationManager = new MigrationManager(config.configPath);
+  }
+  /**
+   * Check for updates without applying
+   */
+  async checkForUpdates() {
+    try {
+      const changes = await this.versionManager.checkForUpdates();
+      if (changes.hasUpdate) {
+        this.displayUpdateInfo(changes);
+      } else {
+        console.log(chalk2.green("\u2713 Your AIKit is up to date"));
+        console.log(`  Installed: ${changes.fromVersion}`);
+        console.log(`  Latest:    ${changes.toVersion}`);
+      }
+      return changes;
+    } catch (error) {
+      logger.error("Failed to check for updates:", error);
+      return null;
+    }
+  }
+  /**
+   * Preview changes without applying
+   */
+  async previewUpdate() {
+    try {
+      console.log(chalk2.bold("\n\u{1F50D} Previewing update...\n"));
+      const changes = await this.versionManager.checkForUpdates();
+      if (!changes.hasUpdate) {
+        console.log(chalk2.green("\u2713 No updates available"));
+        return false;
+      }
+      await this.displayChanges(changes);
+      console.log(chalk2.yellow("\n\u26A0\uFE0F  This is a preview - no changes will be made."));
+      console.log(chalk2.gray("Use `aikit sync apply` to apply these changes."));
+      return true;
+    } catch (error) {
+      logger.error("Failed to preview update:", error);
+      return false;
+    }
+  }
+  /**
+   * Apply update
+   */
+  async applyUpdate(options = {}) {
+    try {
+      const changes = await this.versionManager.checkForUpdates();
+      if (!changes.hasUpdate) {
+        console.log(chalk2.green("\u2713 Already up to date"));
+        return {
+          success: true,
+          newSkills: [],
+          updatedSkills: [],
+          removedSkills: [],
+          migrationsRun: []
+        };
+      }
+      await this.displayChanges(changes);
+      if (!options.force) {
+        const { confirmed } = await inquirer.prompt([{
+          type: "confirm",
+          name: "confirmed",
+          message: "Continue with update?",
+          default: false
+        }]);
+        if (!confirmed) {
+          console.log(chalk2.yellow("Update cancelled"));
+          return {
+            success: false,
+            newSkills: [],
+            updatedSkills: [],
+            removedSkills: [],
+            migrationsRun: []
+          };
+        }
+      }
+      let backupId = void 0;
+      if (!options.dryRun && options.backup !== false) {
+        console.log(chalk2.bold("\n\u{1F4E6} Creating backup..."));
+        const backupResult = await this.backupManager.createBackup(
+          changes.fromVersion,
+          changes.toVersion
+        );
+        if (!backupResult) {
+          throw new Error("Failed to create backup");
+        }
+        backupId = backupResult;
+      }
+      for (const conflict of changes.conflicts) {
+        await this.resolveConflict(conflict);
+      }
+      console.log(chalk2.bold("\n\u{1F504} Running migrations..."));
+      const migrationResult = await this.migrationManager.runPendingMigrations();
+      if (!migrationResult.success) {
+        throw new Error(`Migration failed: ${migrationResult.failed.join(", ")}`);
+      }
+      console.log(chalk2.bold("\n\u{1F4DD} Updating skills..."));
+      const updateResult = await this.updateSkills(changes, options);
+      await this.versionManager.updateVersion(changes.toVersion);
+      if (backupId) {
+        const allSkills = await this.versionManager.loadSkillHashes(paths.skills(paths.globalConfig()));
+        await this.versionManager.saveInstalledSkills(allSkills);
+      }
+      console.log(chalk2.green("\n\u2705 Update complete!"));
+      this.displaySummary({
+        success: true,
+        backupId,
+        ...updateResult,
+        migrationsRun: migrationResult.applied
+      });
+      return {
+        success: true,
+        backupId,
+        ...updateResult,
+        migrationsRun: migrationResult.applied
+      };
+    } catch (error) {
+      logger.error("Update failed:", error);
+      console.log(chalk2.red("\n\u274C Update failed"));
+      return {
+        success: false,
+        newSkills: [],
+        updatedSkills: [],
+        removedSkills: [],
+        migrationsRun: []
+      };
+    }
+  }
+  /**
+   * Rollback to previous backup
+   */
+  async rollback(backupId) {
+    try {
+      console.log(chalk2.bold("\n\u{1F504} Rollback...\n"));
+      if (!backupId) {
+        const backups = await this.backupManager.listBackups();
+        if (backups.length === 0) {
+          console.log(chalk2.yellow("No backups available"));
+          return false;
+        }
+        const { selectedBackup } = await inquirer.prompt([{
+          type: "list",
+          name: "selectedBackup",
+          message: "Select backup to restore:",
+          choices: backups.map((b) => ({
+            name: `${b.manifest.backupId} (${b.manifest.fromVersion} \u2192 ${b.manifest.toVersion})`,
+            value: b.manifest.backupId
+          }))
+        }]);
+        backupId = selectedBackup;
+      }
+      if (!backupId) {
+        console.log(chalk2.yellow("No backup ID provided"));
+        return false;
+      }
+      const success = await this.backupManager.restoreBackup(backupId);
+      if (success) {
+        console.log(chalk2.green("\u2713 Rollback complete"));
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.error("Rollback failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Display update information
+   */
+  displayUpdateInfo(changes) {
+    console.log(chalk2.bold("\n\u{1F4E2} New version available!\n"));
+    console.log(`  ${chalk2.cyan("Current:")} ${changes.fromVersion}`);
+    console.log(`  ${chalk2.cyan("Latest:")}  ${changes.toVersion}
+`);
+  }
+  /**
+   * Display changes summary
+   */
+  async displayChanges(changes) {
+    console.log(chalk2.bold("\u{1F4CA} Changes detected:\n"));
+    if (changes.newSkills.length > 0) {
+      console.log(chalk2.green("  New Skills:"));
+      changes.newSkills.forEach((skill) => {
+        console.log(`    + ${skill.name} (${skill.category})`);
+      });
+    }
+    if (changes.modifiedSkills.length > 0) {
+      console.log(chalk2.yellow("  Updated Skills:"));
+      changes.modifiedSkills.forEach((skill) => {
+        console.log(`    ~ ${skill.name}`);
+      });
+    }
+    if (changes.removedSkills.length > 0) {
+      console.log(chalk2.red("  Removed Skills:"));
+      changes.removedSkills.forEach((skill) => {
+        console.log(`    - ${skill.name}`);
+      });
+    }
+    if (changes.conflicts.length > 0) {
+      console.log(chalk2.bold.red("  \u26A0\uFE0F  Conflicts:"));
+      changes.conflicts.forEach((conflict) => {
+        console.log(`    ! ${conflict.skillName} (user modified)`);
+      });
+    }
+  }
+  /**
+   * Resolve a conflict
+   */
+  async resolveConflict(conflict) {
+    console.log(chalk2.bold.red(`
+\u26A0\uFE0F  Conflict detected: ${conflict.skillName}
+`));
+    console.log(chalk2.yellow("Your version differs from official version."));
+    const { action } = await inquirer.prompt([{
+      type: "list",
+      name: "action",
+      message: "Choose action:",
+      choices: [
+        {
+          name: "Keep your version (will be renamed to -custom.md)",
+          value: "preserve"
+        },
+        {
+          name: "Overwrite with official version",
+          value: "overwrite"
+        },
+        {
+          name: "Skip this skill",
+          value: "skip"
+        }
+      ]
+    }]);
+    if (action === "skip") {
+      return;
+    }
+    if (action === "overwrite") {
+      return;
+    }
+    console.log(chalk2.yellow("  Your version will be preserved as -custom.md"));
+  }
+  /**
+   * Update skills based on changes
+   */
+  async updateSkills(changes, options) {
+    const globalSkillsPath = paths.skills(paths.globalConfig());
+    const projectSkillsPath = paths.skills(this.versionManager["config"].configPath);
+    const newSkills = [];
+    const updatedSkills = [];
+    const removedSkills = [];
+    for (const skill of changes.newSkills) {
+      if (!options.dryRun) {
+        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
+      }
+      newSkills.push(skill.name);
+      console.log(chalk2.green(`    + ${skill.name}`));
+    }
+    for (const skill of changes.modifiedSkills) {
+      if (!options.dryRun) {
+        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
+      }
+      updatedSkills.push(skill.name);
+      console.log(chalk2.yellow(`    ~ ${skill.name}`));
+    }
+    for (const skill of changes.removedSkills) {
+      if (!options.dryRun) {
+        await this.archiveSkill(projectSkillsPath, skill);
+      }
+      removedSkills.push(skill.name);
+      console.log(chalk2.red(`    - ${skill.name} (archived)`));
+    }
+    return {
+      newSkills,
+      updatedSkills,
+      removedSkills
+    };
+  }
+  /**
+   * Install a skill
+   */
+  async installSkill(sourceDir, skill, targetDir) {
+    const sourcePath = join16(sourceDir, skill.category, `${skill.name}.md`);
+    const targetPath = join16(targetDir, skill.category, `${skill.name}.md`);
+    await mkdir9(dirname3(targetPath), { recursive: true });
+    await copyFile(sourcePath, targetPath);
+  }
+  /**
+   * Archive a removed skill
+   */
+  async archiveSkill(targetDir, skill) {
+    const sourcePath = join16(targetDir, skill.category, `${skill.name}.md`);
+    const targetPath = join16(targetDir, skill.category, `${skill.name}-deprecated.md`);
+    try {
+      const content = await readFile10(sourcePath, "utf-8");
+      const deprecatedNotice = `---
+\u26A0\uFE0F  DEPRECATED: This skill has been removed
+
+Deprecation date: ${(/* @__PURE__ */ new Date()).toISOString()}
+Reason: Check release notes for replacement
+---
+
+${content}`;
+      await mkdir9(dirname3(targetPath), { recursive: true });
+      await writeFile11(targetPath, deprecatedNotice);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.log(chalk2.yellow(`    - ${skill.name} (not found, skipping)`));
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Display sync summary
+   */
+  displaySummary(result) {
+    console.log(chalk2.bold("\n\u{1F4CB} Summary:\n"));
+    console.log(`  Updated from: ${chalk2.cyan(result.backupId || "N/A")}`);
+    console.log(`  Updated to:   ${chalk2.cyan("current")}`);
+    console.log();
+    if (result.newSkills.length > 0) {
+      console.log(chalk2.green(`  ${result.newSkills.length} new skills installed`));
+    }
+    if (result.updatedSkills.length > 0) {
+      console.log(chalk2.yellow(`  ${result.updatedSkills.length} skills updated`));
+    }
+    if (result.removedSkills.length > 0) {
+      console.log(chalk2.red(`  ${result.removedSkills.length} skills archived`));
+    }
+    if (result.migrationsRun.length > 0) {
+      console.log(chalk2.blue(`  ${result.migrationsRun.length} migrations run`));
+    }
+    if (result.backupId) {
+      console.log(chalk2.gray(`
+  Rollback available: aikit sync rollback ${result.backupId}`));
+    }
+  }
+};
+
+// src/cli.ts
 var program = new Command();
 program.name("aikit").description("Open-source AI coding agent toolkit for OpenCode").version(getVersion());
 program.command("init").description("Initialize AIKit configuration").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (options) => {
   const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
-  console.log(chalk2.bold("\n\u{1F680} AIKit Setup\n"));
+  console.log(chalk3.bold("\n\u{1F680} AIKit Setup\n"));
   logger.info(`Initializing AIKit in ${configDir}...`);
   try {
     await initializeConfig(configDir, options.global);
@@ -4237,17 +5424,17 @@ program.command("init").description("Initialize AIKit configuration").option("-g
       if (result.count > 0) {
         logger.success(`\u2713 Synced ${result.count} skills`);
       }
-      console.log(chalk2.bold("\n\u{1F50D} Checking CLI tools...\n"));
+      console.log(chalk3.bold("\n\u{1F50D} Checking CLI tools...\n"));
       const cliTools = await CliDetector.checkAll();
       const installableTools = CliDetector.filterInstallable(cliTools);
       for (const tool of cliTools) {
-        const status = tool.isInstalled ? chalk2.green("\u2713 Installed") : chalk2.yellow("\u2717 Not installed");
-        const version = tool.version ? chalk2.gray(` (${tool.version})`) : "";
-        console.log(`  ${status} ${chalk2.cyan(tool.displayName)}${version}`);
+        const status = tool.installed ? chalk3.green("\u2713 Installed") : chalk3.yellow("\u2717 Not installed");
+        const version = tool.version ? chalk3.gray(` (${tool.version})`) : "";
+        console.log(`  ${status} ${chalk3.cyan(tool.displayName)}${version}`);
       }
       if (installableTools.length > 0) {
         console.log();
-        const { action } = await inquirer.prompt([
+        const { action } = await inquirer2.prompt([
           {
             type: "list",
             name: "action",
@@ -4287,7 +5474,7 @@ program.command("init").description("Initialize AIKit configuration").option("-g
           console.log();
           logger.success("\u2713 CLI tools installed");
         } else {
-          const { installTools } = await inquirer.prompt([
+          const { installTools } = await inquirer2.prompt([
             {
               type: "checkbox",
               name: "installTools",
@@ -4331,16 +5518,16 @@ program.command("init").description("Initialize AIKit configuration").option("-g
       }
       const opencodePath = paths.opencodeConfig();
       await installToOpenCode(opencodePath);
-      console.log(chalk2.bold("\n\u2728 AIKit is ready!\n"));
+      console.log(chalk3.bold("\n\u2728 AIKit is ready!\n"));
       console.log("Usage in OpenCode:");
-      console.log(chalk2.cyan("  /skills") + "  - List all available skills");
-      console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
-      console.log(chalk2.cyan("  /tdd") + "     - Test-driven development");
-      console.log(chalk2.cyan("  /debug") + "   - Systematic debugging");
-      console.log(chalk2.cyan("  /review") + "  - Code review checklist");
-      console.log(chalk2.cyan("  /git") + "     - Git workflow");
-      console.log(chalk2.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
-      console.log("\nPress " + chalk2.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
+      console.log(chalk3.cyan("  /skills") + "  - List all available skills");
+      console.log(chalk3.cyan("  /plan") + "    - Create implementation plan");
+      console.log(chalk3.cyan("  /tdd") + "     - Test-driven development");
+      console.log(chalk3.cyan("  /debug") + "   - Systematic debugging");
+      console.log(chalk3.cyan("  /review") + "  - Code review checklist");
+      console.log(chalk3.cyan("  /git") + "     - Git workflow");
+      console.log(chalk3.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
+      console.log("\nPress " + chalk3.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
     }
   } catch (error) {
     logger.error("Failed to initialize AIKit:", error);
@@ -4358,6 +5545,32 @@ program.command("install").description("Install AIKit to OpenCode configuration"
     process.exit(1);
   }
 });
+program.command("sync [subcommand]").description("Update AIKit to latest version").option("--dry-run", "Preview changes without applying").option("-f, --force", "Skip confirmation prompts").option("--no-backup", "Skip creating backup").action(async (subcommand, options) => {
+  const config = await loadConfig();
+  const syncEngine = new SyncEngine(config);
+  if (!subcommand) {
+    await syncEngine.applyUpdate(options);
+  } else {
+    switch (subcommand) {
+      case "check":
+        await syncEngine.checkForUpdates();
+        break;
+      case "preview":
+        await syncEngine.previewUpdate();
+        break;
+      case "apply":
+        await syncEngine.applyUpdate(options);
+        break;
+      case "rollback":
+        await syncEngine.rollback();
+        break;
+      default:
+        logger.error(`Unknown subcommand: ${subcommand}`);
+        console.log(chalk3.gray("Available subcommands: check, preview, apply, rollback"));
+        process.exit(1);
+    }
+  }
+});
 var skillsCmd = program.command("skills").description("Manage skills");
 skillsCmd.command("list").description("List available skills and tools with their configuration status").action(async () => {
   const config = await loadConfig();
@@ -4366,31 +5579,31 @@ skillsCmd.command("list").description("List available skills and tools with thei
   const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
   const toolConfigManager = new ToolConfigManager2(config);
   const tools = await toolConfigManager.listTools();
-  console.log(chalk2.bold("\n\u{1F4DA} Available Skills:\n"));
+  console.log(chalk3.bold("\n\u{1F4DA} Available Skills:\n"));
   for (const skill of skills) {
-    console.log(`  ${chalk2.cyan(skill.name)} - ${skill.description}`);
+    console.log(`  ${chalk3.cyan(skill.name)} - ${skill.description}`);
   }
-  console.log(chalk2.bold("\n\u{1F527} Available Tools:\n"));
+  console.log(chalk3.bold("\n\u{1F527} Available Tools:\n"));
   for (const tool of tools) {
     let statusIcon = "  ";
     let statusText = "";
     if (tool.status === "ready") {
-      statusIcon = chalk2.green("\u2713");
-      statusText = chalk2.gray("(ready)");
+      statusIcon = chalk3.green("\u2713");
+      statusText = chalk3.gray("(ready)");
     } else if (tool.status === "needs_config") {
-      statusIcon = chalk2.yellow("\u26A0");
-      statusText = chalk2.yellow("(needs config)");
+      statusIcon = chalk3.yellow("\u26A0");
+      statusText = chalk3.yellow("(needs config)");
     } else if (tool.status === "error") {
-      statusIcon = chalk2.red("\u2717");
-      statusText = chalk2.red("(error)");
+      statusIcon = chalk3.red("\u2717");
+      statusText = chalk3.red("(error)");
     }
-    console.log(`  ${statusIcon} ${chalk2.cyan(tool.name)} - ${tool.description} ${statusText}`);
+    console.log(`  ${statusIcon} ${chalk3.cyan(tool.name)} - ${tool.description} ${statusText}`);
     if (tool.errorMessage) {
-      console.log(`    ${chalk2.red("Error:")} ${tool.errorMessage}`);
+      console.log(`    ${chalk3.red("Error:")} ${tool.errorMessage}`);
     }
   }
   console.log();
-  console.log(chalk2.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
+  console.log(chalk3.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
 });
 skillsCmd.command("show <name>").description("Show skill details").action(async (name) => {
   const config = await loadConfig();
@@ -4400,11 +5613,11 @@ skillsCmd.command("show <name>").description("Show skill details").action(async
     logger.error(`Skill not found: ${name}`);
     process.exit(1);
   }
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 \u{1F4D6} Skill: ${skill.name}
 `));
-  console.log(chalk2.gray(skill.description));
-  console.log(chalk2.bold("\nWorkflow:"));
+  console.log(chalk3.gray(skill.description));
+  console.log(chalk3.bold("\nWorkflow:"));
   console.log(skill.content);
 });
 skillsCmd.command("create <name>").description("Create a new skill").action(async (name) => {
@@ -4420,11 +5633,11 @@ skillsCmd.command("sync").description("Sync global skills to project").action(as
   if (result.count === 0) {
     logger.info("Skills already in sync or no global skills to sync");
   } else {
-    console.log(chalk2.bold(`
+    console.log(chalk3.bold(`
 \u2713 Synced ${result.count} skills to project:
 `));
     for (const skill of result.synced) {
-      console.log(`  ${chalk2.cyan("\u2022")} ${skill}`);
+      console.log(`  ${chalk3.cyan("\u2022")} ${skill}`);
     }
     console.log();
   }
@@ -4436,18 +5649,18 @@ skillsCmd.command("config <tool-name>").description("Configure a tool (e.g., con
   const tool = await toolConfigManager.getToolConfig(toolName);
   if (!tool) {
     logger.error(`Tool not found: ${toolName}`);
-    console.log(chalk2.gray("\nAvailable tools:"));
+    console.log(chalk3.gray("\nAvailable tools:"));
     const tools = await toolConfigManager.listTools();
     for (const t of tools) {
-      console.log(`  - ${chalk2.cyan(t.name)}`);
+      console.log(`  - ${chalk3.cyan(t.name)}`);
     }
     console.log();
     process.exit(1);
   }
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 \u{1F527} Configuring: ${tool.name}
 `));
-  console.log(chalk2.gray(tool.description));
+  console.log(chalk3.gray(tool.description));
   console.log();
   if (tool.configMethod === "oauth") {
     if (toolName === "figma-analysis") {
@@ -4455,12 +5668,12 @@ skillsCmd.command("config <tool-name>").description("Configure a tool (e.g., con
       const oauth = new FigmaOAuth2(toolConfigManager);
       try {
         const token = await oauth.authenticate();
-        console.log(chalk2.gray("\nValidating token..."));
+        console.log(chalk3.gray("\nValidating token..."));
         const isValid = await oauth.validateToken(token);
         if (isValid) {
           logger.success(`
 \u2705 ${tool.name} configured successfully!`);
-          console.log(chalk2.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+          console.log(chalk3.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
         } else {
           await toolConfigManager.updateToolConfig(toolName, {
             status: "error",
@@ -4499,20 +5712,20 @@ skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis confi
     const tool = await toolConfigManager.getToolConfig(toolName);
     if (!tool) {
       logger.error(`Tool not found: ${toolName}`);
-      console.log(chalk2.gray("\nAvailable tools:"));
+      console.log(chalk3.gray("\nAvailable tools:"));
       const tools = await toolConfigManager.listTools();
       for (const t of tools) {
-        console.log(`  - ${chalk2.cyan(t.name)}`);
+        console.log(`  - ${chalk3.cyan(t.name)}`);
       }
       console.log();
-      console.log(chalk2.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
+      console.log(chalk3.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
       console.log();
       process.exit(1);
     }
-    console.log(chalk2.bold(`
+    console.log(chalk3.bold(`
 \u{1F527} Configuring: ${tool.name}
 `));
-    console.log(chalk2.gray(tool.description));
+    console.log(chalk3.gray(tool.description));
     console.log();
     if (tool.configMethod === "oauth") {
       if (toolName === "figma-analysis") {
@@ -4520,12 +5733,12 @@ skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis confi
         const oauth = new FigmaOAuth2(toolConfigManager);
         try {
           const token = await oauth.authenticate();
-          console.log(chalk2.gray("\nValidating token..."));
+          console.log(chalk3.gray("\nValidating token..."));
           const isValid = await oauth.validateToken(token);
           if (isValid) {
             logger.success(`
 \u2705 ${tool.name} configured successfully!`);
-            console.log(chalk2.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+            console.log(chalk3.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
           } else {
             await toolConfigManager.updateToolConfig(toolName, {
               status: "error",
@@ -4554,7 +5767,7 @@ skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis confi
     }
   } else {
     logger.error(`Unknown command: ${toolName || "unknown"} ${action || ""}`);
-    console.log(chalk2.gray("\nAvailable commands:"));
+    console.log(chalk3.gray("\nAvailable commands:"));
     console.log("  aikit skills list                    - List all skills and tools");
     console.log("  aikit skills show <name>              - Show skill details");
     console.log("  aikit skills config <tool-name>       - Configure a tool");
@@ -4568,10 +5781,10 @@ agentsCmd.command("list").description("List available agents").action(async () =
   const config = await loadConfig();
   const manager = new AgentManager(config);
   const agents = manager.listAgents();
-  console.log(chalk2.bold("\n\u{1F916} Available Agents:\n"));
+  console.log(chalk3.bold("\n\u{1F916} Available Agents:\n"));
   for (const agent of agents) {
-    console.log(`  ${chalk2.cyan(`@${agent.name}`)} - ${agent.description}`);
-    console.log(chalk2.gray(`    Use when: ${agent.useWhen}`));
+    console.log(`  ${chalk3.cyan(`@${agent.name}`)} - ${agent.description}`);
+    console.log(chalk3.gray(`    Use when: ${agent.useWhen}`));
   }
   console.log();
 });
@@ -4580,13 +5793,13 @@ commandsCmd.command("list").description("List available commands").action(async
   const config = await loadConfig();
   const runner = new CommandRunner(config);
   const commands = await runner.listCommands();
-  console.log(chalk2.bold("\n\u26A1 Available Commands:\n"));
+  console.log(chalk3.bold("\n\u26A1 Available Commands:\n"));
   const groups = groupBy(commands, (c) => c.category);
   for (const [category, cmds] of Object.entries(groups)) {
-    console.log(chalk2.bold.yellow(`
+    console.log(chalk3.bold.yellow(`
   ${category}:`));
     for (const cmd of cmds) {
-      console.log(`    ${chalk2.cyan(`/${cmd.name}`)} - ${cmd.description}`);
+      console.log(`    ${chalk3.cyan(`/${cmd.name}`)} - ${cmd.description}`);
     }
   }
   console.log();
@@ -4596,9 +5809,9 @@ toolsCmd.command("list").description("List available tools").action(async () =>
   const config = await loadConfig();
   const registry = new ToolRegistry(config);
   const tools = await registry.listTools();
-  console.log(chalk2.bold("\n\u{1F527} Available Tools:\n"));
+  console.log(chalk3.bold("\n\u{1F527} Available Tools:\n"));
   for (const tool of tools) {
-    console.log(`  ${chalk2.cyan(tool.name)} - ${tool.description}`);
+    console.log(`  ${chalk3.cyan(tool.name)} - ${tool.description}`);
   }
   console.log();
 });
@@ -4607,10 +5820,10 @@ pluginsCmd.command("list").description("List available plugins").action(async ()
   const config = await loadConfig();
   const system = new PluginSystem(config);
   const plugins = await system.listPlugins();
-  console.log(chalk2.bold("\n\u{1F50C} Available Plugins:\n"));
+  console.log(chalk3.bold("\n\u{1F50C} Available Plugins:\n"));
   for (const plugin of plugins) {
-    const status = plugin.enabled ? chalk2.green("\u2713") : chalk2.gray("\u25CB");
-    console.log(`  ${status} ${chalk2.cyan(plugin.name)} - ${plugin.description}`);
+    const status = plugin.enabled ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
+    console.log(`  ${status} ${chalk3.cyan(plugin.name)} - ${plugin.description}`);
   }
   console.log();
 });
@@ -4619,10 +5832,10 @@ memoryCmd.command("list").description("List memory entries").action(async () =>
   const config = await loadConfig();
   const memory = new MemoryManager(config);
   const entries = await memory.list();
-  console.log(chalk2.bold("\n\u{1F9E0} Memory Entries:\n"));
+  console.log(chalk3.bold("\n\u{1F9E0} Memory Entries:\n"));
   for (const entry of entries) {
-    console.log(`  ${chalk2.cyan(entry.key)} - ${entry.summary}`);
-    console.log(chalk2.gray(`    Updated: ${entry.updatedAt}`));
+    console.log(`  ${chalk3.cyan(entry.key)} - ${entry.summary}`);
+    console.log(chalk3.gray(`    Updated: ${entry.updatedAt}`));
   }
   console.log();
 });
@@ -4640,19 +5853,19 @@ var beadsCmd = program.command("beads").description("Beads task management integ
 beadsCmd.command("status").description("Show current Beads status").action(async () => {
   const beads = new BeadsIntegration();
   const status = await beads.getStatus();
-  console.log(chalk2.bold("\n\u{1F4FF} Beads Status:\n"));
+  console.log(chalk3.bold("\n\u{1F4FF} Beads Status:\n"));
   console.log(`  Active tasks: ${status.activeTasks}`);
   console.log(`  Completed: ${status.completedTasks}`);
   console.log(`  Current: ${status.currentTask || "None"}`);
   console.log();
 });
 program.command("status").description("Show AIKit status").action(async () => {
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 \u{1F680} AIKit v${getVersion}
 `));
   try {
     const config = await loadConfig();
-    console.log(chalk2.green("\u2713 Configuration loaded"));
+    console.log(chalk3.green("\u2713 Configuration loaded"));
     const skillEngine = new SkillEngine(config);
     const skills = await skillEngine.listSkills();
     console.log(`  Skills: ${skills.length}`);
@@ -4667,15 +5880,15 @@ program.command("status").description("Show AIKit status").action(async () => {
     console.log(`  Tools: ${tools.length}`);
     const beads = new BeadsIntegration();
     const beadsStatus = await beads.isInstalled();
-    console.log(`  Beads: ${beadsStatus ? chalk2.green("Installed") : chalk2.yellow("Not installed")}`);
+    console.log(`  Beads: ${beadsStatus ? chalk3.green("Installed") : chalk3.yellow("Not installed")}`);
   } catch (error) {
-    console.log(chalk2.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
+    console.log(chalk3.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
   }
   console.log();
 });
 async function initializeConfig(configDir, _isGlobal) {
-  const { mkdir: mkdir9, writeFile: writeFile9 } = await import("fs/promises");
-  const { join: join14 } = await import("path");
+  const { mkdir: mkdir11, writeFile: writeFile13 } = await import("fs/promises");
+  const { join: join18 } = await import("path");
   const dirs = [
     "",
     "skills",
@@ -4694,7 +5907,7 @@ async function initializeConfig(configDir, _isGlobal) {
     "memory/research"
   ];
   for (const dir of dirs) {
-    await mkdir9(join14(configDir, dir), { recursive: true });
+    await mkdir11(join18(configDir, dir), { recursive: true });
   }
   const defaultConfig = {
     version: getVersion,
@@ -4707,8 +5920,8 @@ async function initializeConfig(configDir, _isGlobal) {
     beads: { enabled: true },
     antiHallucination: { enabled: true }
   };
-  await writeFile9(
-    join14(configDir, "aikit.json"),
+  await writeFile13(
+    join18(configDir, "aikit.json"),
     JSON.stringify(defaultConfig, null, 2)
   );
   const agentsMd = `# AIKit Agent Rules
@@ -4731,26 +5944,26 @@ async function initializeConfig(configDir, _isGlobal) {
 ## Project-Specific Rules
 Add your project-specific rules here.
 `;
-  await writeFile9(join14(configDir, "AGENTS.md"), agentsMd);
+  await writeFile13(join18(configDir, "AGENTS.md"), agentsMd);
 }
 async function configureMcpServer(projectPath) {
-  const { mkdir: mkdir9, writeFile: writeFile9, readFile: readFile8 } = await import("fs/promises");
-  const { join: join14 } = await import("path");
+  const { mkdir: mkdir11, writeFile: writeFile13, readFile: readFile12 } = await import("fs/promises");
+  const { join: join18 } = await import("path");
   const { existsSync: existsSync5 } = await import("fs");
   const { homedir: homedir3 } = await import("os");
   const { fileURLToPath: fileURLToPath3 } = await import("url");
-  const { dirname: dirname2 } = await import("path");
+  const { dirname: dirname4 } = await import("path");
   const currentFile = fileURLToPath3(import.meta.url);
-  const currentDir = dirname2(currentFile);
-  const aikitPath = join14(currentDir, "..");
-  const mcpServerPath = join14(aikitPath, "dist", "mcp-server.js");
+  const currentDir = dirname4(currentFile);
+  const aikitPath = join18(currentDir, "..");
+  const mcpServerPath = join18(aikitPath, "dist", "mcp-server.js");
   const configLocations = [
     // Global config (most common)
-    join14(homedir3(), ".config", "opencode", "opencode.json"),
+    join18(homedir3(), ".config", "opencode", "opencode.json"),
     // Project-level config
-    join14(projectPath, ".opencode", "opencode.json"),
+    join18(projectPath, ".opencode", "opencode.json"),
     // Alternative global location
-    join14(homedir3(), ".opencode", "opencode.json")
+    join18(homedir3(), ".opencode", "opencode.json")
   ];
   const mcpServerConfig = {
     type: "local",
@@ -4759,12 +5972,12 @@ async function configureMcpServer(projectPath) {
   };
   for (const configPath of configLocations) {
     try {
-      const configDir = join14(configPath, "..");
-      await mkdir9(configDir, { recursive: true });
+      const configDir = join18(configPath, "..");
+      await mkdir11(configDir, { recursive: true });
       let config = {};
       if (existsSync5(configPath)) {
         try {
-          const existing = await readFile8(configPath, "utf-8");
+          const existing = await readFile12(configPath, "utf-8");
           config = JSON.parse(existing);
         } catch {
           config = {};
@@ -4774,7 +5987,7 @@ async function configureMcpServer(projectPath) {
         config.mcp = {};
       }
       config.mcp.aikit = mcpServerConfig;
-      await writeFile9(configPath, JSON.stringify(config, null, 2));
+      await writeFile13(configPath, JSON.stringify(config, null, 2));
       logger.success(`
 \u2705 MCP server configured: ${configPath}`);
       logger.info(`   Server: node ${mcpServerPath}`);
@@ -4783,9 +5996,9 @@ async function configureMcpServer(projectPath) {
       continue;
     }
   }
-  const instructionsPath = join14(projectPath, ".opencode", "MCP_SETUP.md");
-  await mkdir9(join14(projectPath, ".opencode"), { recursive: true });
-  await writeFile9(instructionsPath, `# AIKit MCP Server Configuration
+  const instructionsPath = join18(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir11(join18(projectPath, ".opencode"), { recursive: true });
+  await writeFile13(instructionsPath, `# AIKit MCP Server Configuration
 
 ## Automatic Setup Failed
 
@@ -4848,15 +6061,15 @@ async function installCliTool(tool) {
   }
 }
 async function installToOpenCode(_opencodePath) {
-  const { mkdir: mkdir9, writeFile: writeFile9, access: access5 } = await import("fs/promises");
-  const { join: join14 } = await import("path");
+  const { mkdir: mkdir11, writeFile: writeFile13, access: access5 } = await import("fs/promises");
+  const { join: join18 } = await import("path");
   const projectPath = process.cwd();
-  const opencodeCommandDir = join14(projectPath, ".opencode", "command");
-  const aikitDir = join14(projectPath, ".aikit");
-  const opencodeAgentDir = join14(paths.opencodeConfig(), "agent");
-  await mkdir9(opencodeCommandDir, { recursive: true });
-  await mkdir9(join14(aikitDir, "skills"), { recursive: true });
-  await mkdir9(opencodeAgentDir, { recursive: true });
+  const opencodeCommandDir = join18(projectPath, ".opencode", "command");
+  const aikitDir = join18(projectPath, ".aikit");
+  const opencodeAgentDir = join18(paths.opencodeConfig(), "agent");
+  await mkdir11(opencodeCommandDir, { recursive: true });
+  await mkdir11(join18(aikitDir, "skills"), { recursive: true });
+  await mkdir11(opencodeAgentDir, { recursive: true });
   const agentFiles = {
     agent: `---
 description: General-purpose default agent (OpenCode compatibility).
@@ -4925,14 +6138,60 @@ tools:
   "*": true
 ---
 
-Use to interpret visual assets (components, layout, colors, typography) and translate to tasks.`
+Use to interpret visual assets (components, layout, colors, typography) and translate to tasks.`,
+    "one-shot": `---
+description: End-to-end autonomous task execution (beta). Complete tasks from start to finish.
+mode: subagent
+tools:
+  "*": true
+---
+
+\u26A0\uFE0F BETA: This mode is experimental. Use for straightforward tasks first.
+
+## One-Shot Mode - Autonomous Task Execution
+
+Execute tasks end-to-end with minimal intervention:
+
+### Workflow Phases
+1. **REQUIREMENTS** - Gather task type, scope, dependencies, success criteria
+2. **PLANNING** - Create detailed plan, recommend skills/tools, create tracking bead
+3. **COMPLEXITY** - Auto-split if: >30min, >10 files, >500 lines, >2 sub-systems
+4. **EXECUTION** - Parallel tasks (max 3), dynamic agent delegation
+5. **TESTING** - Run until pass: typecheck \u2192 test \u2192 lint \u2192 build (max 3 retries)
+6. **VERIFICATION** - Quality gates \u2713 \u2192 Manual verification \u2192 Deployment approval
+7. **COMPLETION** - Generate proof, update tracking, collect feedback
+
+### Quality Gates (ALL must pass)
+- \`npm run typecheck\` - No type errors
+- \`npm run test\` - All tests pass
+- \`npm run lint\` - No lint errors
+- \`npm run build\` - Build succeeds
+
+### Error Recovery (3 Levels)
+- **Level 1**: Auto-fix (type errors, lint --fix)
+- **Level 2**: Alternative approach via @review
+- **Level 3**: User intervention + follow-up task
+
+### Delegates To
+@planner for planning, @build for implementation, @review for code review,
+@scout for research, @explore for navigation, @vision for visual analysis.
+
+### Best Use Cases
+- Straightforward features with clear scope
+- Bug fixes with known reproduction steps
+- Refactoring with defined boundaries
+
+### Consider Alternatives For
+- Complex multi-system features \u2192 Use /plan + /implement
+- Exploratory research \u2192 Use /research first
+- Critical production changes \u2192 Manual with /review`
   };
   for (const [name, content] of Object.entries(agentFiles)) {
-    const filePath = join14(opencodeAgentDir, `${name}.md`);
+    const filePath = join18(opencodeAgentDir, `${name}.md`);
     try {
       await access5(filePath);
     } catch {
-      await writeFile9(filePath, content, "utf8");
+      await writeFile13(filePath, content, "utf8");
     }
   }
   const config = await loadConfig();
@@ -5185,8 +6444,8 @@ ${cmd.content}
   }
   let count = 0;
   for (const [name, content] of Object.entries(opencodeCommands)) {
-    const filePath = join14(opencodeCommandDir, `${name}.md`);
-    await writeFile9(filePath, content.trim());
+    const filePath = join18(opencodeCommandDir, `${name}.md`);
+    await writeFile13(filePath, content.trim());
     logger.info(`  \u2713 Created /${name} command`);
     count++;
   }