@tdsoft-tech/aikit 0.1.13 → 0.1.14

package/dist/cli.js

@@ -127,6 +127,184 @@ var init_paths = __esm({
   }
 });
 
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, join as join2 } from "path";
+function getVersion() {
+  try {
+    const __filename2 = fileURLToPath2(import.meta.url);
+    const __dirname2 = dirname(__filename2);
+    const packageJsonPath = join2(__dirname2, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch (error) {
+    console.warn("Warning: Could not read version from package.json, using fallback");
+    return "0.0.0";
+  }
+}
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/config.ts
+var config_exports = {};
+__export(config_exports, {
+  Config: () => Config,
+  loadConfig: () => loadConfig
+});
+import { readFile, access, constants } from "fs/promises";
+import { join as join3 } from "path";
+import { z } from "zod";
+async function loadConfig(projectPath) {
+  const project = projectPath || process.cwd();
+  const projectConfigPath = paths.projectConfig(project);
+  const globalConfigPath = paths.globalConfig();
+  let configPath;
+  let configData = {};
+  try {
+    await access(join3(globalConfigPath, "aikit.json"), constants.R_OK);
+    const globalContent = await readFile(join3(globalConfigPath, "aikit.json"), "utf-8");
+    configData = JSON.parse(globalContent);
+    configPath = globalConfigPath;
+  } catch {
+    configPath = projectConfigPath;
+  }
+  try {
+    await access(join3(projectConfigPath, "aikit.json"), constants.R_OK);
+    const projectContent = await readFile(join3(projectConfigPath, "aikit.json"), "utf-8");
+    const projectData = JSON.parse(projectContent);
+    configData = deepMerge(configData, projectData);
+    configPath = projectConfigPath;
+  } catch {
+  }
+  if (!configData.version) {
+    configData.version = getVersion();
+  }
+  const parsed = ConfigSchema.parse(configData);
+  return new Config({
+    ...parsed,
+    configPath,
+    projectPath: project
+  });
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key in override) {
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (typeof baseValue === "object" && baseValue !== null && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(baseValue) && !Array.isArray(overrideValue)) {
+      result[key] = deepMerge(
+        baseValue,
+        overrideValue
+      );
+    } else if (overrideValue !== void 0) {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+var ConfigSchema, Config;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    init_version();
+    ConfigSchema = z.object({
+      version: z.string(),
+      skills: z.object({
+        enabled: z.boolean().default(true),
+        directory: z.string().optional()
+      }).default({}),
+      agents: z.object({
+        enabled: z.boolean().default(true),
+        default: z.string().default("build")
+      }).default({}),
+      commands: z.object({
+        enabled: z.boolean().default(true)
+      }).default({}),
+      tools: z.object({
+        enabled: z.boolean().default(true)
+      }).default({}),
+      plugins: z.object({
+        enabled: z.boolean().default(true),
+        autoload: z.array(z.string()).optional()
+      }).default({}),
+      memory: z.object({
+        enabled: z.boolean().default(true),
+        maxSize: z.number().optional()
+      }).default({}),
+      beads: z.object({
+        enabled: z.boolean().default(true),
+        autoInit: z.boolean().default(false)
+      }).default({}),
+      antiHallucination: z.object({
+        enabled: z.boolean().default(true),
+        specFile: z.string().default("spec.md"),
+        reviewFile: z.string().default("review.md")
+      }).default({}),
+      mcp: z.object({
+        context7: z.boolean().default(false),
+        githubGrep: z.boolean().default(false),
+        gkg: z.boolean().default(false)
+      }).optional(),
+      mode: z.string().default("build").optional()
+    });
+    Config = class {
+      config;
+      constructor(config) {
+        this.config = config;
+      }
+      get() {
+        return this.config;
+      }
+      get skills() {
+        return this.config.skills;
+      }
+      get agents() {
+        return this.config.agents;
+      }
+      get commands() {
+        return this.config.commands;
+      }
+      get tools() {
+        return this.config.tools;
+      }
+      get plugins() {
+        return this.config.plugins;
+      }
+      get memory() {
+        return this.config.memory;
+      }
+      get beads() {
+        return this.config.beads;
+      }
+      get antiHallucination() {
+        return this.config.antiHallucination;
+      }
+      get mode() {
+        return this.config.mode;
+      }
+      get configPath() {
+        return this.config.configPath;
+      }
+      get projectPath() {
+        return this.config.projectPath;
+      }
+      /**
+       * Get path to a specific resource
+       */
+      getPath(resource) {
+        return paths[resource](this.configPath);
+      }
+    };
+  }
+});
+
 // src/utils/logger.ts
 import chalk from "chalk";
 var logger;
@@ -169,112 +347,328 @@ ${message}
   }
 });
 
-// src/core/tools/figma-mcp.ts
-var figma_mcp_exports = {};
-__export(figma_mcp_exports, {
-  FigmaMcpClient: () => FigmaMcpClient
+// src/core/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  MemoryManager: () => MemoryManager
 });
-import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3, access as access2, constants as constants2 } from "fs/promises";
 import { join as join6 } from "path";
-import { existsSync as existsSync2 } from "fs";
-var FigmaMcpClient;
-var init_figma_mcp = __esm({
-  "src/core/tools/figma-mcp.ts"() {
+var MemoryManager;
+var init_memory = __esm({
+  "src/core/memory.ts"() {
     "use strict";
     init_esm_shims();
-    init_logger();
-    FigmaMcpClient = class {
-      apiKey;
-      constructor(apiKey, _configManager) {
-        this.apiKey = apiKey;
+    init_paths();
+    MemoryManager = class {
+      config;
+      constructor(config) {
+        this.config = config;
       }
       /**
-       * Fetch helper with simple retry/backoff for 429/5xx
+       * List all memory entries
        */
-      async fetchWithRetry(url, options, label, retries = 3, backoffMs = 1500) {
-        let attempt = 0;
-        let lastError;
-        while (attempt <= retries) {
+      async list() {
+        const memories = [];
+        const memoryPath = paths.memory(this.config.configPath);
+        const subDirs = ["observations", "handoffs", "research"];
+        for (const subDir of subDirs) {
+          const dirPath = join6(memoryPath, subDir);
           try {
-            const res = await fetch(url, options);
-            if (res.ok) return res;
-            if (res.status === 429 || res.status >= 500) {
-              const retryAfter = Number(res.headers.get("retry-after")) || 0;
-              const delay = retryAfter > 0 ? retryAfter * 1e3 : backoffMs * (attempt + 1);
-              logger.warn(`${label} failed (status ${res.status}), retrying in ${Math.round(delay / 1e3)}s...`);
-              await new Promise((r) => setTimeout(r, delay));
-              attempt += 1;
-              continue;
+            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 readFile4(join6(dirPath, file), "utf-8");
+              const summary = this.extractSummary(content);
+              memories.push({
+                key: `${subDir}/${file.replace(".md", "")}`,
+                content,
+                summary,
+                createdAt: /* @__PURE__ */ new Date(),
+                // Would get from file stats
+                updatedAt: /* @__PURE__ */ new Date(),
+                type: subDir
+              });
             }
-            const text = await res.text();
-            throw new Error(`${label} error: ${res.status} ${res.statusText}
-${text}`);
-          } catch (err) {
-            lastError = err;
-            logger.warn(`${label} network error, attempt ${attempt + 1}/${retries + 1}: ${err instanceof Error ? err.message : String(err)}`);
-            if (attempt >= retries) break;
-            await new Promise((r) => setTimeout(r, backoffMs * (attempt + 1)));
-            attempt += 1;
+          } catch {
           }
         }
-        throw lastError instanceof Error ? lastError : new Error(`${label} failed after retries`);
-      }
-      /**
-       * Extract file key from Figma URL
-       */
-      extractFileKey(url) {
-        const match = url.match(/figma\.com\/design\/([a-zA-Z0-9]+)/);
-        return match ? match[1] : null;
+        return memories;
       }
       /**
-       * Extract node ID from Figma URL
+       * Read a memory entry
        */
-      extractNodeId(url) {
-        const match = url.match(/[?&]node-id=([^&]+)/);
-        if (!match) return null;
-        let nodeId = decodeURIComponent(match[1]);
-        if (nodeId.includes("-") && !nodeId.includes(":")) {
-          nodeId = nodeId.replace(/-/g, ":");
+      async read(key) {
+        const memoryPath = paths.memory(this.config.configPath);
+        let filePath;
+        if (key.includes("/")) {
+          filePath = join6(memoryPath, `${key}.md`);
+        } else {
+          const subDirs = ["observations", "handoffs", "research", "_templates"];
+          for (const subDir of subDirs) {
+            const testPath = join6(memoryPath, subDir, `${key}.md`);
+            try {
+              await access2(testPath, constants2.R_OK);
+              filePath = testPath;
+              break;
+            } catch {
+              continue;
+            }
+          }
+          filePath = filePath || join6(memoryPath, `${key}.md`);
+        }
+        try {
+          return await readFile4(filePath, "utf-8");
+        } catch {
+          return null;
         }
-        return nodeId;
       }
       /**
-       * Get Figma file data using API
+       * Update a memory entry
        */
-      async getFileData(url) {
-        const fileKey = this.extractFileKey(url);
-        if (!fileKey) {
-          throw new Error(`Invalid Figma URL: ${url}`);
+      async update(key, content, options) {
+        const memoryPath = paths.memory(this.config.configPath);
+        const type = options?.type || "custom";
+        let filePath;
+        if (key.includes("/")) {
+          filePath = join6(memoryPath, `${key}.md`);
+        } else {
+          const subDir = type === "observation" ? "observations" : type === "handoff" ? "handoffs" : type === "research" ? "research" : "";
+          filePath = join6(memoryPath, subDir, `${key}.md`);
         }
-        const nodeId = this.extractNodeId(url);
-        const apiUrl = nodeId ? `https://api.figma.com/v1/files/${fileKey}/nodes?ids=${encodeURIComponent(nodeId)}` : `https://api.figma.com/v1/files/${fileKey}`;
-        const response = await this.fetchWithRetry(apiUrl, {
-          headers: {
-            "X-Figma-Token": this.apiKey
-          }
-        }, "Figma file fetch");
-        const data = await response.json();
-        if (nodeId) {
-          const nodes = data.nodes;
-          const nodeData = Object.values(nodes)[0];
-          if (!nodeData) {
-            throw new Error(`Node not found: ${nodeId}`);
+        const { dirname: dirname5 } = await import("path");
+        await mkdir3(dirname5(filePath), { recursive: true });
+        if (options?.append) {
+          try {
+            const existing = await readFile4(filePath, "utf-8");
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+            content = `${existing}
+
+---
+_Updated: ${timestamp}_
+
+${content}`;
+          } catch {
           }
-          return {
-            document: nodeData.document,
-            components: {},
-            styles: {}
-          };
         }
-        return data;
+        await writeFile3(filePath, content);
       }
       /**
-       * Extract design tokens from Figma file
+       * Create a handoff bundle
        */
-      async extractDesignTokens(url, downloadAssets = true, assetsDir) {
-        const fileData = await this.getFileData(url);
-        const fileKey = this.extractFileKey(url);
-        if (!fileKey) {
+      async createHandoff(summary) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const key = `handoffs/${timestamp}`;
+        const content = `# Handoff: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+## Completed
+${summary.completed.map((item) => `- [x] ${item}`).join("\n") || "- None"}
+
+## In Progress
+${summary.inProgress.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+
+## Remaining
+${summary.remaining.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+
+## Context
+${summary.context || "No additional context."}
+
+## Next Steps
+${summary.nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "- Continue from where left off"}
+`;
+        await this.update(key, content, { type: "handoff" });
+        return key;
+      }
+      /**
+       * Get the latest handoff
+       */
+      async getLatestHandoff() {
+        const memories = await this.list();
+        const handoffs = memories.filter((m) => m.type === "handoff");
+        if (handoffs.length === 0) return null;
+        handoffs.sort((a, b) => b.key.localeCompare(a.key));
+        return handoffs[0];
+      }
+      /**
+       * Create an observation
+       */
+      async createObservation(title, observation) {
+        const slug = title.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        const key = `observations/${slug}`;
+        const content = `# ${title}
+
+## What
+${observation.what}
+
+## Why
+${observation.why}
+
+## Impact
+${observation.impact}
+
+${observation.tags?.length ? `## Tags
+${observation.tags.map((t) => `- ${t}`).join("\n")}` : ""}
+
+---
+_Created: ${(/* @__PURE__ */ new Date()).toISOString()}_
+`;
+        await this.update(key, content, { type: "observation" });
+        return key;
+      }
+      /**
+       * Save research findings
+       */
+      async saveResearch(topic, findings) {
+        const slug = topic.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        const key = `research/${slug}`;
+        const content = `# Research: ${topic}
+
+## Summary
+${findings.summary}
+
+## Sources
+${findings.sources.map((s) => `- ${s}`).join("\n")}
+
+## Recommendations
+${findings.recommendations.map((r, i) => `${i + 1}. ${r}`).join("\n")}
+
+${findings.codeExamples ? `## Code Examples
+\`\`\`
+${findings.codeExamples}
+\`\`\`` : ""}
+
+---
+_Researched: ${(/* @__PURE__ */ new Date()).toISOString()}_
+`;
+        await this.update(key, content, { type: "research" });
+        return key;
+      }
+      /**
+       * Extract a summary from content (first paragraph or heading)
+       */
+      extractSummary(content) {
+        const lines = content.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          if (!line.startsWith("#") && line.trim().length > 0) {
+            return line.slice(0, 100) + (line.length > 100 ? "..." : "");
+          }
+        }
+        if (lines[0]?.startsWith("#")) {
+          return lines[0].replace(/^#+\s*/, "");
+        }
+        return "No summary available";
+      }
+    };
+  }
+});
+
+// src/core/tools/figma-mcp.ts
+var figma_mcp_exports = {};
+__export(figma_mcp_exports, {
+  FigmaMcpClient: () => FigmaMcpClient
+});
+import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join7 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var FigmaMcpClient;
+var init_figma_mcp = __esm({
+  "src/core/tools/figma-mcp.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    FigmaMcpClient = class {
+      apiKey;
+      constructor(apiKey, _configManager) {
+        this.apiKey = apiKey;
+      }
+      /**
+       * Fetch helper with simple retry/backoff for 429/5xx
+       */
+      async fetchWithRetry(url, options, label, retries = 3, backoffMs = 1500) {
+        let attempt = 0;
+        let lastError;
+        while (attempt <= retries) {
+          try {
+            const res = await fetch(url, options);
+            if (res.ok) return res;
+            if (res.status === 429 || res.status >= 500) {
+              const retryAfter = Number(res.headers.get("retry-after")) || 0;
+              const delay = retryAfter > 0 ? retryAfter * 1e3 : backoffMs * (attempt + 1);
+              logger.warn(`${label} failed (status ${res.status}), retrying in ${Math.round(delay / 1e3)}s...`);
+              await new Promise((r) => setTimeout(r, delay));
+              attempt += 1;
+              continue;
+            }
+            const text = await res.text();
+            throw new Error(`${label} error: ${res.status} ${res.statusText}
+${text}`);
+          } catch (err) {
+            lastError = err;
+            logger.warn(`${label} network error, attempt ${attempt + 1}/${retries + 1}: ${err instanceof Error ? err.message : String(err)}`);
+            if (attempt >= retries) break;
+            await new Promise((r) => setTimeout(r, backoffMs * (attempt + 1)));
+            attempt += 1;
+          }
+        }
+        throw lastError instanceof Error ? lastError : new Error(`${label} failed after retries`);
+      }
+      /**
+       * Extract file key from Figma URL
+       */
+      extractFileKey(url) {
+        const match = url.match(/figma\.com\/design\/([a-zA-Z0-9]+)/);
+        return match ? match[1] : null;
+      }
+      /**
+       * Extract node ID from Figma URL
+       */
+      extractNodeId(url) {
+        const match = url.match(/[?&]node-id=([^&]+)/);
+        if (!match) return null;
+        let nodeId = decodeURIComponent(match[1]);
+        if (nodeId.includes("-") && !nodeId.includes(":")) {
+          nodeId = nodeId.replace(/-/g, ":");
+        }
+        return nodeId;
+      }
+      /**
+       * Get Figma file data using API
+       */
+      async getFileData(url) {
+        const fileKey = this.extractFileKey(url);
+        if (!fileKey) {
+          throw new Error(`Invalid Figma URL: ${url}`);
+        }
+        const nodeId = this.extractNodeId(url);
+        const apiUrl = nodeId ? `https://api.figma.com/v1/files/${fileKey}/nodes?ids=${encodeURIComponent(nodeId)}` : `https://api.figma.com/v1/files/${fileKey}`;
+        const response = await this.fetchWithRetry(apiUrl, {
+          headers: {
+            "X-Figma-Token": this.apiKey
+          }
+        }, "Figma file fetch");
+        const data = await response.json();
+        if (nodeId) {
+          const nodes = data.nodes;
+          const nodeData = Object.values(nodes)[0];
+          if (!nodeData) {
+            throw new Error(`Node not found: ${nodeId}`);
+          }
+          return {
+            document: nodeData.document,
+            components: {},
+            styles: {}
+          };
+        }
+        return data;
+      }
+      /**
+       * Extract design tokens from Figma file
+       */
+      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}`);
         }
         const tokens = {
@@ -534,9 +928,9 @@ ${text}`);
         }, "Figma images listing");
         const imageData = await response.json();
         const images = imageData.images;
-        const fullAssetsDir = assetsDir.startsWith("/") ? assetsDir : join6(process.cwd(), assetsDir);
+        const fullAssetsDir = assetsDir.startsWith("/") ? assetsDir : join7(process.cwd(), assetsDir);
         if (!existsSync2(fullAssetsDir)) {
-          await mkdir3(fullAssetsDir, { recursive: true });
+          await mkdir4(fullAssetsDir, { recursive: true });
         }
         const downloadedAssets = [];
         for (const node of nodesToDownload) {
@@ -555,8 +949,8 @@ ${text}`);
             const safeName = node.name.replace(/[^a-z0-9]/gi, "_").toLowerCase().substring(0, 50);
             const extension = "png";
             const filename = `${safeName}_${node.id.substring(0, 8)}.${extension}`;
-            const filePath = join6(fullAssetsDir, filename);
-            await writeFile3(filePath, Buffer.from(imageBuffer));
+            const filePath = join7(fullAssetsDir, filename);
+            await writeFile4(filePath, Buffer.from(imageBuffer));
             downloadedAssets.push({
               nodeId: node.id,
               nodeName: node.name,
@@ -595,8 +989,8 @@ __export(figma_screen_developer_exports, {
   checkCurrentCodeStatus: () => checkCurrentCodeStatus,
   compareCodeWithFigma: () => compareCodeWithFigma
 });
-import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { join as join8 } from "path";
 import { existsSync as existsSync3 } from "fs";
 async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   const status = {
@@ -610,13 +1004,13 @@ async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   };
   try {
     const htmlFiles = ["index.html", "index.htm", "main.html"].filter(
-      (file) => existsSync3(join7(projectPath, file))
+      (file) => existsSync3(join8(projectPath, file))
     );
     if (htmlFiles.length > 0) {
       status.hasHTML = true;
       status.htmlFile = htmlFiles[0];
       try {
-        const htmlContent = await readFile4(join7(projectPath, htmlFiles[0]), "utf-8");
+        const htmlContent = await readFile5(join8(projectPath, htmlFiles[0]), "utf-8");
         const sectionMatches = htmlContent.match(/<(section|div|header|footer|main|article|aside)[^>]*(?:id|class)=["']([^"']+)["']/gi);
         if (sectionMatches) {
           status.sections = sectionMatches.map((match) => {
@@ -628,19 +1022,19 @@ async function checkCurrentCodeStatus(projectPath = process.cwd()) {
       } catch (e) {
       }
     }
-    const stylesDir = join7(projectPath, "styles");
+    const stylesDir = join8(projectPath, "styles");
     if (existsSync3(stylesDir)) {
       try {
         const files = await readdir3(stylesDir);
         const cssFiles = files.filter((f) => f.endsWith(".css"));
         if (cssFiles.length > 0) {
           status.hasCSS = true;
-          status.cssFiles = cssFiles.map((f) => join7(stylesDir, f));
+          status.cssFiles = cssFiles.map((f) => join8(stylesDir, f));
         }
       } catch (e) {
       }
     }
-    const assetsDir = join7(projectPath, "assets", "images");
+    const assetsDir = join8(projectPath, "assets", "images");
     if (existsSync3(assetsDir)) {
       try {
         const files = await readdir3(assetsDir);
@@ -713,217 +1107,394 @@ var init_figma_screen_developer = __esm({
   }
 });
 
-// src/core/memory.ts
-var memory_exports = {};
-__export(memory_exports, {
-  MemoryManager: () => MemoryManager
+// src/core/beads.ts
+var beads_exports = {};
+__export(beads_exports, {
+  BeadsIntegration: () => BeadsIntegration
 });
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir4, access as access2, constants as constants2 } from "fs/promises";
-import { join as join8 } from "path";
-var MemoryManager;
-var init_memory = __esm({
-  "src/core/memory.ts"() {
+import { readFile as readFile6, writeFile as writeFile5, readdir as readdir4, access as access3, constants as constants3, mkdir as mkdir5 } from "fs/promises";
+import { join as join9 } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync, BeadsIntegration;
+var init_beads = __esm({
+  "src/core/beads.ts"() {
     "use strict";
     init_esm_shims();
     init_paths();
-    MemoryManager = class {
-      config;
-      constructor(config) {
-        this.config = config;
+    init_logger();
+    execAsync = promisify(exec);
+    BeadsIntegration = class {
+      projectPath;
+      constructor(projectPath) {
+        this.projectPath = projectPath || process.cwd();
       }
       /**
-       * List all memory entries
+       * Check if Beads CLI is installed
        */
-      async list() {
-        const memories = [];
-        const memoryPath = paths.memory(this.config.configPath);
-        const subDirs = ["observations", "handoffs", "research"];
-        for (const subDir of subDirs) {
-          const dirPath = join8(memoryPath, subDir);
-          try {
-            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");
-              const summary = this.extractSummary(content);
-              memories.push({
-                key: `${subDir}/${file.replace(".md", "")}`,
-                content,
-                summary,
-                createdAt: /* @__PURE__ */ new Date(),
-                // Would get from file stats
-                updatedAt: /* @__PURE__ */ new Date(),
-                type: subDir
-              });
-            }
-          } catch {
-          }
+      async isInstalled() {
+        try {
+          await execAsync("bd --version");
+          return true;
+        } catch {
+          return false;
         }
-        return memories;
       }
       /**
-       * Read a memory entry
+       * Get Beads version
        */
-      async read(key) {
-        const memoryPath = paths.memory(this.config.configPath);
-        let filePath;
-        if (key.includes("/")) {
-          filePath = join8(memoryPath, `${key}.md`);
-        } else {
-          const subDirs = ["observations", "handoffs", "research", "_templates"];
-          for (const subDir of subDirs) {
-            const testPath = join8(memoryPath, subDir, `${key}.md`);
-            try {
-              await access2(testPath, constants2.R_OK);
-              filePath = testPath;
-              break;
-            } catch {
-              continue;
-            }
-          }
-          filePath = filePath || join8(memoryPath, `${key}.md`);
-        }
+      async getVersion() {
         try {
-          return await readFile5(filePath, "utf-8");
+          const { stdout } = await execAsync("bd --version");
+          const match = stdout.match(/bd version (\S+)/);
+          return match?.[1] || null;
         } catch {
           return null;
         }
       }
       /**
-       * Update a memory entry
+       * Check if Beads is initialized in project
        */
-      async update(key, content, options) {
-        const memoryPath = paths.memory(this.config.configPath);
-        const type = options?.type || "custom";
-        let filePath;
-        if (key.includes("/")) {
-          filePath = join8(memoryPath, `${key}.md`);
-        } else {
-          const subDir = type === "observation" ? "observations" : type === "handoff" ? "handoffs" : type === "research" ? "research" : "";
-          filePath = join8(memoryPath, subDir, `${key}.md`);
+      async isInitialized() {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        try {
+          await access3(beadsDir, constants3.R_OK);
+          return true;
+        } catch {
+          return false;
         }
-        const { dirname: dirname5 } = await import("path");
-        await mkdir4(dirname5(filePath), { recursive: true });
-        if (options?.append) {
-          try {
-            const existing = await readFile5(filePath, "utf-8");
-            const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-            content = `${existing}
-
----
-_Updated: ${timestamp}_
-
-${content}`;
-          } catch {
-          }
+      }
+      /**
+       * Install Beads CLI globally
+       */
+      async install() {
+        try {
+          await execAsync("npm install -g beads");
+          return true;
+        } catch (error) {
+          logger.error("Failed to install Beads CLI:", error);
+          return false;
         }
-        await writeFile4(filePath, content);
       }
       /**
-       * Create a handoff bundle
+       * Initialize Beads in project using bd CLI
        */
-      async createHandoff(summary) {
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const key = `handoffs/${timestamp}`;
-        const content = `# Handoff: ${(/* @__PURE__ */ new Date()).toLocaleString()}
-
-## Completed
-${summary.completed.map((item) => `- [x] ${item}`).join("\n") || "- None"}
+      async init() {
+        try {
+          await execAsync("bd init", { cwd: this.projectPath });
+          logger.success("Beads initialized");
+          return true;
+        } catch (error) {
+          logger.error("Failed to initialize Beads:", error);
+          return false;
+        }
+      }
+      /**
+       * Initialize local .beads directory (works without global beads CLI)
+       */
+      async initLocal() {
+        try {
+          const beadsDir = paths.beadsDir(this.projectPath);
+          await mkdir5(beadsDir, { recursive: true });
+          const readmeContent = `# Beads - Task Tracking
 
-## In Progress
-${summary.inProgress.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+This directory contains task beads for tracking work items.
 
-## Remaining
-${summary.remaining.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+## How it works
+- Each file is a task bead (bead-001.md, bead-002.md, etc.)
+- Status: todo, in-progress, completed, blocked
+- Use \`/create\` command to create new tasks
+- Use \`/finish\` command to complete tasks with quality gates
 
-## Context
-${summary.context || "No additional context."}
+## Beads CLI
+For full functionality, install beads globally:
+\`\`\`bash
+npm install -g beads
+bd init
+\`\`\`
 
-## Next Steps
-${summary.nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "- Continue from where left off"}
+## Available Commands
+- \`bd ready\` - Show available work
+- \`bd show <id>\` - View task details
+- \`bd update <id> --status in_progress\` - Update task status
+- \`bd close <id>\` - Complete task
+- \`bd sync\` - Sync with git
 `;
-        await this.update(key, content, { type: "handoff" });
-        return key;
+          await writeFile5(join9(beadsDir, "README.md"), readmeContent);
+          return true;
+        } catch (error) {
+          logger.error("Failed to initialize .beads directory:", error);
+          return false;
+        }
       }
       /**
-       * Get the latest handoff
+       * Get current status
        */
-      async getLatestHandoff() {
-        const memories = await this.list();
-        const handoffs = memories.filter((m) => m.type === "handoff");
-        if (handoffs.length === 0) return null;
-        handoffs.sort((a, b) => b.key.localeCompare(a.key));
-        return handoffs[0];
+      async getStatus() {
+        const installed = await this.isInstalled();
+        const version = await this.getVersion();
+        const initialized = await this.isInitialized();
+        let activeTasks = 0;
+        let completedTasks = 0;
+        let currentTask;
+        if (initialized) {
+          const beads = await this.listBeads();
+          activeTasks = beads.filter((b) => b.status === "in-progress" || b.status === "todo").length;
+          completedTasks = beads.filter((b) => b.status === "completed").length;
+          const active = beads.find((b) => b.status === "in-progress");
+          currentTask = active?.title;
+        }
+        return {
+          installed,
+          version: version || void 0,
+          initialized,
+          activeTasks,
+          completedTasks,
+          currentTask
+        };
       }
       /**
-       * Create an observation
+       * List all beads in project
        */
-      async createObservation(title, observation) {
-        const slug = title.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
-        const key = `observations/${slug}`;
-        const content = `# ${title}
-
-## What
-${observation.what}
-
-## Why
-${observation.why}
-
-## Impact
-${observation.impact}
-
-${observation.tags?.length ? `## Tags
-${observation.tags.map((t) => `- ${t}`).join("\n")}` : ""}
-
----
-_Created: ${(/* @__PURE__ */ new Date()).toISOString()}_
-`;
-        await this.update(key, content, { type: "observation" });
-        return key;
+      async listBeads() {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        const beads = [];
+        try {
+          const files = await readdir4(beadsDir);
+          for (const file of files) {
+            if (!file.match(/^bead-\d+\.md$/)) continue;
+            const content = await readFile6(join9(beadsDir, file), "utf-8");
+            const bead = this.parseBeadFile(file, content);
+            if (bead) beads.push(bead);
+          }
+        } catch {
+        }
+        return beads.sort((a, b) => a.id.localeCompare(b.id));
       }
       /**
-       * Save research findings
+       * Get a specific bead
        */
-      async saveResearch(topic, findings) {
-        const slug = topic.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
-        const key = `research/${slug}`;
-        const content = `# Research: ${topic}
-
-## Summary
-${findings.summary}
+      async getBead(id) {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        const fileName = id.endsWith(".md") ? id : `${id}.md`;
+        try {
+          const content = await readFile6(join9(beadsDir, fileName), "utf-8");
+          return this.parseBeadFile(fileName, content);
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Create a new bead
+       */
+      async createBead(title, description) {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        await mkdir5(beadsDir, { recursive: true });
+        const beads = await this.listBeads();
+        const maxId = beads.reduce((max, b) => {
+          const num = parseInt(b.id.replace("bead-", ""), 10);
+          return num > max ? num : max;
+        }, 0);
+        const id = `bead-${String(maxId + 1).padStart(3, "0")}`;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const content = `---
+id: ${id}
+title: ${title}
+status: in-progress
+created: ${now}
+updated: ${now}
+---
 
-## Sources
-${findings.sources.map((s) => `- ${s}`).join("\n")}
+# ${title}
 
-## Recommendations
-${findings.recommendations.map((r, i) => `${i + 1}. ${r}`).join("\n")}
+## Description
+${description}
 
-${findings.codeExamples ? `## Code Examples
-\`\`\`
-${findings.codeExamples}
-\`\`\`` : ""}
+## Notes
 
----
-_Researched: ${(/* @__PURE__ */ new Date()).toISOString()}_
 `;
-        await this.update(key, content, { type: "research" });
-        return key;
+        await writeFile5(join9(beadsDir, `${id}.md`), content);
+        return {
+          id,
+          title,
+          description,
+          status: "in-progress",
+          createdAt: new Date(now),
+          updatedAt: new Date(now),
+          notes: []
+        };
       }
       /**
-       * Extract a summary from content (first paragraph or heading)
+       * Update bead status
        */
-      extractSummary(content) {
-        const lines = content.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-          if (!line.startsWith("#") && line.trim().length > 0) {
-            return line.slice(0, 100) + (line.length > 100 ? "..." : "");
+      async updateBeadStatus(id, status) {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        const fileName = id.endsWith(".md") ? id : `${id}.md`;
+        const filePath = join9(beadsDir, fileName);
+        try {
+          let content = await readFile6(filePath, "utf-8");
+          content = content.replace(
+            /status:\s*\w+/,
+            `status: ${status}`
+          );
+          content = content.replace(
+            /updated:\s*.+/,
+            `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+          );
+          await writeFile5(filePath, content);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Add note to bead
+       */
+      async addNote(id, note) {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        const fileName = id.endsWith(".md") ? id : `${id}.md`;
+        const filePath = join9(beadsDir, fileName);
+        try {
+          let content = await readFile6(filePath, "utf-8");
+          const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
+          if (notesMatch) {
+            const timestamp = (/* @__PURE__ */ new Date()).toLocaleString();
+            const newNote = `- [${timestamp}] ${note}`;
+            content = content.replace(
+              notesMatch[0],
+              `## Notes
+${notesMatch[1]}${newNote}
+`
+            );
           }
+          content = content.replace(
+            /updated:\s*.+/,
+            `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+          );
+          await writeFile5(filePath, content);
+          return true;
+        } catch {
+          return false;
         }
-        if (lines[0]?.startsWith("#")) {
-          return lines[0].replace(/^#+\s*/, "");
+      }
+      /**
+       * Update bead type
+       */
+      async updateBeadType(id, type) {
+        const beadsDir = paths.beadsDir(this.projectPath);
+        const fileName = id.endsWith(".md") ? id : `${id}.md`;
+        const filePath = join9(beadsDir, fileName);
+        try {
+          let content = await readFile6(filePath, "utf-8");
+          const typeMatch = content.match(/^type:\s*.+/m);
+          if (typeMatch) {
+            content = content.replace(typeMatch[0], `type: ${type}`);
+          } else {
+            content = content.replace(/^---\n([\s\S]*?)\n---/, (match) => {
+              return match.replace(/^---\n/, `---
+type: ${type}
+`);
+            });
+          }
+          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;
         }
-        return "No summary available";
       }
     };
   }
@@ -1203,169 +1774,7 @@ import { Command } from "commander";
 
 // src/index.ts
 init_esm_shims();
-
-// src/core/config.ts
-init_esm_shims();
-init_paths();
-import { readFile, access, constants } from "fs/promises";
-import { join as join3 } from "path";
-import { z } from "zod";
-
-// src/utils/version.ts
-init_esm_shims();
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname, join as join2 } from "path";
-function getVersion() {
-  try {
-    const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = dirname(__filename2);
-    const packageJsonPath = join2(__dirname2, "..", "package.json");
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.version;
-  } catch (error) {
-    console.warn("Warning: Could not read version from package.json, using fallback");
-    return "0.0.0";
-  }
-}
-
-// src/core/config.ts
-var ConfigSchema = z.object({
-  version: z.string(),
-  skills: z.object({
-    enabled: z.boolean().default(true),
-    directory: z.string().optional()
-  }).default({}),
-  agents: z.object({
-    enabled: z.boolean().default(true),
-    default: z.string().default("build")
-  }).default({}),
-  commands: z.object({
-    enabled: z.boolean().default(true)
-  }).default({}),
-  tools: z.object({
-    enabled: z.boolean().default(true)
-  }).default({}),
-  plugins: z.object({
-    enabled: z.boolean().default(true),
-    autoload: z.array(z.string()).optional()
-  }).default({}),
-  memory: z.object({
-    enabled: z.boolean().default(true),
-    maxSize: z.number().optional()
-  }).default({}),
-  beads: z.object({
-    enabled: z.boolean().default(true),
-    autoInit: z.boolean().default(false)
-  }).default({}),
-  antiHallucination: z.object({
-    enabled: z.boolean().default(true),
-    specFile: z.string().default("spec.md"),
-    reviewFile: z.string().default("review.md")
-  }).default({}),
-  mcp: z.object({
-    context7: z.boolean().default(false),
-    githubGrep: z.boolean().default(false),
-    gkg: z.boolean().default(false)
-  }).optional(),
-  mode: z.string().default("build").optional()
-});
-var Config = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  get() {
-    return this.config;
-  }
-  get skills() {
-    return this.config.skills;
-  }
-  get agents() {
-    return this.config.agents;
-  }
-  get commands() {
-    return this.config.commands;
-  }
-  get tools() {
-    return this.config.tools;
-  }
-  get plugins() {
-    return this.config.plugins;
-  }
-  get memory() {
-    return this.config.memory;
-  }
-  get beads() {
-    return this.config.beads;
-  }
-  get antiHallucination() {
-    return this.config.antiHallucination;
-  }
-  get mode() {
-    return this.config.mode;
-  }
-  get configPath() {
-    return this.config.configPath;
-  }
-  get projectPath() {
-    return this.config.projectPath;
-  }
-  /**
-   * Get path to a specific resource
-   */
-  getPath(resource) {
-    return paths[resource](this.configPath);
-  }
-};
-async function loadConfig(projectPath) {
-  const project = projectPath || process.cwd();
-  const projectConfigPath = paths.projectConfig(project);
-  const globalConfigPath = paths.globalConfig();
-  let configPath;
-  let configData = {};
-  try {
-    await access(join3(globalConfigPath, "aikit.json"), constants.R_OK);
-    const globalContent = await readFile(join3(globalConfigPath, "aikit.json"), "utf-8");
-    configData = JSON.parse(globalContent);
-    configPath = globalConfigPath;
-  } catch {
-    configPath = projectConfigPath;
-  }
-  try {
-    await access(join3(projectConfigPath, "aikit.json"), constants.R_OK);
-    const projectContent = await readFile(join3(projectConfigPath, "aikit.json"), "utf-8");
-    const projectData = JSON.parse(projectContent);
-    configData = deepMerge(configData, projectData);
-    configPath = projectConfigPath;
-  } catch {
-  }
-  if (!configData.version) {
-    configData.version = getVersion();
-  }
-  const parsed = ConfigSchema.parse(configData);
-  return new Config({
-    ...parsed,
-    configPath,
-    projectPath: project
-  });
-}
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key in override) {
-    const baseValue = base[key];
-    const overrideValue = override[key];
-    if (typeof baseValue === "object" && baseValue !== null && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(baseValue) && !Array.isArray(overrideValue)) {
-      result[key] = deepMerge(
-        baseValue,
-        overrideValue
-      );
-    } else if (overrideValue !== void 0) {
-      result[key] = overrideValue;
-    }
-  }
-  return result;
-}
+init_config();
 
 // src/core/skills.ts
 init_esm_shims();
@@ -2813,8 +3222,8 @@ ${command.content}
 init_esm_shims();
 init_paths();
 init_logger();
-import { readdir as readdir4, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { join as join9, extname as extname3 } from "path";
+import { readdir as readdir5, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { join as join10, extname as extname3 } from "path";
 import { z as z2 } from "zod";
 var ToolArgSchema = z2.object({
   type: z2.enum(["string", "number", "boolean", "array", "object"]),
@@ -2877,8 +3286,28 @@ Note: Configure GitHub integration in AIKit settings for actual results.`;
         required: true
       }
     },
-    async execute({ key }) {
-      return `Memory read: ${key}`;
+    async execute({ key }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        const content = await memory.read(key);
+        if (!content) {
+          return `Memory entry not found: ${key}
+
+Available keys (use \`list_session\` or \`aikit memory list\`):
+- handoffs/
+- observations/
+- research/
+- _templates/`;
+        }
+        return content;
+      } catch (error) {
+        return `Error reading memory: ${error instanceof Error ? error.message : String(error)}`;
+      }
     }
   },
   {
@@ -2902,8 +3331,22 @@ Note: Configure GitHub integration in AIKit settings for actual results.`;
         default: true
       }
     },
-    async execute({ key, append = true }) {
-      return `Memory updated: ${key} (append: ${append})`;
+    async execute({ key, content, append = true }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      if (typeof content !== "string") {
+        return "Error: content must be a string";
+      }
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        await memory.update(key, content, { append });
+        return `\u2713 Saved to memory: ${key}${append ? " (appended)" : " (overwrote)"}`;
+      } catch (error) {
+        return `Error updating memory: ${error instanceof Error ? error.message : String(error)}`;
+      }
     }
   },
   {
@@ -3276,7 +3719,7 @@ ${tokens.screens?.map((s, i) => `${i + 1}. ${s.name} (ID: ${s.id})`).join("\n")
           try {
             const fileData = await client.getFileData(figmaUrl);
             const projectPath = process.cwd();
-            const assetsDir = join9(projectPath, "assets", "images");
+            const assetsDir = join10(projectPath, "assets", "images");
             const assets = await client.downloadAssets(fileKey, fileData.document, assetsDir, selectedScreen.id);
             downloadedAssets = assets || [];
             logger.info(`Downloaded ${downloadedAssets.length} assets for screen ${selectedScreen.name}`);
@@ -3368,91 +3811,318 @@ ${tokens.screens?.map((s, i) => `${i + 1}. ${s.name} (ID: ${s.id})`).join("\n")
 `;
         result += `5. Verify pixel-perfect match with Figma design
 `;
-        return result;
+        return result;
+      } catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "list_session",
+    description: "List previous sessions to discover what happened and when. Use this before read_session to find the right context.",
+    args: {
+      limit: {
+        type: "number",
+        description: "Maximum number of sessions to return (default: 10)",
+        required: false,
+        default: 10
+      }
+    },
+    async execute({ limit = 10 }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      const limitNum = typeof limit === "number" ? limit : 10;
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        const memories = await memory.list();
+        const handoffs = memories.filter((m) => m.type === "handoff").sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, limitNum);
+        if (handoffs.length === 0) {
+          return "No previous sessions found. Use /handoff to create a session handoff.";
+        }
+        let result = `# Previous Sessions (${handoffs.length})
+
+`;
+        handoffs.forEach((handoff, index) => {
+          const sessionId = handoff.key.replace("handoffs/", "");
+          result += `${index + 1}. **${sessionId}**
+`;
+          result += `   - Updated: ${handoff.updatedAt.toLocaleString()}
+`;
+          result += `   - Summary: ${handoff.summary}
+
+`;
+        });
+        result += `
+Use \`read_session\` with a session ID to load full context.`;
+        return result;
+      } catch (error) {
+        return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "read_session",
+    description: "Load context from a previous session. Returns session summary, user tasks, and file changes.",
+    args: {
+      sessionId: {
+        type: "string",
+        description: 'Session ID from list_session (e.g., "2024-01-15T10-30-00")',
+        required: true
+      }
+    },
+    async execute({ sessionId }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        const content = await memory.read(`handoffs/${sessionId}`);
+        if (!content) {
+          return `Session not found: ${sessionId}
+
+Use \`list_session\` to see available sessions.`;
+        }
+        return `# Session Context: ${sessionId}
+
+${content}
+
+---
+
+This context has been loaded. Use /resume to continue from this point.`;
+      } catch (error) {
+        return `Error reading session: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "bead-create",
+    description: "Create a new bead/task for tracking work",
+    args: {
+      title: {
+        type: "string",
+        description: "Title of bead/task",
+        required: true
+      },
+      description: {
+        type: "string",
+        description: "Description of what needs to be done",
+        required: true
+      }
+    },
+    async execute({ title, description }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      if (typeof title !== "string" || typeof description !== "string") {
+        return "Error: title and description must be strings";
+      }
+      try {
+        const { BeadsIntegration: BeadsIntegration2 } = await Promise.resolve().then(() => (init_beads(), beads_exports));
+        const beads = new BeadsIntegration2(config.projectPath);
+        const bead = await beads.createBead(title, description);
+        return `\u2713 Created bead: ${bead.id}
+
+Title: ${bead.title}
+Description: ${description}
+
+Use \`bead-update-status\` to change status or \`bead-complete\` to finish with quality gates.`;
+      } catch (error) {
+        return `Error creating bead: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "bead-update-status",
+    description: "Update bead status (todo, in-progress, completed, blocked)",
+    args: {
+      id: {
+        type: "string",
+        description: 'Bead ID (e.g., "bead-001")',
+        required: true
+      },
+      status: {
+        type: "string",
+        description: "New status: todo, in-progress, completed, blocked",
+        required: true
+      }
+    },
+    async execute({ id, status }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      if (typeof id !== "string" || typeof status !== "string") {
+        return "Error: id and status must be strings";
+      }
+      const validStatuses = ["todo", "in-progress", "completed", "blocked"];
+      if (!validStatuses.includes(status)) {
+        return `Error: Invalid status "${status}". Valid statuses: ${validStatuses.join(", ")}`;
+      }
+      try {
+        const { BeadsIntegration: BeadsIntegration2 } = await Promise.resolve().then(() => (init_beads(), beads_exports));
+        const beads = new BeadsIntegration2(config.projectPath);
+        const success = await beads.updateBeadStatus(id, status);
+        if (success) {
+          return `\u2713 Updated bead ${id} to status: ${status}`;
+        } else {
+          return `Error: Bead ${id} not found`;
+        }
+      } catch (error) {
+        return `Error updating bead status: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "bead-complete",
+    description: "Complete a bead with quality gates (typecheck, test, lint, build)",
+    args: {
+      id: {
+        type: "string",
+        description: 'Bead ID (e.g., "bead-001")',
+        required: true
+      }
+    },
+    async execute({ id }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      if (typeof id !== "string") {
+        return "Error: id must be a string";
+      }
+      try {
+        const { BeadsIntegration: BeadsIntegration2 } = await Promise.resolve().then(() => (init_beads(), beads_exports));
+        const beads = new BeadsIntegration2(config.projectPath);
+        const result = await beads.completeBead(id);
+        if (!result.success) {
+          let errorReport = `\u274C Quality gates failed for bead ${id}:
+
+`;
+          result.gates.forEach((gate) => {
+            const status = gate.passed ? "\u2713" : "\u2717";
+            errorReport += `${status} ${gate.name}`;
+            if (gate.error) {
+              errorReport += `
+  Error: ${gate.error}`;
+            }
+            errorReport += "\n";
+          });
+          return errorReport;
+        }
+        return `\u2713 Bead ${id} completed successfully!
+
+All quality gates passed:
+${result.gates.map((g) => `  \u2713 ${g.name}`).join("\n")}`;
       } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+        return `Error completing bead: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
   },
   {
-    name: "list_session",
-    description: "List previous sessions to discover what happened and when. Use this before read_session to find the right context.",
+    name: "bead-list",
+    description: "List all beads in the project",
     args: {
-      limit: {
-        type: "number",
-        description: "Maximum number of sessions to return (default: 10)",
-        required: false,
-        default: 10
+      filter: {
+        type: "string",
+        description: "Filter by status: todo, in-progress, completed, blocked (optional)",
+        required: false
       }
     },
-    async execute({ limit = 10 }, context) {
+    async execute({ filter }, context) {
       const config = context?.config;
       if (!config) {
         return "Error: Configuration not available";
       }
-      const limitNum = typeof limit === "number" ? limit : 10;
+      if (filter !== void 0 && typeof filter !== "string") {
+        return "Error: filter must be a string";
+      }
       try {
-        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
-        const memory = new MemoryManager2(config);
-        const memories = await memory.list();
-        const handoffs = memories.filter((m) => m.type === "handoff").sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, limitNum);
-        if (handoffs.length === 0) {
-          return "No previous sessions found. Use /handoff to create a session handoff.";
+        const { BeadsIntegration: BeadsIntegration2 } = await Promise.resolve().then(() => (init_beads(), beads_exports));
+        const beads = new BeadsIntegration2(config.projectPath);
+        const allBeads = await beads.listBeads();
+        let filtered = allBeads;
+        if (filter && ["todo", "in-progress", "completed", "blocked"].includes(filter)) {
+          filtered = allBeads.filter((b) => b.status === filter);
         }
-        let result = `# Previous Sessions (${handoffs.length})
+        if (filtered.length === 0) {
+          return `No beads found${filter ? ` with status "${filter}"` : ""}`;
+        }
+        let result = `# Beads (${filtered.length})
 
 `;
-        handoffs.forEach((handoff, index) => {
-          const sessionId = handoff.key.replace("handoffs/", "");
-          result += `${index + 1}. **${sessionId}**
+        filtered.forEach((bead) => {
+          const statusEmoji = {
+            "todo": "\u23F8\uFE0F",
+            "in-progress": "\u{1F504}",
+            "completed": "\u2705",
+            "blocked": "\u{1F6AB}"
+          }[bead.status] || "\u2753";
+          result += `${statusEmoji} **${bead.id}**: ${bead.title}
 `;
-          result += `   - Updated: ${handoff.updatedAt.toLocaleString()}
+          result += `   Status: ${bead.status}
 `;
-          result += `   - Summary: ${handoff.summary}
-
+          result += `   Updated: ${bead.updatedAt.toLocaleString()}
 `;
+          if (bead.description) {
+            const desc = bead.description.length > 100 ? bead.description.slice(0, 100) + "..." : bead.description;
+            result += `   Description: ${desc}
+`;
+          }
+          result += "\n";
         });
-        result += `
-Use \`read_session\` with a session ID to load full context.`;
-        return result;
+        return result.trim();
       } catch (error) {
-        return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
+        return `Error listing beads: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
   },
   {
-    name: "read_session",
-    description: "Load context from a previous session. Returns session summary, user tasks, and file changes.",
+    name: "bead-update-type",
+    description: "Update the type of an existing bead (feature, pattern, decision, knowledge)",
     args: {
-      sessionId: {
+      id: {
         type: "string",
-        description: 'Session ID from list_session (e.g., "2024-01-15T10-30-00")',
+        description: 'Bead ID (e.g., "bead-001")',
+        required: true
+      },
+      type: {
+        type: "string",
+        description: "New type: feature, pattern, decision, or knowledge",
         required: true
       }
     },
-    async execute({ sessionId }, context) {
+    async execute({ id, type }, context) {
       const config = context?.config;
       if (!config) {
         return "Error: Configuration not available";
       }
+      if (typeof id !== "string") {
+        return "Error: id must be a string";
+      }
+      if (typeof type !== "string") {
+        return "Error: type must be a string";
+      }
+      const validTypes = ["feature", "pattern", "decision", "knowledge"];
+      if (!validTypes.includes(type)) {
+        return `Error: Invalid type "${type}". Valid types: ${validTypes.join(", ")}`;
+      }
       try {
-        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
-        const memory = new MemoryManager2(config);
-        const content = await memory.read(`handoffs/${sessionId}`);
-        if (!content) {
-          return `Session not found: ${sessionId}
-
-Use \`list_session\` to see available sessions.`;
+        const { BeadsIntegration: BeadsIntegration2 } = await Promise.resolve().then(() => (init_beads(), beads_exports));
+        const beads = new BeadsIntegration2(config.projectPath);
+        const success = await beads.updateBeadType(id, type);
+        if (success) {
+          return `\u2713 Updated bead ${id} type to: ${type}`;
+        } else {
+          return `Error: Bead ${id} not found`;
         }
-        return `# Session Context: ${sessionId}
-
-${content}
-
----
-
-This context has been loaded. Use /resume to continue from this point.`;
       } catch (error) {
-        return `Error reading session: ${error instanceof Error ? error.message : String(error)}`;
+        return `Error updating bead type: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
   }
@@ -3507,6 +4177,7 @@ var ToolRegistry = class {
     }
     const mergedContext = {
       ...context,
+      config: this.config,
       toolConfigManager: context?.toolConfigManager || this.toolConfigManager
     };
     if (tool.execute.length === 2) {
@@ -3520,9 +4191,9 @@ var ToolRegistry = class {
   async createTool(name, options) {
     const configPath = options.global ? paths.globalConfig() : this.config.configPath;
     const toolsDir = paths.tools(configPath);
-    await mkdir5(toolsDir, { recursive: true });
+    await mkdir6(toolsDir, { recursive: true });
     const fileName = `${name}.ts`;
-    const filePath = join9(toolsDir, fileName);
+    const filePath = join10(toolsDir, fileName);
     const argsSchema = Object.entries(options.args).map(([argName, arg]) => `    ${argName}: {
       type: '${arg.type}',
       description: '${arg.description}',
@@ -3541,7 +4212,7 @@ ${options.code}
   }
 });
 `;
-    await writeFile5(filePath, content);
+    await writeFile6(filePath, content);
   }
   /**
    * Format tool for agent consumption
@@ -3570,13 +4241,13 @@ ${argsDesc}
   async loadToolsFromDir(dir) {
     let files;
     try {
-      files = await readdir4(dir);
+      files = await readdir5(dir);
     } catch {
       return;
     }
     for (const file of files) {
       if (extname3(file) !== ".ts" && extname3(file) !== ".js") continue;
-      const filePath = join9(dir, file);
+      const filePath = join10(dir, file);
       try {
         const toolModule = await import(`file://${filePath}`);
         const tool = toolModule.default;
@@ -3595,8 +4266,8 @@ ${argsDesc}
 init_esm_shims();
 init_paths();
 init_logger();
-import { readdir as readdir5, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import { join as join10, basename as basename3, extname as extname4 } from "path";
+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";
 var PluginSystem = class {
   config;
   plugins = /* @__PURE__ */ new Map();
@@ -3694,9 +4365,9 @@ var PluginSystem = class {
   async createPlugin(name, options) {
     const configPath = options.global ? paths.globalConfig() : this.config.configPath;
     const pluginsDir = paths.plugins(configPath);
-    await mkdir6(pluginsDir, { recursive: true });
+    await mkdir7(pluginsDir, { recursive: true });
     const fileName = `${name}.ts`;
-    const filePath = join10(pluginsDir, fileName);
+    const filePath = join11(pluginsDir, fileName);
     const content = `import { Plugin } from 'aikit';
 
 /**
@@ -3712,7 +4383,7 @@ ${options.code}
 
 export default ${toPascalCase(name)}Plugin;
 `;
-    await writeFile6(filePath, content);
+    await writeFile7(filePath, content);
   }
   /**
    * Process event queue
@@ -3780,13 +4451,13 @@ export default ${toPascalCase(name)}Plugin;
   async loadPluginsFromDir(dir) {
     let files;
     try {
-      files = await readdir5(dir);
+      files = await readdir6(dir);
     } catch {
       return;
     }
     for (const file of files) {
       if (extname4(file) !== ".ts" && extname4(file) !== ".js") continue;
-      const filePath = join10(dir, file);
+      const filePath = join11(dir, file);
       const name = basename3(file, extname4(file));
       this.plugins.set(name, {
         name,
@@ -3887,355 +4558,7 @@ function toPascalCase(str) {
 
 // src/index.ts
 init_memory();
-
-// src/core/beads.ts
-init_esm_shims();
-init_paths();
-init_logger();
-import { readFile as readFile6, writeFile as writeFile7, readdir as readdir6, access as access3, constants as constants3, mkdir as mkdir7 } from "fs/promises";
-import { join as join11 } from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var BeadsIntegration = class {
-  projectPath;
-  constructor(projectPath) {
-    this.projectPath = projectPath || process.cwd();
-  }
-  /**
-   * Check if Beads CLI is installed
-   */
-  async isInstalled() {
-    try {
-      await execAsync("bd --version");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get Beads version
-   */
-  async getVersion() {
-    try {
-      const { stdout } = await execAsync("bd --version");
-      const match = stdout.match(/bd version (\S+)/);
-      return match?.[1] || null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Check if Beads is initialized in project
-   */
-  async isInitialized() {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    try {
-      await access3(beadsDir, constants3.R_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Install Beads CLI globally
-   */
-  async install() {
-    try {
-      await execAsync("npm install -g beads");
-      return true;
-    } catch (error) {
-      logger.error("Failed to install Beads CLI:", error);
-      return false;
-    }
-  }
-  /**
-   * Initialize Beads in project using bd CLI
-   */
-  async init() {
-    try {
-      await execAsync("bd init", { cwd: this.projectPath });
-      logger.success("Beads initialized");
-      return true;
-    } catch (error) {
-      logger.error("Failed to initialize Beads:", error);
-      return false;
-    }
-  }
-  /**
-   * Initialize local .beads directory (works without global beads CLI)
-   */
-  async initLocal() {
-    try {
-      const beadsDir = paths.beadsDir(this.projectPath);
-      await mkdir7(beadsDir, { recursive: true });
-      const readmeContent = `# Beads - Task Tracking
-
-This directory contains task beads for tracking work items.
-
-## How it works
-- Each file is a task bead (bead-001.md, bead-002.md, etc.)
-- Status: todo, in-progress, completed, blocked
-- Use \`/create\` command to create new tasks
-- Use \`/finish\` command to complete tasks with quality gates
-
-## Beads CLI
-For full functionality, install beads globally:
-\`\`\`bash
-npm install -g beads
-bd init
-\`\`\`
-
-## Available Commands
-- \`bd ready\` - Show available work
-- \`bd show <id>\` - View task details
-- \`bd update <id> --status in_progress\` - Update task status
-- \`bd close <id>\` - Complete task
-- \`bd sync\` - Sync with git
-`;
-      await writeFile7(join11(beadsDir, "README.md"), readmeContent);
-      return true;
-    } catch (error) {
-      logger.error("Failed to initialize .beads directory:", error);
-      return false;
-    }
-  }
-  /**
-   * Get current status
-   */
-  async getStatus() {
-    const installed = await this.isInstalled();
-    const version = await this.getVersion();
-    const initialized = await this.isInitialized();
-    let activeTasks = 0;
-    let completedTasks = 0;
-    let currentTask;
-    if (initialized) {
-      const beads = await this.listBeads();
-      activeTasks = beads.filter((b) => b.status === "in-progress" || b.status === "todo").length;
-      completedTasks = beads.filter((b) => b.status === "completed").length;
-      const active = beads.find((b) => b.status === "in-progress");
-      currentTask = active?.title;
-    }
-    return {
-      installed,
-      version: version || void 0,
-      initialized,
-      activeTasks,
-      completedTasks,
-      currentTask
-    };
-  }
-  /**
-   * List all beads in the project
-   */
-  async listBeads() {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    const beads = [];
-    try {
-      const files = await readdir6(beadsDir);
-      for (const file of files) {
-        if (!file.match(/^bead-\d+\.md$/)) continue;
-        const content = await readFile6(join11(beadsDir, file), "utf-8");
-        const bead = this.parseBeadFile(file, content);
-        if (bead) beads.push(bead);
-      }
-    } catch {
-    }
-    return beads.sort((a, b) => a.id.localeCompare(b.id));
-  }
-  /**
-   * Get a specific bead
-   */
-  async getBead(id) {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    const fileName = id.endsWith(".md") ? id : `${id}.md`;
-    try {
-      const content = await readFile6(join11(beadsDir, fileName), "utf-8");
-      return this.parseBeadFile(fileName, content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Create a new bead
-   */
-  async createBead(title, description) {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    await mkdir7(beadsDir, { recursive: true });
-    const beads = await this.listBeads();
-    const maxId = beads.reduce((max, b) => {
-      const num = parseInt(b.id.replace("bead-", ""), 10);
-      return num > max ? num : max;
-    }, 0);
-    const id = `bead-${String(maxId + 1).padStart(3, "0")}`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const content = `---
-id: ${id}
-title: ${title}
-status: in-progress
-created: ${now}
-updated: ${now}
----
-
-# ${title}
-
-## Description
-${description}
-
-## Notes
-
-
-## Checklist
-- [ ] Requirements understood
-- [ ] Implementation complete
-- [ ] Tests passing
-- [ ] Code reviewed
-
-## Progress
-
-`;
-    await writeFile7(join11(beadsDir, `${id}.md`), content);
-    return {
-      id,
-      title,
-      description,
-      status: "in-progress",
-      createdAt: new Date(now),
-      updatedAt: new Date(now),
-      notes: []
-    };
-  }
-  /**
-   * Update bead status
-   */
-  async updateBeadStatus(id, status) {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    const fileName = id.endsWith(".md") ? id : `${id}.md`;
-    const filePath = join11(beadsDir, fileName);
-    try {
-      let content = await readFile6(filePath, "utf-8");
-      content = content.replace(
-        /status:\s*\w+/,
-        `status: ${status}`
-      );
-      content = content.replace(
-        /updated:\s*.+/,
-        `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
-      );
-      await writeFile7(filePath, content);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Add note to bead
-   */
-  async addNote(id, note) {
-    const beadsDir = paths.beadsDir(this.projectPath);
-    const fileName = id.endsWith(".md") ? id : `${id}.md`;
-    const filePath = join11(beadsDir, fileName);
-    try {
-      let content = await readFile6(filePath, "utf-8");
-      const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
-      if (notesMatch) {
-        const timestamp = (/* @__PURE__ */ new Date()).toLocaleString();
-        const newNote = `- [${timestamp}] ${note}`;
-        content = content.replace(
-          notesMatch[0],
-          `## Notes
-${notesMatch[1]}${newNote}
-`
-        );
-      }
-      content = content.replace(
-        /updated:\s*.+/,
-        `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
-      );
-      await writeFile7(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");
-    } else {
-      await this.addNote(id, "Completion attempted but quality gates failed");
-    }
-    return {
-      success: allPassed,
-      gates: results
-    };
-  }
-  /**
-   * 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());
-      return {
-        id,
-        title,
-        description,
-        status: getValue("status") || "todo",
-        createdAt: new Date(getValue("created") || Date.now()),
-        updatedAt: new Date(getValue("updated") || Date.now()),
-        notes
-      };
-    } catch {
-      return null;
-    }
-  }
-};
+init_beads();
 
 // src/core/anti-hallucination.ts
 init_esm_shims();
@@ -4244,14 +4567,17 @@ init_logger();
 // src/index.ts
 init_logger();
 init_paths();
+init_version();
 
 // src/cli/commands/index.ts
 init_esm_shims();
 
 // src/cli/commands/init.ts
 init_esm_shims();
+init_config();
 import chalk2 from "chalk";
 import inquirer from "inquirer";
+init_beads();
 
 // src/utils/cli-detector.ts
 init_esm_shims();
@@ -4380,6 +4706,7 @@ import { join as join13, dirname as dirname2 } from "path";
 import { homedir as homedir3 } 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) {
@@ -4986,6 +5313,7 @@ function registerInstallCommand(program2) {
 
 // src/cli/commands/sync.ts
 init_esm_shims();
+init_config();
 import chalk4 from "chalk";
 
 // src/core/sync-engine.ts
@@ -6066,6 +6394,7 @@ function registerSyncCommand(program2) {
 
 // src/cli/commands/skills.ts
 init_esm_shims();
+init_config();
 import chalk5 from "chalk";
 init_logger();
 function registerSkillsCommand(program2) {
@@ -6229,7 +6558,9 @@ init_esm_shims();
 import chalk6 from "chalk";
 import { readFile as readFile13, writeFile as writeFile14 } from "fs/promises";
 import { join as join19 } from "path";
+init_config();
 init_memory();
+init_beads();
 init_logger();
 function registerAgentsCommand(program2) {
   const agentsCmd = program2.command("agents").description("Manage agents");