@pikaa-ai/pikaa 0.3.14 → 0.3.16

package/dist/index.js

@@ -1119,17 +1119,139 @@ class ExecutionPolicyError extends GroupyError {
   }
 }
 // src/auth/store.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/config/paths.ts
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { resolve, join } from "path";
 import { homedir } from "os";
+function getPikaaHomeDir() {
+  const envDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME;
+  if (envDir) {
+    return resolve(envDir);
+  }
+  return resolve(homedir(), ".pikaa");
+}
+function getLegacyGroupyHomeDir() {
+  if (process.env.GROUPY_HOME) {
+    return resolve(process.env.GROUPY_HOME);
+  }
+  return resolve(homedir(), ".groupy");
+}
+var hasMigrated = false;
+function copyDirRecursiveSync(src, dest) {
+  if (!existsSync(src))
+    return;
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursiveSync(srcPath, destPath);
+    } else if (!existsSync(destPath)) {
+      try {
+        copyFileSync(srcPath, destPath);
+      } catch {}
+    }
+  }
+}
+function ensurePikaaHomeMigrated(force = false) {
+  const pikaaHome = getPikaaHomeDir();
+  const legacyHome = getLegacyGroupyHomeDir();
+  try {
+    if (!existsSync(pikaaHome)) {
+      mkdirSync(pikaaHome, { recursive: true });
+    }
+  } catch {}
+  if (hasMigrated && !force) {
+    return pikaaHome;
+  }
+  hasMigrated = true;
+  try {
+    if (existsSync(legacyHome) && legacyHome !== pikaaHome) {
+      const legacyCreds = join(legacyHome, "credentials.json");
+      const pikaaCreds = join(pikaaHome, "credentials.json");
+      if (existsSync(legacyCreds) && !existsSync(pikaaCreds)) {
+        copyFileSync(legacyCreds, pikaaCreds);
+      }
+      const legacyThreads = join(legacyHome, "groupy_threads.db");
+      const pikaaThreads = join(pikaaHome, "pikaa_threads.db");
+      if (existsSync(legacyThreads) && !existsSync(pikaaThreads)) {
+        copyFileSync(legacyThreads, pikaaThreads);
+      }
+      const legacyRules = join(legacyHome, "groupy_rules.db");
+      const pikaaRules = join(pikaaHome, "pikaa_rules.db");
+      if (existsSync(legacyRules) && !existsSync(pikaaRules)) {
+        copyFileSync(legacyRules, pikaaRules);
+      }
+      const legacyGraph = join(legacyHome, "agent_graph.db");
+      const pikaaGraph = join(pikaaHome, "agent_graph.db");
+      if (existsSync(legacyGraph) && !existsSync(pikaaGraph)) {
+        copyFileSync(legacyGraph, pikaaGraph);
+      }
+      const legacyMemories = join(legacyHome, "memories.md");
+      const pikaaMemories = join(pikaaHome, "memories.md");
+      if (existsSync(legacyMemories) && !existsSync(pikaaMemories)) {
+        copyFileSync(legacyMemories, pikaaMemories);
+      }
+      copyDirRecursiveSync(join(legacyHome, "skills"), join(pikaaHome, "skills"));
+      copyDirRecursiveSync(join(legacyHome, "templates"), join(pikaaHome, "templates"));
+    }
+  } catch {}
+  return pikaaHome;
+}
+function getCredentialsPath() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "credentials.json");
+}
+function getThreadsDbPath() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "pikaa_threads.db");
+}
+function getPrefixRulesDbPath() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "pikaa_rules.db");
+}
+function getAgentGraphDbPath() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "agent_graph.db");
+}
+function getGlobalSkillsDir() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "skills");
+}
+function getGlobalTemplatesDir() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "templates");
+}
+function getGlobalMemoriesPath() {
+  ensurePikaaHomeMigrated();
+  return join(getPikaaHomeDir(), "memories.md");
+}
+function getProjectsDir() {
+  ensurePikaaHomeMigrated();
+  const dir = join(getPikaaHomeDir(), "projects");
+  if (!existsSync(dir)) {
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch {}
+  }
+  return dir;
+}
 
+// src/auth/store.ts
 class CredentialsStore {
   filePath;
   constructor(customPath) {
-    this.filePath = customPath || resolve(homedir(), ".groupy", "credentials.json");
+    this.filePath = customPath || getCredentialsPath();
   }
   load() {
-    if (!existsSync(this.filePath))
+    if (!existsSync2(this.filePath))
       return null;
     try {
       const raw = readFileSync(this.filePath, "utf8");
@@ -1160,14 +1282,14 @@ class CredentialsStore {
     return creds?.user;
   }
   save(credentials) {
-    const dir = resolve(this.filePath, "..");
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+    const dir = resolve2(this.filePath, "..");
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
     writeFileSync(this.filePath, JSON.stringify(credentials, null, 2), "utf8");
   }
   clear() {
-    if (existsSync(this.filePath)) {
+    if (existsSync2(this.filePath)) {
       try {
         unlinkSync(this.filePath);
         return true;
@@ -1616,9 +1738,9 @@ class ToolRouter {
   }
 }
 // src/tools/handlers/apply-patch.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3, dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
 var applyPatchTool = {
   name: "apply_patch",
   description: "Apply precise multi-line modifications to an existing file or create a new file. TargetContent must match the file content exactly.",
@@ -1645,7 +1767,7 @@ var applyPatchTool = {
     if (!rawPath) {
       return { output: "Error: 'path' parameter is required", isError: true };
     }
-    const filePath = resolve2(ctx.cwd, rawPath);
+    const filePath = resolve3(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
     if (ctx.execPolicy) {
@@ -1664,7 +1786,7 @@ var applyPatchTool = {
         }
       }
     }
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       if (targetContent) {
         return {
           output: `Error: Target file '${rawPath}' does not exist, but targetContent was provided.`,
@@ -1672,7 +1794,7 @@ var applyPatchTool = {
         };
       }
       try {
-        mkdirSync2(dirname(filePath), { recursive: true });
+        mkdirSync3(dirname2(filePath), { recursive: true });
         writeFileSync2(filePath, replacementContent, "utf8");
         return { output: `Successfully created new file '${rawPath}'` };
       } catch (err) {
@@ -1879,7 +2001,7 @@ class WindowsSandbox {
 }
 
 // src/security/kernel/linux.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 class LinuxSandbox {
   hasBwrap = false;
@@ -1890,7 +2012,7 @@ class LinuxSandbox {
     if (process.platform !== "linux") {
       return;
     }
-    this.hasBwrap = existsSync3("/usr/bin/bwrap") || existsSync3("/bin/bwrap") || existsSync3("/usr/local/bin/bwrap");
+    this.hasBwrap = existsSync4("/usr/bin/bwrap") || existsSync4("/bin/bwrap") || existsSync4("/usr/local/bin/bwrap");
   }
   wrapCommand(cmd, profile) {
     if (!this.hasBwrap || profile.kind === "danger-unrestricted") {
@@ -1924,7 +2046,7 @@ class LinuxSandbox {
 }
 
 // src/security/kernel/macos.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 
 class MacOSSandbox {
   hasSandboxExec = false;
@@ -1935,7 +2057,7 @@ class MacOSSandbox {
     if (process.platform !== "darwin") {
       return;
     }
-    this.hasSandboxExec = existsSync4("/usr/bin/sandbox-exec");
+    this.hasSandboxExec = existsSync5("/usr/bin/sandbox-exec");
   }
   generateProfile(profile) {
     const rules = [
@@ -1974,7 +2096,7 @@ class MacOSSandbox {
 }
 
 // src/security/kernel/manager.ts
-import { resolve as resolve3, normalize } from "path";
+import { resolve as resolve4, normalize } from "path";
 
 class KernelSandboxManager {
   windowsSandbox;
@@ -1996,10 +2118,10 @@ class KernelSandboxManager {
     };
   }
   buildDefaultProfile(cwd, allowNetwork = true) {
-    const normCwd = normalize(resolve3(cwd));
+    const normCwd = normalize(resolve4(cwd));
     return {
       kind: "workspace-write",
-      readableRoots: [normCwd, resolve3(process.cwd())],
+      readableRoots: [normCwd, resolve4(process.cwd())],
       writableRoots: [normCwd],
       allowNetwork,
       limits: {
@@ -2045,21 +2167,19 @@ var globalKernelSandbox = new KernelSandboxManager;
 
 // src/storage/prefix-rules-store.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, resolve as resolve4 } from "path";
-import { homedir as homedir2 } from "os";
-
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } from "path";
 class PrefixRulesStore {
   db;
   constructor(dbOrPath) {
     if (dbOrPath instanceof Database) {
       this.db = dbOrPath;
     } else {
-      const effectivePath = dbOrPath || resolve4(homedir2(), ".groupy", "groupy_rules.db");
+      const effectivePath = dbOrPath || getPrefixRulesDbPath();
       if (effectivePath !== ":memory:") {
-        const dir = dirname2(effectivePath);
-        if (!existsSync5(dir)) {
-          mkdirSync3(dir, { recursive: true });
+        const dir = dirname3(effectivePath);
+        if (!existsSync6(dir)) {
+          mkdirSync4(dir, { recursive: true });
         }
       }
       this.db = new Database(effectivePath);
@@ -2082,7 +2202,7 @@ class PrefixRulesStore {
   addRule(workspacePath, prefixTokens) {
     if (!prefixTokens || prefixTokens.length === 0)
       return;
-    const normalizedWs = workspacePath === "*" ? "*" : resolve4(workspacePath);
+    const normalizedWs = workspacePath === "*" ? "*" : resolve5(workspacePath);
     const tokensJson = JSON.stringify(prefixTokens);
     const id = `${normalizedWs}:${tokensJson}`;
     const query = this.db.prepare(`
@@ -2099,7 +2219,7 @@ class PrefixRulesStore {
   isApproved(workspacePath, commandTokens) {
     if (!commandTokens || commandTokens.length === 0)
       return false;
-    const normalizedWs = resolve4(workspacePath);
+    const normalizedWs = resolve5(workspacePath);
     const query = this.db.prepare(`
       SELECT prefix_tokens FROM approved_prefix_rules
       WHERE workspace_path = $ws OR workspace_path = '*'
@@ -2118,7 +2238,7 @@ class PrefixRulesStore {
   listRules(workspacePath) {
     let rows;
     if (workspacePath) {
-      const normalizedWs = workspacePath === "*" ? "*" : resolve4(workspacePath);
+      const normalizedWs = workspacePath === "*" ? "*" : resolve5(workspacePath);
       const query = this.db.prepare(`
         SELECT prefix_tokens FROM approved_prefix_rules
         WHERE workspace_path = $ws OR workspace_path = '*'
@@ -2137,7 +2257,7 @@ class PrefixRulesStore {
     }).filter((r) => r.length > 0);
   }
   removeRule(workspacePath, prefixTokens) {
-    const normalizedWs = workspacePath === "*" ? "*" : resolve4(workspacePath);
+    const normalizedWs = workspacePath === "*" ? "*" : resolve5(workspacePath);
     const tokensJson = JSON.stringify(prefixTokens);
     const id = `${normalizedWs}:${tokensJson}`;
     const query = this.db.prepare(`
@@ -2270,7 +2390,7 @@ function createShellTool(policy = new ExecPolicy) {
             } catch {}
           });
         }
-        const timeoutPromise = new Promise((resolve5) => setTimeout(() => resolve5({ isTimeout: true }), timeoutMs));
+        const timeoutPromise = new Promise((resolve6) => setTimeout(() => resolve6({ isTimeout: true }), timeoutMs));
         const result = await Promise.race([
           proc.exited.then(async (code) => {
             const stdout = await new Response(proc.stdout).text();
@@ -2314,8 +2434,8 @@ ${result.stderr.trim()}`);
 }
 var shellTool = createShellTool();
 // src/tools/handlers/file-ops.ts
-import { readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync6, statSync, mkdirSync as mkdirSync4 } from "fs";
-import { resolve as resolve5, dirname as dirname3 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync7, statSync as statSync2, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve6, dirname as dirname4 } from "path";
 var readFileTool = {
   name: "read_file",
   description: "Read the full text content of a file.",
@@ -2327,8 +2447,8 @@ var readFileTool = {
     required: ["path"]
   },
   async execute(args, ctx) {
-    const filePath = resolve5(ctx.cwd, String(args.path || ""));
-    if (!existsSync6(filePath)) {
+    const filePath = resolve6(ctx.cwd, String(args.path || ""));
+    if (!existsSync7(filePath)) {
       return { output: `Error: File not found: '${args.path}'`, isError: true };
     }
     try {
@@ -2349,15 +2469,15 @@ var listDirTool = {
     }
   },
   async execute(args, ctx) {
-    const dirPath = resolve5(ctx.cwd, String(args.path || "."));
-    if (!existsSync6(dirPath)) {
+    const dirPath = resolve6(ctx.cwd, String(args.path || "."));
+    if (!existsSync7(dirPath)) {
       return { output: `Error: Directory not found: '${args.path}'`, isError: true };
     }
     try {
-      const entries = readdirSync(dirPath);
+      const entries = readdirSync2(dirPath);
       const formatted = entries.map((entry) => {
-        const full = resolve5(dirPath, entry);
-        const isDir = statSync(full).isDirectory();
+        const full = resolve6(dirPath, entry);
+        const isDir = statSync2(full).isDirectory();
         return `${isDir ? "[DIR]" : "[FILE]"} ${entry}`;
       });
       return { output: formatted.join(`
@@ -2380,7 +2500,7 @@ var writeFileTool = {
   },
   async execute(args, ctx) {
     const rawPath = String(args.path || "");
-    const filePath = resolve5(ctx.cwd, rawPath);
+    const filePath = resolve6(ctx.cwd, rawPath);
     if (ctx.execPolicy) {
       const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
       if (evalResult.isPlanBlocked || ctx.mode === "plan") {
@@ -2398,7 +2518,7 @@ var writeFileTool = {
       }
     }
     try {
-      mkdirSync4(dirname3(filePath), { recursive: true });
+      mkdirSync5(dirname4(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
       return { output: `Successfully wrote to '${args.path}'` };
     } catch (err) {
@@ -2521,8 +2641,8 @@ var updatePlanTool = {
   }
 };
 // src/search/engine.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, existsSync as existsSync7 } from "fs";
-import { resolve as resolve6, relative, join, extname } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3, existsSync as existsSync8 } from "fs";
+import { resolve as resolve7, relative, join as join2, extname } from "path";
 var DEFAULT_IGNORE_DIRS = new Set([
   ".git",
   "node_modules",
@@ -2567,8 +2687,8 @@ var BINARY_EXTENSIONS = new Set([
 
 class FileSearchEngine {
   grep(cwd, options) {
-    const searchRoot = resolve6(cwd, options.path || ".");
-    if (!existsSync7(searchRoot)) {
+    const searchRoot = resolve7(cwd, options.path || ".");
+    if (!existsSync8(searchRoot)) {
       return { matches: [], totalMatches: 0, truncated: false };
     }
     const maxResults = options.maxResults || 50;
@@ -2617,8 +2737,8 @@ class FileSearchEngine {
     return { matches, totalMatches, truncated };
   }
   findFiles(cwd, options) {
-    const searchRoot = resolve6(cwd, options.path || ".");
-    if (!existsSync7(searchRoot))
+    const searchRoot = resolve7(cwd, options.path || ".");
+    if (!existsSync8(searchRoot))
       return [];
     const maxResults = options.maxResults || 100;
     const gitignoreRules = this.loadGitignoreRules(searchRoot);
@@ -2657,8 +2777,8 @@ class FileSearchEngine {
   }
   loadGitignoreRules(root) {
     const rules = new Set;
-    const gitignorePath = join(root, ".gitignore");
-    if (existsSync7(gitignorePath)) {
+    const gitignorePath = join2(root, ".gitignore");
+    if (existsSync8(gitignorePath)) {
       try {
         const lines = readFileSync4(gitignorePath, "utf8").split(`
 `);
@@ -2675,7 +2795,7 @@ class FileSearchEngine {
   collectFiles(dir, root, gitignoreRules, includePattern) {
     const results = [];
     try {
-      const stat = statSync2(dir);
+      const stat = statSync3(dir);
       if (!stat.isDirectory()) {
         if (!this.isBinary(dir)) {
           results.push(dir);
@@ -2689,9 +2809,9 @@ class FileSearchEngine {
     while (queue.length > 0) {
       const currentDir = queue.shift();
       try {
-        const entries = readdirSync2(currentDir, { withFileTypes: true });
+        const entries = readdirSync3(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join(currentDir, entry.name);
+          const fullPath = join2(currentDir, entry.name);
           const relToRoot = relative(root, fullPath).replace(/\\/g, "/");
           if (this.isIgnored(entry.name, relToRoot, gitignoreRules)) {
             continue;
@@ -3088,6 +3208,111 @@ ${loaded.instructions}`
 }
 
 // src/memories/tool.ts
+function createSaveMemoryTool(store) {
+  return {
+    name: "save_memory",
+    description: "Save a persistent memory note to the project's Auto-Memory bank. Categories: 'user' (role, workflow style, tooling preferences), 'feedback' (user corrections, guidelines), 'project' (external context, environments, deadlines), 'reference' (links, issue trackers, dashboards). Do NOT save facts easily discovered in code or git history.",
+    parameters: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          description: "Category of memory: 'user', 'feedback', 'project', or 'reference'.",
+          enum: ["user", "feedback", "project", "reference"]
+        },
+        name: {
+          type: "string",
+          description: "Short, descriptive snake_case identifier for this memory topic (e.g. 'testing_strategy', 'preferred_framework', 'staging_api')."
+        },
+        description: {
+          type: "string",
+          description: "One-line summary to display in the MEMORY.md index (e.g. 'Prefers Vitest without database mocks')."
+        },
+        content: {
+          type: "string",
+          description: "Detailed description of the fact, preference, or learned correction."
+        }
+      },
+      required: ["category", "name", "content"]
+    },
+    async execute(args, context) {
+      const category = args.category || "project";
+      const name = String(args.name || `topic_${Date.now()}`);
+      const content = String(args.content || "").trim();
+      const description = args.description ? String(args.description).trim() : undefined;
+      if (!content) {
+        return { output: "Error: memory content cannot be empty", isError: true };
+      }
+      const entry = store.saveTopicMemory({
+        category,
+        name,
+        description,
+        content,
+        cwd: context.cwd
+      });
+      return {
+        output: `\u2713 Saved Auto-Memory topic: [${entry.category}] "${entry.name}" -> ${entry.filePath}`
+      };
+    }
+  };
+}
+function createReadMemoryTool(store) {
+  return {
+    name: "read_memory",
+    description: "Read the full details of a specific Auto-Memory topic file recorded in the project's memory index.",
+    parameters: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "Name or filename of the memory topic to read (e.g. 'testing_strategy' or 'feedback_testing.md')."
+        }
+      },
+      required: ["topic"]
+    },
+    async execute(args, context) {
+      const topic = String(args.topic || "").trim();
+      if (!topic) {
+        return { output: "Error: topic name is required", isError: true };
+      }
+      const memory = store.readTopicMemory(topic, context.cwd);
+      if (!memory) {
+        return {
+          output: `No memory topic found matching '${topic}' in this project.`,
+          isError: true
+        };
+      }
+      return {
+        output: `# Topic: ${memory.name} (${memory.type})
+Modified: ${memory.modified}
+
+${memory.content}`
+      };
+    }
+  };
+}
+function createListMemoriesTool(store) {
+  return {
+    name: "list_memories",
+    description: "List all persistent memory topics and index for the current project repository.",
+    parameters: {
+      type: "object",
+      properties: {}
+    },
+    async execute(_args, context) {
+      const topics = store.listProjectMemories(context.cwd);
+      if (topics.length === 0) {
+        return { output: "No persistent Auto-Memories have been recorded for this project yet." };
+      }
+      const lines = topics.map((t) => `\u2022 [${t.type}] **${t.name}**: ${t.description || t.content.split(`
+`)[0]} (file: ${t.filePath})`);
+      return { output: `Project Auto-Memories (${topics.length} topics):
+
+${lines.join(`
+`)}` };
+    }
+  };
+}
 function createRememberTool(store) {
   return {
     name: "remember",
@@ -3098,16 +3323,15 @@ function createRememberTool(store) {
         category: {
           type: "string",
           description: "Category of the memory.",
-          enum: ["preference", "guideline", "architecture", "note"]
+          enum: ["preference", "guideline", "architecture", "note", "user", "feedback", "project", "reference"]
         },
         content: {
           type: "string",
           description: "The concise rule, preference, or fact to remember permanently."
         },
-        scope: {
+        name: {
           type: "string",
-          description: "'global' (applies to all projects) or 'workspace' (applies only to current repository). Defaults to 'global'.",
-          enum: ["global", "workspace"]
+          description: "Optional topic name."
         }
       },
       required: ["category", "content"]
@@ -3115,22 +3339,30 @@ function createRememberTool(store) {
     async execute(args, context) {
       const category = args.category || "preference";
       const content = String(args.content || "");
-      const scope = args.scope || "global";
+      const name = args.name ? String(args.name) : undefined;
       if (!content) {
         return { output: "Error: memory content cannot be empty", isError: true };
       }
       const entry = store.addMemory({
         category,
         content,
-        scope,
+        name,
         cwd: context.cwd
       });
       return {
-        output: `Successfully saved to ${scope} memory bank: [${entry.category}] "${entry.content}"`
+        output: `Successfully saved to Auto-Memory bank: [${entry.category}] "${entry.name || entry.content}"`
       };
     }
   };
 }
+function createAutoMemoryTools(store) {
+  return [
+    createSaveMemoryTool(store),
+    createReadMemoryTool(store),
+    createListMemoriesTool(store),
+    createRememberTool(store)
+  ];
+}
 
 // src/worktree/tools.ts
 function createWorktreeTools(manager) {
@@ -3265,7 +3497,9 @@ function createDefaultTools(options = {}) {
     router2.register(createSkillTool(options.skillsLoader));
   }
   if (options.memoryStore) {
-    router2.register(createRememberTool(options.memoryStore));
+    for (const tool of createAutoMemoryTools(options.memoryStore)) {
+      router2.register(tool);
+    }
   }
   if (options.worktreeManager) {
     for (const tool of createWorktreeTools(options.worktreeManager)) {
@@ -3275,21 +3509,21 @@ function createDefaultTools(options = {}) {
   return router2;
 }
 // src/security/sandbox.ts
-import { resolve as resolve7, normalize as normalize2, relative as relative2 } from "path";
+import { resolve as resolve8, normalize as normalize2, relative as relative2 } from "path";
 class PathSandbox {
   allowedRoots;
   constructor(workspaceRoots) {
-    this.allowedRoots = workspaceRoots.map((root) => normalize2(resolve7(root)));
+    this.allowedRoots = workspaceRoots.map((root) => normalize2(resolve8(root)));
   }
   isPathAllowed(targetPath) {
-    const normalized = normalize2(resolve7(targetPath));
+    const normalized = normalize2(resolve8(targetPath));
     return this.allowedRoots.some((root) => {
       const rel = relative2(root, normalized);
-      return !rel.startsWith("..") && !resolve7(root, rel).startsWith("..");
+      return !rel.startsWith("..") && !resolve8(root, rel).startsWith("..");
     });
   }
   assertPathAllowed(targetPath) {
-    const normalized = normalize2(resolve7(targetPath));
+    const normalized = normalize2(resolve8(targetPath));
     if (!this.isPathAllowed(normalized)) {
       throw new ExecutionPolicyError(`Path access denied: '${targetPath}' is outside the allowed workspace boundaries (${this.allowedRoots.join(", ")})`);
     }
@@ -3297,8 +3531,8 @@ class PathSandbox {
   }
 }
 // src/security/scanner.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { join as join2, relative as relative3, resolve as resolve8 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { join as join3, relative as relative3, resolve as resolve9 } from "path";
 var SECURITY_RULES = [
   {
     id: "SEC-001",
@@ -3430,27 +3664,27 @@ var IGNORED_FILES = new Set([
 ]);
 async function runSecurityScan(targetDir, options = {}) {
   const startTime = performance.now();
-  const root = resolve8(targetDir);
+  const root = resolve9(targetDir);
   const isDirectTestDir = targetDir.includes("test") || Boolean(options.includeTests);
   const maxFiles = options.maxFiles || 2000;
   const findings = [];
   let scannedCount = 0;
   function walk(current) {
-    if (scannedCount >= maxFiles || !existsSync8(current))
+    if (scannedCount >= maxFiles || !existsSync9(current))
       return;
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join2(current, entry);
+      const fullPath = join3(current, entry);
       let stat;
       try {
-        stat = statSync3(fullPath);
+        stat = statSync4(fullPath);
       } catch {
         continue;
       }
@@ -3571,14 +3805,13 @@ function formatWorldStatePrompt(state) {
 `);
 }
 // src/prompts/loader.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve9, join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve10, join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 class PromptTemplateLoader {
   builtInTemplatesDir;
   constructor(builtInDir) {
-    this.builtInTemplatesDir = builtInDir || resolve9(join3(import.meta.dir, "..", "..", "templates"));
+    this.builtInTemplatesDir = builtInDir || resolve10(join4(import.meta.dir, "..", "..", "templates"));
   }
   loadTemplate(relativePath, variables = {}, cwd) {
     const rawContent = this.resolveTemplateContent(relativePath, cwd);
@@ -3587,21 +3820,27 @@ class PromptTemplateLoader {
   resolveTemplateContent(relativePath, cwd) {
     const normalizedRel = relativePath.replace(/^\/+/, "");
     if (cwd) {
-      const workspacePath = join3(cwd, ".agents", "templates", normalizedRel);
-      if (existsSync9(workspacePath)) {
+      const workspacePath = join4(cwd, ".agents", "templates", normalizedRel);
+      if (existsSync10(workspacePath)) {
         try {
           return readFileSync6(workspacePath, "utf-8");
         } catch {}
       }
     }
-    const globalPath = join3(homedir3(), ".groupy", "templates", normalizedRel);
-    if (existsSync9(globalPath)) {
+    const globalPath = join4(getGlobalTemplatesDir(), normalizedRel);
+    if (existsSync10(globalPath)) {
       try {
         return readFileSync6(globalPath, "utf-8");
       } catch {}
     }
-    const builtInPath = join3(this.builtInTemplatesDir, normalizedRel);
-    if (existsSync9(builtInPath)) {
+    const legacyGlobalPath = join4(homedir2(), ".groupy", "templates", normalizedRel);
+    if (existsSync10(legacyGlobalPath)) {
+      try {
+        return readFileSync6(legacyGlobalPath, "utf-8");
+      } catch {}
+    }
+    const builtInPath = join4(this.builtInTemplatesDir, normalizedRel);
+    if (existsSync10(builtInPath)) {
       try {
         return readFileSync6(builtInPath, "utf-8");
       } catch {}
@@ -3618,8 +3857,8 @@ class PromptTemplateLoader {
 var globalPromptLoader = new PromptTemplateLoader;
 
 // src/prompts/agents-md.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve10, join as join4, dirname as dirname4 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve11, join as join5, dirname as dirname5 } from "path";
 var DEFAULT_AGENTS_MD_FILENAMES = [
   "AGENTS.override.md",
   "AGENTS.md",
@@ -3634,28 +3873,28 @@ var AGENTS_MD_SEPARATOR = `
 
 class AgentsMdLoader {
   findProjectRoot(startDir) {
-    let current = resolve10(startDir);
+    let current = resolve11(startDir);
     while (true) {
-      if (existsSync10(join4(current, ".git"))) {
+      if (existsSync11(join5(current, ".git"))) {
         return current;
       }
-      const parent = dirname4(current);
+      const parent = dirname5(current);
       if (parent === current) {
-        return resolve10(startDir);
+        return resolve11(startDir);
       }
       current = parent;
     }
   }
   collectDirectoryHierarchy(targetDir, rootDir) {
     const hierarchy = [];
-    let current = resolve10(targetDir);
-    const normalizedRoot = resolve10(rootDir);
+    let current = resolve11(targetDir);
+    const normalizedRoot = resolve11(rootDir);
     while (true) {
       hierarchy.unshift(current);
       if (current === normalizedRoot) {
         break;
       }
-      const parent = dirname4(current);
+      const parent = dirname5(current);
       if (parent === current) {
         break;
       }
@@ -3670,8 +3909,8 @@ class AgentsMdLoader {
     const sourcePaths = [];
     for (const dir of dirHierarchy) {
       for (const filename of fallbackFilenames) {
-        const filePath = join4(dir, filename);
-        if (existsSync10(filePath)) {
+        const filePath = join5(dir, filename);
+        if (existsSync11(filePath)) {
           try {
             const content = readFileSync7(filePath, "utf-8").trim();
             if (content) {
@@ -4260,13 +4499,13 @@ class Session {
       type: "StatusChanged",
       status: "waiting_approval"
     });
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       this.pendingApprovals.set(params.approvalId, (approved) => {
         this.emitEvent({
           type: "StatusChanged",
           status: "running"
         });
-        resolve11(approved);
+        resolve12(approved);
       });
     });
   }
@@ -4289,13 +4528,13 @@ class Session {
       type: "StatusChanged",
       status: "waiting_user_input"
     });
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       this.pendingUserQuestions.set(params.questionId, (answer) => {
         this.emitEvent({
           type: "StatusChanged",
           status: "running"
         });
-        resolve11(answer);
+        resolve12(answer);
       });
     });
   }
@@ -4325,7 +4564,7 @@ class Session {
     return handleTurnInput(this, { text, images });
   }
   async promptAndWait(text, images, timeoutMs = 30000) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         unsub();
         reject(new Error(`Turn timed out after ${timeoutMs}ms`));
@@ -4334,7 +4573,7 @@ class Session {
         if (event.msg.type === "TurnCompleted") {
           clearTimeout(timer);
           unsub();
-          resolve11();
+          resolve12();
         } else if (event.msg.type === "Error") {
           clearTimeout(timer);
           unsub();
@@ -4353,8 +4592,8 @@ class Session {
       if (this.submissionQueue.length > 0) {
         yield this.submissionQueue.shift();
       } else {
-        const nextSub = await new Promise((resolve11) => {
-          this.submissionResolvers.push(resolve11);
+        const nextSub = await new Promise((resolve12) => {
+          this.submissionResolvers.push(resolve12);
         });
         yield nextSub;
       }
@@ -4618,13 +4857,13 @@ class StdioTransport {
     if (this.isClosed || !this.proc || !this.proc.stdin) {
       throw new GroupyError("MCP Stdio transport is closed");
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timeoutMs = 30000;
       const timer = setTimeout(() => {
         this.pendingRequests.delete(request.id);
         reject(new GroupyError(`MCP request timed out after ${timeoutMs}ms (method: ${request.method})`));
       }, timeoutMs);
-      this.pendingRequests.set(request.id, { resolve: resolve11, reject, timer });
+      this.pendingRequests.set(request.id, { resolve: resolve12, reject, timer });
       try {
         const payload = JSON.stringify(request) + `
 `;
@@ -4757,12 +4996,12 @@ class SseTransport {
     if (!this.messageUrl) {
       this.messageUrl = this.endpointUrl;
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(request.id);
         reject(new GroupyError(`MCP SSE request timed out (method: ${request.method})`));
       }, 30000);
-      this.pendingRequests.set(request.id, { resolve: resolve11, reject, timer });
+      this.pendingRequests.set(request.id, { resolve: resolve12, reject, timer });
       fetch(this.messageUrl, {
         method: "POST",
         headers: {
@@ -4999,8 +5238,8 @@ class McpClient {
   }
 }
 // src/mcp/manager.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve11, dirname as dirname5, join as join5 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve12, dirname as dirname6, join as join6 } from "path";
 class McpManager {
   clients = new Map;
   serverConfigs = new Map;
@@ -5034,8 +5273,8 @@ class McpManager {
     }
   }
   async loadConfigFile(filePath) {
-    const fullPath = resolve11(filePath);
-    if (!existsSync11(fullPath))
+    const fullPath = resolve12(filePath);
+    if (!existsSync12(fullPath))
       return;
     this.loadedConfigFiles.add(fullPath);
     try {
@@ -5288,13 +5527,13 @@ class McpManager {
 `);
   }
   saveServerToConfigFile(filePath, name, config) {
-    const fullPath = resolve11(filePath);
-    const dir = dirname5(fullPath);
-    if (!existsSync11(dir)) {
-      mkdirSync5(dir, { recursive: true });
+    const fullPath = resolve12(filePath);
+    const dir = dirname6(fullPath);
+    if (!existsSync12(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
     let existing = { mcpServers: {} };
-    if (existsSync11(fullPath)) {
+    if (existsSync12(fullPath)) {
       try {
         const content = readFileSync8(fullPath, "utf8");
         existing = JSON.parse(content);
@@ -5308,8 +5547,8 @@ class McpManager {
     this.loadedConfigFiles.add(fullPath);
   }
   removeServerFromConfigFile(filePath, name) {
-    const fullPath = resolve11(filePath);
-    if (!existsSync11(fullPath))
+    const fullPath = resolve12(filePath);
+    if (!existsSync12(fullPath))
       return false;
     try {
       const content = readFileSync8(fullPath, "utf8");
@@ -5339,11 +5578,11 @@ class McpManager {
     }
   }
   getDefaultConfigFile(cwd = process.cwd()) {
-    const workspaceConfig = join5(cwd, ".mcp.json");
-    if (existsSync11(workspaceConfig))
+    const workspaceConfig = join6(cwd, ".mcp.json");
+    if (existsSync12(workspaceConfig))
       return workspaceConfig;
-    const altConfig = join5(cwd, "mcp_config.json");
-    if (existsSync11(altConfig))
+    const altConfig = join6(cwd, "mcp_config.json");
+    if (existsSync12(altConfig))
       return altConfig;
     return workspaceConfig;
   }
@@ -5362,11 +5601,11 @@ class McpManager {
   }
 }
 // src/mcp/servers/chrome-devtools/index.ts
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 
 // src/mcp/servers/chrome-devtools/launcher.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, rmSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, rmSync } from "fs";
+import { join as join7 } from "path";
 import { tmpdir } from "os";
 class BrowserLauncher {
   proc = null;
@@ -5374,21 +5613,21 @@ class BrowserLauncher {
   wsDebuggerUrl = null;
   port = 0;
   static findBrowserExecutable() {
-    if (process.env.CHROME_PATH && existsSync12(process.env.CHROME_PATH)) {
+    if (process.env.CHROME_PATH && existsSync13(process.env.CHROME_PATH)) {
       return process.env.CHROME_PATH;
     }
     if (process.platform === "win32") {
       const candidates = [
         "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
         "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-        join6(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
+        join7(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
         "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-        join6(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
+        join7(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
       ];
       for (const path of candidates) {
-        if (path && existsSync12(path))
+        if (path && existsSync13(path))
           return path;
       }
     } else if (process.platform === "darwin") {
@@ -5399,7 +5638,7 @@ class BrowserLauncher {
         "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
       ];
       for (const path of candidates) {
-        if (existsSync12(path))
+        if (existsSync13(path))
           return path;
       }
     } else {
@@ -5412,7 +5651,7 @@ class BrowserLauncher {
         "/usr/bin/microsoft-edge"
       ];
       for (const path of candidates) {
-        if (existsSync12(path))
+        if (existsSync13(path))
           return path;
       }
     }
@@ -5424,8 +5663,8 @@ class BrowserLauncher {
       throw new Error("No supported browser (Google Chrome, Chromium, MS Edge, Brave) found on this machine. Please install Chrome or specify CHROME_PATH.");
     }
     this.port = options.port || 9200 + Math.floor(Math.random() * 500);
-    this.tempUserDataDir = options.userDataDir || join6(tmpdir(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
-    mkdirSync6(this.tempUserDataDir, { recursive: true });
+    this.tempUserDataDir = options.userDataDir || join7(tmpdir(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    mkdirSync7(this.tempUserDataDir, { recursive: true });
     const isHeadless = options.headless ?? true;
     const launchArgs = [
       executable,
@@ -5502,7 +5741,7 @@ class BrowserLauncher {
       }
       this.proc = null;
     }
-    if (this.tempUserDataDir && existsSync12(this.tempUserDataDir)) {
+    if (this.tempUserDataDir && existsSync13(this.tempUserDataDir)) {
       try {
         rmSync(this.tempUserDataDir, { recursive: true, force: true });
       } catch {}
@@ -5524,7 +5763,7 @@ class CdpSession {
     this.wsUrl = wsUrl;
   }
   async connect() {
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       try {
         this.ws = new WebSocket(this.wsUrl);
         const onOpen = async () => {
@@ -5540,7 +5779,7 @@ class CdpSession {
             await this.send("Network.enable").catch(() => {});
             await this.send("Page.setLifecycleEventsEnabled", { enabled: true }).catch(() => {});
             this.setupEventHandlers();
-            resolve12();
+            resolve13();
           } catch (err) {
             reject(err);
           }
@@ -5662,13 +5901,13 @@ class CdpSession {
       throw new Error("CDP WebSocket is not connected");
     }
     const id = this.nextId++;
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       const timeoutMs = 30000;
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`CDP command '${method}' timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve12, reject, timer });
+      this.pending.set(id, { resolve: resolve13, reject, timer });
       try {
         this.ws?.send(JSON.stringify({ id, method, params }));
       } catch (err) {
@@ -5863,8 +6102,8 @@ class DomSnapshotEngine {
   }
 }
 // src/mcp/servers/chrome-devtools/controller.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname6, resolve as resolve12 } from "path";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname7, resolve as resolve13 } from "path";
 class ChromeDevToolsController {
   launcher = new BrowserLauncher;
   sessions = new Map;
@@ -5992,12 +6231,12 @@ class ChromeDevToolsController {
     } else if (navType === "reload") {
       await cdp.send("Page.reload", { ignoreCache: params.ignoreCache });
     }
-    await new Promise((resolve13) => {
-      const timer = setTimeout(resolve13, params.timeout || 3000);
+    await new Promise((resolve14) => {
+      const timer = setTimeout(resolve14, params.timeout || 3000);
       const unsub = cdp.on("Page.loadEventFired", () => {
         clearTimeout(timer);
         unsub();
-        resolve13();
+        resolve14();
       });
     });
     const evalRes = await cdp.send("Runtime.evaluate", {
@@ -6013,8 +6252,8 @@ class ChromeDevToolsController {
     const { cdp } = this.getSession(params.pageId);
     const snapshot = await DomSnapshotEngine.captureSnapshot(cdp, params.verbose);
     if (params.filePath) {
-      const fullPath = resolve12(params.filePath);
-      mkdirSync7(dirname6(fullPath), { recursive: true });
+      const fullPath = resolve13(params.filePath);
+      mkdirSync8(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, snapshot.textSnapshot, "utf8");
       return `Snapshot saved to ${params.filePath} (${snapshot.elementsCount} indexed elements)`;
     }
@@ -6042,8 +6281,8 @@ class ChromeDevToolsController {
     });
     const base64Data = res.data;
     if (params.filePath) {
-      const fullPath = resolve12(params.filePath);
-      mkdirSync7(dirname6(fullPath), { recursive: true });
+      const fullPath = resolve13(params.filePath);
+      mkdirSync8(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, Buffer.from(base64Data, "base64"));
       return { format, filePath: params.filePath };
     }
@@ -6187,8 +6426,8 @@ class ChromeDevToolsController {
     }
     const value = res.result?.value;
     if (params.filePath) {
-      const fullPath = resolve12(params.filePath);
-      mkdirSync7(dirname6(fullPath), { recursive: true });
+      const fullPath = resolve13(params.filePath);
+      mkdirSync8(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, JSON.stringify(value, null, 2), "utf8");
       return `Script output saved to ${params.filePath}`;
     }
@@ -6681,9 +6920,9 @@ if (false) {}
 
 // src/mcp/servers/chrome-devtools/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/chrome-devtools";
-var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve13(__dirname, "server.ts");
+var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve14(__dirname, "server.ts");
 // src/mcp/servers/web-search/index.ts
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 
 // src/mcp/servers/web-search/html-to-markdown.ts
 class HtmlToMarkdownConverter {
@@ -7335,14 +7574,14 @@ if (false) {}
 
 // src/mcp/servers/web-search/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/web-search";
-var WEB_SEARCH_MCP_SERVER_PATH = resolve14(__dirname, "server.ts");
+var WEB_SEARCH_MCP_SERVER_PATH = resolve15(__dirname, "server.ts");
 // src/mcp/servers/sqlite/index.ts
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 
 // src/mcp/servers/sqlite/db-engine.ts
 import { Database as Database2 } from "bun:sqlite";
-import { resolve as resolve15, isAbsolute } from "path";
-import { readdirSync as readdirSync4 } from "fs";
+import { resolve as resolve16, isAbsolute } from "path";
+import { readdirSync as readdirSync5 } from "fs";
 
 class SqliteEngine {
   connections = new Map;
@@ -7364,17 +7603,17 @@ class SqliteEngine {
         this.defaultDbPath = discovered;
         return discovered;
       }
-      const fallback = resolve15(process.cwd(), "dev.sqlite");
+      const fallback = resolve16(process.cwd(), "dev.sqlite");
       this.defaultDbPath = fallback;
       return fallback;
     }
-    return isAbsolute(dbPath) ? dbPath : resolve15(process.cwd(), dbPath);
+    return isAbsolute(dbPath) ? dbPath : resolve16(process.cwd(), dbPath);
   }
   autoDiscoverDatabase() {
     try {
-      const files = readdirSync4(process.cwd());
+      const files = readdirSync5(process.cwd());
       const dbFile = files.find((f) => f.endsWith(".sqlite") || f.endsWith(".sqlite3") || f.endsWith(".db"));
-      return dbFile ? resolve15(process.cwd(), dbFile) : null;
+      return dbFile ? resolve16(process.cwd(), dbFile) : null;
     } catch {
       return null;
     }
@@ -7833,7 +8072,7 @@ if (false) {}
 
 // src/mcp/servers/sqlite/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/sqlite";
-var SQLITE_MCP_SERVER_PATH = resolve16(__dirname, "server.ts");
+var SQLITE_MCP_SERVER_PATH = resolve17(__dirname, "server.ts");
 // src/agents/identity.ts
 import { generateKeyPairSync, sign, verify } from "crypto";
 function createAgentIdentity(parentId, harnessId = "groupy-harness-v1") {
@@ -7876,8 +8115,8 @@ function verifyTaskAction(assertion, payload) {
   }
 }
 // src/agents/roles.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve17, join as join7 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve18, join as join8 } from "path";
 
 class AgentRoleRegistry {
   roles = new Map;
@@ -7961,14 +8200,14 @@ class AgentRoleRegistry {
     return cycle === 0 ? base : `${base}_${cycle + 1}`;
   }
   loadRolesFromDir(dirPath) {
-    const fullPath = resolve17(dirPath);
-    if (!existsSync14(fullPath))
+    const fullPath = resolve18(dirPath);
+    if (!existsSync15(fullPath))
       return;
-    const entries = readdirSync5(fullPath);
+    const entries = readdirSync6(fullPath);
     for (const entry of entries) {
       if (entry.endsWith(".json")) {
         try {
-          const content = readFileSync9(join7(fullPath, entry), "utf8");
+          const content = readFileSync9(join8(fullPath, entry), "utf8");
           const parsed = JSON.parse(content);
           if (parsed.name && parsed.systemPrompt) {
             this.registerRole(parsed);
@@ -7997,21 +8236,19 @@ class AgentRoleRegistry {
 }
 // src/agents/graph-store.ts
 import { Database as Database3 } from "bun:sqlite";
-import { resolve as resolve18 } from "path";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
-import { homedir as homedir4 } from "os";
-
+import { resolve as resolve19 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9 } from "fs";
 class AgentGraphStore {
   db;
   constructor(dbPathOrDb) {
     if (dbPathOrDb instanceof Database3) {
       this.db = dbPathOrDb;
     } else {
-      const dbPath = dbPathOrDb || resolve18(homedir4(), ".groupy", "agent_graph.db");
+      const dbPath = dbPathOrDb || getAgentGraphDbPath();
       if (dbPath !== ":memory:") {
-        const dir = resolve18(dbPath, "..");
-        if (!existsSync15(dir)) {
-          mkdirSync8(dir, { recursive: true });
+        const dir = resolve19(dbPath, "..");
+        if (!existsSync16(dir)) {
+          mkdirSync9(dir, { recursive: true });
         }
       }
       this.db = new Database3(dbPath);
@@ -8133,8 +8370,8 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
     });
     let resolvePromise;
     let rejectPromise;
-    const taskPromise = new Promise((resolve19, reject) => {
-      resolvePromise = resolve19;
+    const taskPromise = new Promise((resolve20, reject) => {
+      resolvePromise = resolve20;
       rejectPromise = reject;
     });
     const handle = {
@@ -8433,17 +8670,16 @@ function registerMultiAgentTools(router2, spawner) {
 }
 // src/storage/sqlite-store.ts
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname7, resolve as resolve19 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname8 } from "path";
 class SqliteThreadStore {
   db;
   constructor(dbPath) {
     const effectivePath = dbPath || this.getDefaultDbPath();
     if (effectivePath !== ":memory:") {
-      const dir = dirname7(effectivePath);
-      if (!existsSync16(dir)) {
-        mkdirSync9(dir, { recursive: true });
+      const dir = dirname8(effectivePath);
+      if (!existsSync17(dir)) {
+        mkdirSync10(dir, { recursive: true });
       }
     }
     this.db = new Database4(effectivePath);
@@ -8452,7 +8688,7 @@ class SqliteThreadStore {
     this.initSchema();
   }
   getDefaultDbPath() {
-    return resolve19(homedir5(), ".groupy", "groupy_threads.db");
+    return getThreadsDbPath();
   }
   initSchema() {
     this.db.exec(`
@@ -8675,9 +8911,9 @@ class SessionPersistenceManager {
   }
 }
 // src/skills/loader.ts
-import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve20, join as join8 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve20, join as join9 } from "path";
+import { homedir as homedir3 } from "os";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -8747,16 +8983,16 @@ class SkillsLoader {
         resolve20(cwd, "skills")
       ];
       for (const cand of candidates) {
-        if (existsSync17(cand) && !roots.includes(cand)) {
+        if (existsSync18(cand) && !roots.includes(cand)) {
           roots.push(cand);
         }
       }
     }
     if (this.includeGlobal) {
-      roots.push(resolve20(homedir6(), ".groupy", "skills"), resolve20(homedir6(), ".gemini", "config", "skills"));
+      roots.push(getGlobalSkillsDir(), resolve20(homedir3(), ".gemini", "config", "skills"));
     }
     roots.push(...this.customRoots.map((r) => resolve20(r)));
-    return roots.filter((r) => existsSync17(r));
+    return roots.filter((r) => existsSync18(r));
   }
   discoverSkills(cwd, options) {
     return this.listSkills(cwd, options);
@@ -8772,12 +9008,12 @@ class SkillsLoader {
     const discovered = new Map;
     for (const root of roots) {
       try {
-        const entries = readdirSync6(root, { withFileTypes: true });
+        const entries = readdirSync7(root, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const skillDir = join8(root, entry.name);
-            const skillFilePath = join8(skillDir, "SKILL.md");
-            if (existsSync17(skillFilePath)) {
+            const skillDir = join9(root, entry.name);
+            const skillFilePath = join9(skillDir, "SKILL.md");
+            if (existsSync18(skillFilePath)) {
               const meta = this.parseSkillFrontmatter(skillFilePath, entry.name, root, cwd);
               if (meta && !discovered.has(meta.name)) {
                 meta.enabled = !this.isSkillDisabled(meta.name);
@@ -8899,143 +9135,282 @@ When tackling complex specialized tasks that match any of these skills, autonomo
   }
 }
 // src/memories/store.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
-import { resolve as resolve21, dirname as dirname8 } from "path";
-import { homedir as homedir7 } from "os";
-
+import { existsSync as existsSync19, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11, readdirSync as readdirSync8 } from "fs";
+import { resolve as resolve21, join as join10, basename, dirname as dirname9 } from "path";
+import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
   customWorkspacePath;
   constructor(options = {}) {
-    this.globalPath = options.globalPath || resolve21(homedir7(), ".groupy", "memories.md");
+    this.globalPath = options.globalPath || getGlobalMemoriesPath();
     this.customWorkspacePath = options.workspacePath;
   }
-  getWorkspacePath(cwd) {
-    return this.customWorkspacePath || resolve21(cwd, ".agents", "memories.md");
+  findProjectRoot(cwd) {
+    let current = resolve21(cwd);
+    while (true) {
+      if (existsSync19(join10(current, ".git"))) {
+        return current;
+      }
+      const parent = dirname9(current);
+      if (parent === current) {
+        return resolve21(cwd);
+      }
+      current = parent;
+    }
   }
-  addMemory(params) {
-    const scope = params.scope || "global";
-    const targetFile = scope === "global" ? this.globalPath : this.getWorkspacePath(params.cwd || process.cwd());
-    const dir = dirname8(targetFile);
-    if (!existsSync18(dir)) {
-      mkdirSync10(dir, { recursive: true });
-    }
-    const existingEntries = this.readMemoryFile(targetFile, scope);
-    const normalized = params.content.trim();
-    const duplicate = existingEntries.find((e) => e.category === params.category && e.content.toLowerCase() === normalized.toLowerCase());
-    if (duplicate) {
-      return duplicate;
-    }
-    const newEntry = {
-      id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-      category: params.category,
-      content: normalized,
-      scope,
-      createdAt: Date.now()
-    };
-    existingEntries.push(newEntry);
-    this.writeMemoryFile(targetFile, existingEntries);
-    return newEntry;
+  getProjectSlug(cwd) {
+    const root = this.findProjectRoot(cwd);
+    const folderName = basename(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
+    const hash = createHash("sha256").update(resolve21(root)).digest("hex").slice(0, 6);
+    return `${folderName}-${hash}`;
   }
-  getAllMemories(cwd) {
-    const globalEntries = this.readMemoryFile(this.globalPath, "global");
-    const workspacePath = this.getWorkspacePath(cwd);
-    const workspaceEntries = existsSync18(workspacePath) ? this.readMemoryFile(workspacePath, "workspace") : [];
-    return [...globalEntries, ...workspaceEntries];
+  getProjectMemoryDir(cwd) {
+    if (this.customWorkspacePath) {
+      const dir2 = resolve21(this.customWorkspacePath);
+      if (!existsSync19(dir2)) {
+        try {
+          mkdirSync11(dir2, { recursive: true });
+        } catch {}
+      }
+      return dir2;
+    }
+    const slug = this.getProjectSlug(cwd);
+    const dir = join10(getProjectsDir(), slug, "memory");
+    if (!existsSync19(dir)) {
+      try {
+        mkdirSync11(dir, { recursive: true });
+      } catch {}
+    }
+    return dir;
+  }
+  getMemoryIndexPath(cwd) {
+    return join10(this.getProjectMemoryDir(cwd), "MEMORY.md");
+  }
+  normalizeCategory(raw) {
+    const cat = raw.toLowerCase().trim();
+    if (cat === "user" || cat === "preference")
+      return "user";
+    if (cat === "feedback" || cat === "guideline")
+      return "feedback";
+    if (cat === "project" || cat === "architecture")
+      return "project";
+    if (cat === "reference" || cat === "note")
+      return "reference";
+    return "project";
+  }
+  saveTopicMemory(params) {
+    const type = this.normalizeCategory(params.category);
+    const sanitizedName = params.name.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `note_${Date.now()}`;
+    const memoryDir = this.getProjectMemoryDir(params.cwd);
+    const fileName = `${type}_${sanitizedName}.md`;
+    const filePath = join10(memoryDir, fileName);
+    const nowIso = new Date().toISOString();
+    const cleanContent = params.content.trim();
+    const desc = (params.description || cleanContent.split(`
+`)[0] || sanitizedName).replace(/[\r\n]+/g, " ");
+    const frontmatter = [
+      "---",
+      `type: ${type}`,
+      `name: ${sanitizedName}`,
+      `description: ${desc}`,
+      `modified: ${nowIso}`,
+      "---",
+      "",
+      `# ${sanitizedName.replace(/_/g, " ").toUpperCase()}`,
+      "",
+      cleanContent,
+      ""
+    ].join(`
+`);
+    writeFileSync6(filePath, frontmatter, "utf8");
+    this.syncMemoryIndex(params.cwd);
+    return {
+      id: `mem_${sanitizedName}`,
+      category: type,
+      name: sanitizedName,
+      description: desc,
+      content: cleanContent,
+      scope: "project",
+      createdAt: Date.now(),
+      modifiedAt: Date.now(),
+      filePath
+    };
   }
-  readMemoryFile(filePath, scope) {
-    if (!existsSync18(filePath))
-      return [];
+  readTopicMemory(topicNameOrFile, cwd) {
+    const memoryDir = this.getProjectMemoryDir(cwd);
+    let targetPath = join10(memoryDir, topicNameOrFile);
+    if (!existsSync19(targetPath)) {
+      if (!topicNameOrFile.endsWith(".md")) {
+        targetPath = join10(memoryDir, `${topicNameOrFile}.md`);
+      }
+    }
+    if (!existsSync19(targetPath)) {
+      const files = readdirSync8(memoryDir);
+      const match = files.find((f) => f.includes(topicNameOrFile));
+      if (match) {
+        targetPath = join10(memoryDir, match);
+      } else {
+        return null;
+      }
+    }
     try {
-      const content = readFileSync11(filePath, "utf8");
-      const lines = content.split(`
+      const raw = readFileSync11(targetPath, "utf8");
+      return this.parseTopicFile(raw, targetPath);
+    } catch {
+      return null;
+    }
+  }
+  parseTopicFile(raw, filePath) {
+    const lines = raw.split(`
 `);
-      const entries = [];
-      let currentCategory = "preference";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("## Preferences") || trimmed.startsWith("## User Preferences")) {
-          currentCategory = "preference";
-        } else if (trimmed.startsWith("## Guidelines") || trimmed.startsWith("## Coding Guidelines")) {
-          currentCategory = "guideline";
-        } else if (trimmed.startsWith("## Architecture") || trimmed.startsWith("## Project Architecture")) {
-          currentCategory = "architecture";
-        } else if (trimmed.startsWith("## Notes") || trimmed.startsWith("## General Notes")) {
-          currentCategory = "note";
-        } else if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
-          const itemText = trimmed.slice(2).trim();
-          if (itemText) {
-            entries.push({
-              id: `mem_${entries.length + 1}`,
-              category: currentCategory,
-              content: itemText,
-              scope,
-              createdAt: Date.now()
-            });
-          }
+    let inFm = false;
+    let type = "project";
+    let name = basename(filePath, ".md");
+    let description;
+    let modified = new Date().toISOString();
+    const bodyLines = [];
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (i === 0 && line.trim() === "---") {
+        inFm = true;
+        continue;
+      }
+      if (inFm) {
+        if (line.trim() === "---") {
+          inFm = false;
+          continue;
         }
+        const colonIdx = line.indexOf(":");
+        if (colonIdx !== -1) {
+          const key = line.slice(0, colonIdx).trim();
+          const val = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, "");
+          if (key === "type")
+            type = this.normalizeCategory(val);
+          else if (key === "name")
+            name = val;
+          else if (key === "description")
+            description = val;
+          else if (key === "modified")
+            modified = val;
+        }
+      } else {
+        bodyLines.push(line);
       }
-      return entries;
-    } catch {
-      return [];
     }
-  }
-  writeMemoryFile(filePath, entries) {
-    const categories = {
-      preference: [],
-      guideline: [],
-      architecture: [],
-      note: []
+    return {
+      type,
+      name,
+      description,
+      modified,
+      content: bodyLines.join(`
+`).trim(),
+      filePath
     };
-    for (const entry of entries) {
-      categories[entry.category].push(entry.content);
+  }
+  syncMemoryIndex(cwd) {
+    const memoryDir = this.getProjectMemoryDir(cwd);
+    const indexPath = join10(memoryDir, "MEMORY.md");
+    const files = existsSync19(memoryDir) ? readdirSync8(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const items2 = [];
+    for (const f of files) {
+      try {
+        const full = join10(memoryDir, f);
+        const parsed = this.parseTopicFile(readFileSync11(full, "utf8"), full);
+        items2.push({
+          type: parsed.type,
+          name: parsed.name,
+          desc: parsed.description || parsed.content.split(`
+`)[0] || parsed.name,
+          file: f
+        });
+      } catch {}
     }
-    let markdown = `# Groupy Persistent Memories
-
-`;
-    if (categories.preference.length > 0) {
-      markdown += `## User Preferences
-${categories.preference.map((p) => `- ${p}`).join(`
-`)}
-
-`;
+    const indexLines = [
+      "# Project Auto-Memory Index",
+      "",
+      "This index is loaded at session startup. Detailed topics can be retrieved via read_memory tool.",
+      ""
+    ];
+    for (const item of items2) {
+      indexLines.push(`- [${item.type}] **${item.name}**: ${item.desc} (topic: ${item.file})`);
     }
-    if (categories.guideline.length > 0) {
-      markdown += `## Coding Guidelines
-${categories.guideline.map((g) => `- ${g}`).join(`
-`)}
-
-`;
+    const boundedLines = indexLines.slice(0, 200);
+    writeFileSync6(indexPath, boundedLines.join(`
+`) + `
+`, "utf8");
+  }
+  loadMemoryIndex(cwd) {
+    const indexPath = this.getMemoryIndexPath(cwd);
+    if (!existsSync19(indexPath))
+      return "";
+    try {
+      const raw = readFileSync11(indexPath, "utf8");
+      const byteLimit = 25 * 1024;
+      const sliced = raw.length > byteLimit ? raw.slice(0, byteLimit) : raw;
+      const lines = sliced.split(`
+`).slice(0, 200);
+      return lines.join(`
+`).trim();
+    } catch {
+      return "";
     }
-    if (categories.architecture.length > 0) {
-      markdown += `## Project Architecture
-${categories.architecture.map((a) => `- ${a}`).join(`
-`)}
-
-`;
+  }
+  listProjectMemories(cwd) {
+    const memoryDir = this.getProjectMemoryDir(cwd);
+    if (!existsSync19(memoryDir))
+      return [];
+    const files = readdirSync8(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const list = [];
+    for (const f of files) {
+      try {
+        const full = join10(memoryDir, f);
+        list.push(this.parseTopicFile(readFileSync11(full, "utf8"), full));
+      } catch {}
     }
-    if (categories.note.length > 0) {
-      markdown += `## General Notes
-${categories.note.map((n) => `- ${n}`).join(`
-`)}
-
-`;
+    return list;
+  }
+  addMemory(params) {
+    const cwd = params.cwd || process.cwd();
+    const type = this.normalizeCategory(params.category);
+    const name = params.name || `${type}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+    const entry = this.saveTopicMemory({
+      category: type,
+      name,
+      content: params.content,
+      cwd
+    });
+    if (params.scope) {
+      entry.scope = params.scope;
     }
-    writeFileSync6(filePath, markdown.trim() + `
-`, "utf8");
+    return entry;
+  }
+  getAllMemories(cwd) {
+    const projectTopics = this.listProjectMemories(cwd).map((t) => ({
+      id: `mem_${t.name}`,
+      category: t.type,
+      name: t.name,
+      description: t.description,
+      content: t.content,
+      scope: t.type === "user" ? "global" : "workspace",
+      createdAt: new Date(t.modified).getTime() || Date.now(),
+      filePath: t.filePath
+    }));
+    return projectTopics;
   }
   formatMemoriesPrompt(cwd) {
-    const memories = this.getAllMemories(cwd);
-    if (memories.length === 0)
+    const indexContent = this.loadMemoryIndex(cwd);
+    if (!indexContent)
       return "";
-    const lines = memories.map((m) => `- [${m.category}] (${m.scope}): ${m.content}`);
-    return `
-## Persistent User Preferences & Memory Bank
-<user_memories>
-${lines.join(`
-`)}
-</user_memories>
-Strictly respect these learned user preferences and project architectural conventions.`;
+    return [
+      "",
+      "## Project Auto-Memory (Persistent Learnings)",
+      "<auto_memory>",
+      indexContent,
+      "</auto_memory>",
+      "Apply these persistent project learnings, user preferences, and feedback across all tasks.",
+      "If more context is needed for a specific topic, retrieve it using the `read_memory` tool."
+    ].join(`
+`);
   }
 }
 // src/worktree/git.ts
@@ -9166,8 +9541,8 @@ async function removeWorktreeGit(repoRoot, worktreePath, deleteBranch = false) {
   return { success: true };
 }
 // src/worktree/manager.ts
-import { resolve as resolve23, join as join9 } from "path";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve23, join as join11 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
 var DEFAULT_WORKTREE_KEEP_COUNT = 15;
 
 class WorktreeManager {
@@ -9191,15 +9566,15 @@ class WorktreeManager {
     const branchName = options.branch || `groupy/${taskId}`;
     const targetDir = options.worktreePath || (this.baseStorageDir ? resolve23(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve23(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
     const worktreeParent = resolve23(targetDir, "..");
-    if (!existsSync19(worktreeParent)) {
-      mkdirSync11(worktreeParent, { recursive: true });
+    if (!existsSync20(worktreeParent)) {
+      mkdirSync12(worktreeParent, { recursive: true });
     }
     const baseBranch = options.baseBranch || await getCurrentBranch(repoRoot);
     const result = await createWorktreeGit(repoRoot, targetDir, branchName, baseBranch);
     if (!result.success) {
       throw new Error(`Failed to create git worktree: ${result.error}`);
     }
-    const metaPath = join9(targetDir, "groupy-thread.json");
+    const metaPath = join11(targetDir, "groupy-thread.json");
     try {
       writeFileSync7(metaPath, JSON.stringify({
         version: 1,
@@ -9225,8 +9600,8 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join9(wt.path, "groupy-thread.json");
-      if (existsSync19(metaPath)) {
+      const metaPath = join11(wt.path, "groupy-thread.json");
+      if (existsSync20(metaPath)) {
         try {
           const raw = JSON.parse(readFileSync12(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
@@ -9304,7 +9679,7 @@ class WorktreeManager {
   }
 }
 // src/auth/oauth.ts
-import { randomBytes, createHash } from "crypto";
+import { randomBytes, createHash as createHash2 } from "crypto";
 import { exec } from "child_process";
 class AuthClient {
   store;
@@ -9457,7 +9832,7 @@ class AuthClient {
     return randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9]/g, "").slice(0, 64);
   }
   generateCodeChallenge(verifier) {
-    return createHash("sha256").update(verifier).digest("base64url");
+    return createHash2("sha256").update(verifier).digest("base64url");
   }
 }
 // src/ui/components/claude/claude-header.tsx
@@ -11007,11 +11382,15 @@ export {
   captureWorldState,
   compactHistory,
   createAgentIdentity,
+  createAutoMemoryTools,
   createCodeModeTools,
   createDefaultTools,
   createFileSearchTools,
+  createListMemoriesTool,
   createMultiAgentTools,
+  createReadMemoryTool,
   createRememberTool,
+  createSaveMemoryTool,
   createShellTool,
   createSkillTool,
   createWorktreeGit,