@pikaa-ai/pikaa 0.3.14 → 0.3.15

package/dist/cli.js

@@ -3,21 +3,143 @@
 
 // src/cli/index.ts
 import { resolve as resolve21 } from "path";
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { createInterface } from "readline";
 
 // 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");
@@ -48,14 +170,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;
@@ -633,14 +755,13 @@ function formatWorldStatePrompt(state) {
 }
 
 // src/prompts/loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2, join } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3, join as join2 } from "path";
 import { homedir as homedir2 } from "os";
-
 class PromptTemplateLoader {
   builtInTemplatesDir;
   constructor(builtInDir) {
-    this.builtInTemplatesDir = builtInDir || resolve2(join(import.meta.dir, "..", "..", "templates"));
+    this.builtInTemplatesDir = builtInDir || resolve3(join2(import.meta.dir, "..", "..", "templates"));
   }
   loadTemplate(relativePath, variables = {}, cwd) {
     const rawContent = this.resolveTemplateContent(relativePath, cwd);
@@ -649,21 +770,27 @@ class PromptTemplateLoader {
   resolveTemplateContent(relativePath, cwd) {
     const normalizedRel = relativePath.replace(/^\/+/, "");
     if (cwd) {
-      const workspacePath = join(cwd, ".agents", "templates", normalizedRel);
-      if (existsSync2(workspacePath)) {
+      const workspacePath = join2(cwd, ".agents", "templates", normalizedRel);
+      if (existsSync3(workspacePath)) {
         try {
           return readFileSync2(workspacePath, "utf-8");
         } catch {}
       }
     }
-    const globalPath = join(homedir2(), ".groupy", "templates", normalizedRel);
-    if (existsSync2(globalPath)) {
+    const globalPath = join2(getGlobalTemplatesDir(), normalizedRel);
+    if (existsSync3(globalPath)) {
       try {
         return readFileSync2(globalPath, "utf-8");
       } catch {}
     }
-    const builtInPath = join(this.builtInTemplatesDir, normalizedRel);
-    if (existsSync2(builtInPath)) {
+    const legacyGlobalPath = join2(homedir2(), ".groupy", "templates", normalizedRel);
+    if (existsSync3(legacyGlobalPath)) {
+      try {
+        return readFileSync2(legacyGlobalPath, "utf-8");
+      } catch {}
+    }
+    const builtInPath = join2(this.builtInTemplatesDir, normalizedRel);
+    if (existsSync3(builtInPath)) {
       try {
         return readFileSync2(builtInPath, "utf-8");
       } catch {}
@@ -680,8 +807,8 @@ class PromptTemplateLoader {
 var globalPromptLoader = new PromptTemplateLoader;
 
 // src/prompts/agents-md.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3, join as join2, dirname } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4, join as join3, dirname as dirname2 } from "path";
 var DEFAULT_AGENTS_MD_FILENAMES = [
   "AGENTS.override.md",
   "AGENTS.md",
@@ -696,28 +823,28 @@ var AGENTS_MD_SEPARATOR = `
 
 class AgentsMdLoader {
   findProjectRoot(startDir) {
-    let current = resolve3(startDir);
+    let current = resolve4(startDir);
     while (true) {
-      if (existsSync3(join2(current, ".git"))) {
+      if (existsSync4(join3(current, ".git"))) {
         return current;
       }
-      const parent = dirname(current);
+      const parent = dirname2(current);
       if (parent === current) {
-        return resolve3(startDir);
+        return resolve4(startDir);
       }
       current = parent;
     }
   }
   collectDirectoryHierarchy(targetDir, rootDir) {
     const hierarchy = [];
-    let current = resolve3(targetDir);
-    const normalizedRoot = resolve3(rootDir);
+    let current = resolve4(targetDir);
+    const normalizedRoot = resolve4(rootDir);
     while (true) {
       hierarchy.unshift(current);
       if (current === normalizedRoot) {
         break;
       }
-      const parent = dirname(current);
+      const parent = dirname2(current);
       if (parent === current) {
         break;
       }
@@ -732,8 +859,8 @@ class AgentsMdLoader {
     const sourcePaths = [];
     for (const dir of dirHierarchy) {
       for (const filename of fallbackFilenames) {
-        const filePath = join2(dir, filename);
-        if (existsSync3(filePath)) {
+        const filePath = join3(dir, filename);
+        if (existsSync4(filePath)) {
           try {
             const content = readFileSync3(filePath, "utf-8").trim();
             if (content) {
@@ -1345,13 +1472,13 @@ class Session {
       type: "StatusChanged",
       status: "waiting_approval"
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       this.pendingApprovals.set(params.approvalId, (approved) => {
         this.emitEvent({
           type: "StatusChanged",
           status: "running"
         });
-        resolve4(approved);
+        resolve5(approved);
       });
     });
   }
@@ -1374,13 +1501,13 @@ class Session {
       type: "StatusChanged",
       status: "waiting_user_input"
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       this.pendingUserQuestions.set(params.questionId, (answer) => {
         this.emitEvent({
           type: "StatusChanged",
           status: "running"
         });
-        resolve4(answer);
+        resolve5(answer);
       });
     });
   }
@@ -1410,7 +1537,7 @@ class Session {
     return handleTurnInput(this, { text, images });
   }
   async promptAndWait(text, images, timeoutMs = 30000) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const timer = setTimeout(() => {
         unsub();
         reject(new Error(`Turn timed out after ${timeoutMs}ms`));
@@ -1419,7 +1546,7 @@ class Session {
         if (event.msg.type === "TurnCompleted") {
           clearTimeout(timer);
           unsub();
-          resolve4();
+          resolve5();
         } else if (event.msg.type === "Error") {
           clearTimeout(timer);
           unsub();
@@ -1438,8 +1565,8 @@ class Session {
       if (this.submissionQueue.length > 0) {
         yield this.submissionQueue.shift();
       } else {
-        const nextSub = await new Promise((resolve4) => {
-          this.submissionResolvers.push(resolve4);
+        const nextSub = await new Promise((resolve5) => {
+          this.submissionResolvers.push(resolve5);
         });
         yield nextSub;
       }
@@ -1453,9 +1580,9 @@ class Session {
   }
 }
 // src/tools/handlers/apply-patch.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve4, dirname as dirname2 } from "path";
-import { mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve5, dirname as dirname3 } 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.",
@@ -1482,7 +1609,7 @@ var applyPatchTool = {
     if (!rawPath) {
       return { output: "Error: 'path' parameter is required", isError: true };
     }
-    const filePath = resolve4(ctx.cwd, rawPath);
+    const filePath = resolve5(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
     if (ctx.execPolicy) {
@@ -1501,7 +1628,7 @@ var applyPatchTool = {
         }
       }
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       if (targetContent) {
         return {
           output: `Error: Target file '${rawPath}' does not exist, but targetContent was provided.`,
@@ -1509,7 +1636,7 @@ var applyPatchTool = {
         };
       }
       try {
-        mkdirSync2(dirname2(filePath), { recursive: true });
+        mkdirSync3(dirname3(filePath), { recursive: true });
         writeFileSync2(filePath, replacementContent, "utf8");
         return { output: `Successfully created new file '${rawPath}'` };
       } catch (err) {
@@ -1635,7 +1762,7 @@ class WindowsSandbox {
 }
 
 // src/security/kernel/linux.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 
 class LinuxSandbox {
   hasBwrap = false;
@@ -1646,7 +1773,7 @@ class LinuxSandbox {
     if (process.platform !== "linux") {
       return;
     }
-    this.hasBwrap = existsSync5("/usr/bin/bwrap") || existsSync5("/bin/bwrap") || existsSync5("/usr/local/bin/bwrap");
+    this.hasBwrap = existsSync6("/usr/bin/bwrap") || existsSync6("/bin/bwrap") || existsSync6("/usr/local/bin/bwrap");
   }
   wrapCommand(cmd, profile) {
     if (!this.hasBwrap || profile.kind === "danger-unrestricted") {
@@ -1680,7 +1807,7 @@ class LinuxSandbox {
 }
 
 // src/security/kernel/macos.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 class MacOSSandbox {
   hasSandboxExec = false;
@@ -1691,7 +1818,7 @@ class MacOSSandbox {
     if (process.platform !== "darwin") {
       return;
     }
-    this.hasSandboxExec = existsSync6("/usr/bin/sandbox-exec");
+    this.hasSandboxExec = existsSync7("/usr/bin/sandbox-exec");
   }
   generateProfile(profile) {
     const rules = [
@@ -1730,7 +1857,7 @@ class MacOSSandbox {
 }
 
 // src/security/kernel/manager.ts
-import { resolve as resolve5, normalize } from "path";
+import { resolve as resolve6, normalize } from "path";
 
 class KernelSandboxManager {
   windowsSandbox;
@@ -1752,10 +1879,10 @@ class KernelSandboxManager {
     };
   }
   buildDefaultProfile(cwd, allowNetwork = true) {
-    const normCwd = normalize(resolve5(cwd));
+    const normCwd = normalize(resolve6(cwd));
     return {
       kind: "workspace-write",
-      readableRoots: [normCwd, resolve5(process.cwd())],
+      readableRoots: [normCwd, resolve6(process.cwd())],
       writableRoots: [normCwd],
       allowNetwork,
       limits: {
@@ -1801,21 +1928,19 @@ var globalKernelSandbox = new KernelSandboxManager;
 
 // src/storage/prefix-rules-store.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve6 } from "path";
-import { homedir as homedir3 } from "os";
-
+import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4, resolve as resolve7 } from "path";
 class PrefixRulesStore {
   db;
   constructor(dbOrPath) {
     if (dbOrPath instanceof Database) {
       this.db = dbOrPath;
     } else {
-      const effectivePath = dbOrPath || resolve6(homedir3(), ".groupy", "groupy_rules.db");
+      const effectivePath = dbOrPath || getPrefixRulesDbPath();
       if (effectivePath !== ":memory:") {
-        const dir = dirname3(effectivePath);
-        if (!existsSync7(dir)) {
-          mkdirSync3(dir, { recursive: true });
+        const dir = dirname4(effectivePath);
+        if (!existsSync8(dir)) {
+          mkdirSync4(dir, { recursive: true });
         }
       }
       this.db = new Database(effectivePath);
@@ -1838,7 +1963,7 @@ class PrefixRulesStore {
   addRule(workspacePath, prefixTokens) {
     if (!prefixTokens || prefixTokens.length === 0)
       return;
-    const normalizedWs = workspacePath === "*" ? "*" : resolve6(workspacePath);
+    const normalizedWs = workspacePath === "*" ? "*" : resolve7(workspacePath);
     const tokensJson = JSON.stringify(prefixTokens);
     const id = `${normalizedWs}:${tokensJson}`;
     const query = this.db.prepare(`
@@ -1855,7 +1980,7 @@ class PrefixRulesStore {
   isApproved(workspacePath, commandTokens) {
     if (!commandTokens || commandTokens.length === 0)
       return false;
-    const normalizedWs = resolve6(workspacePath);
+    const normalizedWs = resolve7(workspacePath);
     const query = this.db.prepare(`
       SELECT prefix_tokens FROM approved_prefix_rules
       WHERE workspace_path = $ws OR workspace_path = '*'
@@ -1874,7 +1999,7 @@ class PrefixRulesStore {
   listRules(workspacePath) {
     let rows;
     if (workspacePath) {
-      const normalizedWs = workspacePath === "*" ? "*" : resolve6(workspacePath);
+      const normalizedWs = workspacePath === "*" ? "*" : resolve7(workspacePath);
       const query = this.db.prepare(`
         SELECT prefix_tokens FROM approved_prefix_rules
         WHERE workspace_path = $ws OR workspace_path = '*'
@@ -1893,7 +2018,7 @@ class PrefixRulesStore {
     }).filter((r) => r.length > 0);
   }
   removeRule(workspacePath, prefixTokens) {
-    const normalizedWs = workspacePath === "*" ? "*" : resolve6(workspacePath);
+    const normalizedWs = workspacePath === "*" ? "*" : resolve7(workspacePath);
     const tokensJson = JSON.stringify(prefixTokens);
     const id = `${normalizedWs}:${tokensJson}`;
     const query = this.db.prepare(`
@@ -2026,7 +2151,7 @@ function createShellTool(policy = new ExecPolicy) {
             } catch {}
           });
         }
-        const timeoutPromise = new Promise((resolve7) => setTimeout(() => resolve7({ isTimeout: true }), timeoutMs));
+        const timeoutPromise = new Promise((resolve8) => setTimeout(() => resolve8({ isTimeout: true }), timeoutMs));
         const result = await Promise.race([
           proc.exited.then(async (code) => {
             const stdout = await new Response(proc.stdout).text();
@@ -2070,8 +2195,8 @@ ${result.stderr.trim()}`);
 }
 var shellTool = createShellTool();
 // src/tools/handlers/file-ops.ts
-import { readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync, mkdirSync as mkdirSync4 } from "fs";
-import { resolve as resolve7, dirname as dirname4 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync9, statSync as statSync2, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve8, dirname as dirname5 } from "path";
 var readFileTool = {
   name: "read_file",
   description: "Read the full text content of a file.",
@@ -2083,8 +2208,8 @@ var readFileTool = {
     required: ["path"]
   },
   async execute(args, ctx) {
-    const filePath = resolve7(ctx.cwd, String(args.path || ""));
-    if (!existsSync8(filePath)) {
+    const filePath = resolve8(ctx.cwd, String(args.path || ""));
+    if (!existsSync9(filePath)) {
       return { output: `Error: File not found: '${args.path}'`, isError: true };
     }
     try {
@@ -2105,15 +2230,15 @@ var listDirTool = {
     }
   },
   async execute(args, ctx) {
-    const dirPath = resolve7(ctx.cwd, String(args.path || "."));
-    if (!existsSync8(dirPath)) {
+    const dirPath = resolve8(ctx.cwd, String(args.path || "."));
+    if (!existsSync9(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 = resolve7(dirPath, entry);
-        const isDir = statSync(full).isDirectory();
+        const full = resolve8(dirPath, entry);
+        const isDir = statSync2(full).isDirectory();
         return `${isDir ? "[DIR]" : "[FILE]"} ${entry}`;
       });
       return { output: formatted.join(`
@@ -2136,7 +2261,7 @@ var writeFileTool = {
   },
   async execute(args, ctx) {
     const rawPath = String(args.path || "");
-    const filePath = resolve7(ctx.cwd, rawPath);
+    const filePath = resolve8(ctx.cwd, rawPath);
     if (ctx.execPolicy) {
       const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
       if (evalResult.isPlanBlocked || ctx.mode === "plan") {
@@ -2154,7 +2279,7 @@ var writeFileTool = {
       }
     }
     try {
-      mkdirSync4(dirname4(filePath), { recursive: true });
+      mkdirSync5(dirname5(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
       return { output: `Successfully wrote to '${args.path}'` };
     } catch (err) {
@@ -2277,8 +2402,8 @@ var updatePlanTool = {
   }
 };
 // src/search/engine.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2, existsSync as existsSync9 } from "fs";
-import { resolve as resolve8, relative, join as join3, extname } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3, existsSync as existsSync10 } from "fs";
+import { resolve as resolve9, relative, join as join4, extname } from "path";
 var DEFAULT_IGNORE_DIRS = new Set([
   ".git",
   "node_modules",
@@ -2323,8 +2448,8 @@ var BINARY_EXTENSIONS = new Set([
 
 class FileSearchEngine {
   grep(cwd, options) {
-    const searchRoot = resolve8(cwd, options.path || ".");
-    if (!existsSync9(searchRoot)) {
+    const searchRoot = resolve9(cwd, options.path || ".");
+    if (!existsSync10(searchRoot)) {
       return { matches: [], totalMatches: 0, truncated: false };
     }
     const maxResults = options.maxResults || 50;
@@ -2373,8 +2498,8 @@ class FileSearchEngine {
     return { matches, totalMatches, truncated };
   }
   findFiles(cwd, options) {
-    const searchRoot = resolve8(cwd, options.path || ".");
-    if (!existsSync9(searchRoot))
+    const searchRoot = resolve9(cwd, options.path || ".");
+    if (!existsSync10(searchRoot))
       return [];
     const maxResults = options.maxResults || 100;
     const gitignoreRules = this.loadGitignoreRules(searchRoot);
@@ -2413,8 +2538,8 @@ class FileSearchEngine {
   }
   loadGitignoreRules(root) {
     const rules = new Set;
-    const gitignorePath = join3(root, ".gitignore");
-    if (existsSync9(gitignorePath)) {
+    const gitignorePath = join4(root, ".gitignore");
+    if (existsSync10(gitignorePath)) {
       try {
         const lines = readFileSync6(gitignorePath, "utf8").split(`
 `);
@@ -2431,7 +2556,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);
@@ -2445,9 +2570,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 = join3(currentDir, entry.name);
+          const fullPath = join4(currentDir, entry.name);
           const relToRoot = relative(root, fullPath).replace(/\\/g, "/");
           if (this.isIgnored(entry.name, relToRoot, gitignoreRules)) {
             continue;
@@ -2844,6 +2969,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",
@@ -2854,16 +3084,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"]
@@ -2871,22 +3100,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) {
@@ -3021,7 +3258,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)) {
@@ -3032,8 +3271,8 @@ function createDefaultTools(options = {}) {
 }
 
 // src/agents/roles.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve9, join as join4 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve10, join as join5 } from "path";
 
 class AgentRoleRegistry {
   roles = new Map;
@@ -3117,14 +3356,14 @@ class AgentRoleRegistry {
     return cycle === 0 ? base : `${base}_${cycle + 1}`;
   }
   loadRolesFromDir(dirPath) {
-    const fullPath = resolve9(dirPath);
-    if (!existsSync10(fullPath))
+    const fullPath = resolve10(dirPath);
+    if (!existsSync11(fullPath))
       return;
-    const entries = readdirSync3(fullPath);
+    const entries = readdirSync4(fullPath);
     for (const entry of entries) {
       if (entry.endsWith(".json")) {
         try {
-          const content = readFileSync7(join4(fullPath, entry), "utf8");
+          const content = readFileSync7(join5(fullPath, entry), "utf8");
           const parsed = JSON.parse(content);
           if (parsed.name && parsed.systemPrompt) {
             this.registerRole(parsed);
@@ -3176,21 +3415,19 @@ function createAgentIdentity(parentId, harnessId = "groupy-harness-v1") {
 
 // src/agents/graph-store.ts
 import { Database as Database2 } from "bun:sqlite";
-import { resolve as resolve10 } from "path";
-import { existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-
+import { resolve as resolve11 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
 class AgentGraphStore {
   db;
   constructor(dbPathOrDb) {
     if (dbPathOrDb instanceof Database2) {
       this.db = dbPathOrDb;
     } else {
-      const dbPath = dbPathOrDb || resolve10(homedir4(), ".groupy", "agent_graph.db");
+      const dbPath = dbPathOrDb || getAgentGraphDbPath();
       if (dbPath !== ":memory:") {
-        const dir = resolve10(dbPath, "..");
-        if (!existsSync11(dir)) {
-          mkdirSync5(dir, { recursive: true });
+        const dir = resolve11(dbPath, "..");
+        if (!existsSync12(dir)) {
+          mkdirSync6(dir, { recursive: true });
         }
       }
       this.db = new Database2(dbPath);
@@ -3313,8 +3550,8 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
     });
     let resolvePromise;
     let rejectPromise;
-    const taskPromise = new Promise((resolve11, reject) => {
-      resolvePromise = resolve11;
+    const taskPromise = new Promise((resolve12, reject) => {
+      resolvePromise = resolve12;
       rejectPromise = reject;
     });
     const handle = {
@@ -3614,8 +3851,8 @@ function registerMultiAgentTools(router2, spawner) {
 }
 
 // src/mcp/manager.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve11, dirname as dirname5, join as join5 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve12, dirname as dirname6, join as join6 } from "path";
 
 // src/mcp/client.ts
 class McpClient {
@@ -4009,13 +4246,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) + `
 `;
@@ -4148,12 +4385,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: {
@@ -4230,8 +4467,8 @@ class McpManager {
     }
   }
   async loadConfigFile(filePath) {
-    const fullPath = resolve11(filePath);
-    if (!existsSync12(fullPath))
+    const fullPath = resolve12(filePath);
+    if (!existsSync13(fullPath))
       return;
     this.loadedConfigFiles.add(fullPath);
     try {
@@ -4484,13 +4721,13 @@ class McpManager {
 `);
   }
   saveServerToConfigFile(filePath, name, config) {
-    const fullPath = resolve11(filePath);
-    const dir = dirname5(fullPath);
-    if (!existsSync12(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    const fullPath = resolve12(filePath);
+    const dir = dirname6(fullPath);
+    if (!existsSync13(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
     let existing = { mcpServers: {} };
-    if (existsSync12(fullPath)) {
+    if (existsSync13(fullPath)) {
       try {
         const content = readFileSync8(fullPath, "utf8");
         existing = JSON.parse(content);
@@ -4504,8 +4741,8 @@ class McpManager {
     this.loadedConfigFiles.add(fullPath);
   }
   removeServerFromConfigFile(filePath, name) {
-    const fullPath = resolve11(filePath);
-    if (!existsSync12(fullPath))
+    const fullPath = resolve12(filePath);
+    if (!existsSync13(fullPath))
       return false;
     try {
       const content = readFileSync8(fullPath, "utf8");
@@ -4535,11 +4772,11 @@ class McpManager {
     }
   }
   getDefaultConfigFile(cwd = process.cwd()) {
-    const workspaceConfig = join5(cwd, ".mcp.json");
-    if (existsSync12(workspaceConfig))
+    const workspaceConfig = join6(cwd, ".mcp.json");
+    if (existsSync13(workspaceConfig))
       return workspaceConfig;
-    const altConfig = join5(cwd, "mcp_config.json");
-    if (existsSync12(altConfig))
+    const altConfig = join6(cwd, "mcp_config.json");
+    if (existsSync13(altConfig))
       return altConfig;
     return workspaceConfig;
   }
@@ -4560,17 +4797,16 @@ class McpManager {
 
 // src/storage/sqlite-store.ts
 import { Database as Database3 } from "bun:sqlite";
-import { existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname6, resolve as resolve12 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname7 } from "path";
 class SqliteThreadStore {
   db;
   constructor(dbPath) {
     const effectivePath = dbPath || this.getDefaultDbPath();
     if (effectivePath !== ":memory:") {
-      const dir = dirname6(effectivePath);
-      if (!existsSync13(dir)) {
-        mkdirSync7(dir, { recursive: true });
+      const dir = dirname7(effectivePath);
+      if (!existsSync14(dir)) {
+        mkdirSync8(dir, { recursive: true });
       }
     }
     this.db = new Database3(effectivePath);
@@ -4579,7 +4815,7 @@ class SqliteThreadStore {
     this.initSchema();
   }
   getDefaultDbPath() {
-    return resolve12(homedir5(), ".groupy", "groupy_threads.db");
+    return getThreadsDbPath();
   }
   initSchema() {
     this.db.exec(`
@@ -4804,9 +5040,9 @@ class SessionPersistenceManager {
 }
 
 // src/skills/loader.ts
-import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve13, join as join6 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve13, join as join7 } from "path";
+import { homedir as homedir3 } from "os";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -4876,16 +5112,16 @@ class SkillsLoader {
         resolve13(cwd, "skills")
       ];
       for (const cand of candidates) {
-        if (existsSync14(cand) && !roots.includes(cand)) {
+        if (existsSync15(cand) && !roots.includes(cand)) {
           roots.push(cand);
         }
       }
     }
     if (this.includeGlobal) {
-      roots.push(resolve13(homedir6(), ".groupy", "skills"), resolve13(homedir6(), ".gemini", "config", "skills"));
+      roots.push(getGlobalSkillsDir(), resolve13(homedir3(), ".gemini", "config", "skills"));
     }
     roots.push(...this.customRoots.map((r) => resolve13(r)));
-    return roots.filter((r) => existsSync14(r));
+    return roots.filter((r) => existsSync15(r));
   }
   discoverSkills(cwd, options) {
     return this.listSkills(cwd, options);
@@ -4901,12 +5137,12 @@ class SkillsLoader {
     const discovered = new Map;
     for (const root of roots) {
       try {
-        const entries = readdirSync4(root, { withFileTypes: true });
+        const entries = readdirSync5(root, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const skillDir = join6(root, entry.name);
-            const skillFilePath = join6(skillDir, "SKILL.md");
-            if (existsSync14(skillFilePath)) {
+            const skillDir = join7(root, entry.name);
+            const skillFilePath = join7(skillDir, "SKILL.md");
+            if (existsSync15(skillFilePath)) {
               const meta = this.parseSkillFrontmatter(skillFilePath, entry.name, root, cwd);
               if (meta && !discovered.has(meta.name)) {
                 meta.enabled = !this.isSkillDisabled(meta.name);
@@ -5029,149 +5265,288 @@ When tackling complex specialized tasks that match any of these skills, autonomo
 }
 
 // src/memories/store.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
-import { resolve as resolve14, dirname as dirname7 } from "path";
-import { homedir as homedir7 } from "os";
-
+import { existsSync as existsSync16, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync9, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve14, join as join8, basename, dirname as dirname8 } from "path";
+import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
   customWorkspacePath;
   constructor(options = {}) {
-    this.globalPath = options.globalPath || resolve14(homedir7(), ".groupy", "memories.md");
+    this.globalPath = options.globalPath || getGlobalMemoriesPath();
     this.customWorkspacePath = options.workspacePath;
   }
-  getWorkspacePath(cwd) {
-    return this.customWorkspacePath || resolve14(cwd, ".agents", "memories.md");
+  findProjectRoot(cwd) {
+    let current = resolve14(cwd);
+    while (true) {
+      if (existsSync16(join8(current, ".git"))) {
+        return current;
+      }
+      const parent = dirname8(current);
+      if (parent === current) {
+        return resolve14(cwd);
+      }
+      current = parent;
+    }
   }
-  addMemory(params) {
-    const scope = params.scope || "global";
-    const targetFile = scope === "global" ? this.globalPath : this.getWorkspacePath(params.cwd || process.cwd());
-    const dir = dirname7(targetFile);
-    if (!existsSync15(dir)) {
-      mkdirSync8(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(resolve14(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 = existsSync15(workspacePath) ? this.readMemoryFile(workspacePath, "workspace") : [];
-    return [...globalEntries, ...workspaceEntries];
+  getProjectMemoryDir(cwd) {
+    if (this.customWorkspacePath) {
+      const dir2 = resolve14(this.customWorkspacePath);
+      if (!existsSync16(dir2)) {
+        try {
+          mkdirSync9(dir2, { recursive: true });
+        } catch {}
+      }
+      return dir2;
+    }
+    const slug = this.getProjectSlug(cwd);
+    const dir = join8(getProjectsDir(), slug, "memory");
+    if (!existsSync16(dir)) {
+      try {
+        mkdirSync9(dir, { recursive: true });
+      } catch {}
+    }
+    return dir;
+  }
+  getMemoryIndexPath(cwd) {
+    return join8(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 = join8(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(`
+`);
+    writeFileSync5(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 (!existsSync15(filePath))
-      return [];
+  readTopicMemory(topicNameOrFile, cwd) {
+    const memoryDir = this.getProjectMemoryDir(cwd);
+    let targetPath = join8(memoryDir, topicNameOrFile);
+    if (!existsSync16(targetPath)) {
+      if (!topicNameOrFile.endsWith(".md")) {
+        targetPath = join8(memoryDir, `${topicNameOrFile}.md`);
+      }
+    }
+    if (!existsSync16(targetPath)) {
+      const files = readdirSync6(memoryDir);
+      const match = files.find((f) => f.includes(topicNameOrFile));
+      if (match) {
+        targetPath = join8(memoryDir, match);
+      } else {
+        return null;
+      }
+    }
     try {
-      const content = readFileSync10(filePath, "utf8");
-      const lines = content.split(`
+      const raw = readFileSync10(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 = join8(memoryDir, "MEMORY.md");
+    const files = existsSync16(memoryDir) ? readdirSync6(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const items = [];
+    for (const f of files) {
+      try {
+        const full = join8(memoryDir, f);
+        const parsed = this.parseTopicFile(readFileSync10(full, "utf8"), full);
+        items.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 items) {
+      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);
+    writeFileSync5(indexPath, boundedLines.join(`
+`) + `
+`, "utf8");
+  }
+  loadMemoryIndex(cwd) {
+    const indexPath = this.getMemoryIndexPath(cwd);
+    if (!existsSync16(indexPath))
+      return "";
+    try {
+      const raw = readFileSync10(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 (!existsSync16(memoryDir))
+      return [];
+    const files = readdirSync6(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const list = [];
+    for (const f of files) {
+      try {
+        const full = join8(memoryDir, f);
+        list.push(this.parseTopicFile(readFileSync10(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;
     }
-    writeFileSync5(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/manager.ts
-import { resolve as resolve16, join as join7 } from "path";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6, readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve16, join as join9 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync6, readFileSync as readFileSync11 } from "fs";
 
 // src/worktree/git.ts
 import { resolve as resolve15 } from "path";
@@ -5321,15 +5696,15 @@ class WorktreeManager {
     const branchName = options.branch || `groupy/${taskId}`;
     const targetDir = options.worktreePath || (this.baseStorageDir ? resolve16(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve16(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
     const worktreeParent = resolve16(targetDir, "..");
-    if (!existsSync16(worktreeParent)) {
-      mkdirSync9(worktreeParent, { recursive: true });
+    if (!existsSync17(worktreeParent)) {
+      mkdirSync10(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 = join7(targetDir, "groupy-thread.json");
+    const metaPath = join9(targetDir, "groupy-thread.json");
     try {
       writeFileSync6(metaPath, JSON.stringify({
         version: 1,
@@ -5355,8 +5730,8 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join7(wt.path, "groupy-thread.json");
-      if (existsSync16(metaPath)) {
+      const metaPath = join9(wt.path, "groupy-thread.json");
+      if (existsSync17(metaPath)) {
         try {
           const raw = JSON.parse(readFileSync11(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
@@ -5434,7 +5809,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;
@@ -5587,7 +5962,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/cli/ui/colors.ts
@@ -6054,7 +6429,7 @@ function parsePatch(oldSrc, newSrc, contextLines = 3) {
 // package.json
 var package_default = {
   name: "@pikaa-ai/pikaa",
-  version: "0.3.14",
+  version: "0.3.15",
   description: "PIKAA CLI - AI coding agent that runs locally in your terminal.",
   main: "./dist/index.js",
   module: "./dist/index.js",
@@ -6132,7 +6507,7 @@ function getCliVersion(options = {}) {
 }
 
 // src/cli/ui/animation/banner-animation.ts
-import { homedir as homedir8 } from "os";
+import { homedir as homedir4 } from "os";
 import { execSync } from "child_process";
 var ROSE = "\x1B[38;2;205;105;74m";
 var ROSE_DIM = "\x1B[38;2;120;60;45m";
@@ -6142,7 +6517,7 @@ var BOLD = "\x1B[1m";
 var ITALIC = "\x1B[3m";
 var RESET = "\x1B[0m";
 function shortenPath(cwd) {
-  const home = homedir8();
+  const home = homedir4();
   if (cwd.startsWith(home)) {
     return `~${cwd.slice(home.length).replace(/\\/g, "/")}`;
   }
@@ -7520,8 +7895,8 @@ async function promptInteractiveList(config) {
 }
 
 // src/security/scanner.ts
-import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
-import { join as join8, relative as relative2, resolve as resolve17 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { join as join10, relative as relative2, resolve as resolve17 } from "path";
 var SECURITY_RULES = [
   {
     id: "SEC-001",
@@ -7659,21 +8034,21 @@ async function runSecurityScan(targetDir, options = {}) {
   const findings = [];
   let scannedCount = 0;
   function walk(current) {
-    if (scannedCount >= maxFiles || !existsSync17(current))
+    if (scannedCount >= maxFiles || !existsSync18(current))
       return;
     let entries;
     try {
-      entries = readdirSync5(current);
+      entries = readdirSync7(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join8(current, entry);
+      const fullPath = join10(current, entry);
       let stat;
       try {
-        stat = statSync3(fullPath);
+        stat = statSync4(fullPath);
       } catch {
         continue;
       }
@@ -7778,8 +8153,8 @@ var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/sqlite";
 var SQLITE_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
 
 // src/init/project-analyzer.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync6 } from "fs";
-import { join as join9, basename as basename2 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync13, readdirSync as readdirSync8 } from "fs";
+import { join as join11, basename as basename3 } from "path";
 
 class ProjectAnalyzer {
   cwd;
@@ -7797,8 +8172,8 @@ class ProjectAnalyzer {
     const architectureNotes = [];
     const codeConventions = [];
     let description = readmeInfo.description;
-    const pkgPath = join9(this.cwd, "package.json");
-    if (existsSync18(pkgPath)) {
+    const pkgPath = join11(this.cwd, "package.json");
+    if (existsSync19(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         if (!description && pkg.description)
@@ -7871,8 +8246,8 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const tsconfigPath = join9(this.cwd, "tsconfig.json");
-    if (existsSync18(tsconfigPath)) {
+    const tsconfigPath = join11(this.cwd, "tsconfig.json");
+    if (existsSync19(tsconfigPath)) {
       try {
         const tsconfig = JSON.parse(readFileSync13(tsconfigPath, "utf8"));
         if (tsconfig.compilerOptions?.strict) {
@@ -7883,8 +8258,8 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const cargoPath = join9(this.cwd, "Cargo.toml");
-    if (existsSync18(cargoPath)) {
+    const cargoPath = join11(this.cwd, "Cargo.toml");
+    if (existsSync19(cargoPath)) {
       try {
         commands.dev = commands.dev || "cargo run";
         commands.build = commands.build || "cargo build";
@@ -7893,8 +8268,8 @@ class ProjectAnalyzer {
         frameworks.push("Rust Cargo");
       } catch {}
     }
-    const goModPath = join9(this.cwd, "go.mod");
-    if (existsSync18(goModPath)) {
+    const goModPath = join11(this.cwd, "go.mod");
+    if (existsSync19(goModPath)) {
       try {
         commands.dev = commands.dev || "go run .";
         commands.build = commands.build || "go build ./...";
@@ -7903,37 +8278,37 @@ class ProjectAnalyzer {
         frameworks.push("Go Modules");
       } catch {}
     }
-    const pyprojectPath = join9(this.cwd, "pyproject.toml");
-    const requirementsPath = join9(this.cwd, "requirements.txt");
-    if (existsSync18(pyprojectPath) || existsSync18(requirementsPath)) {
+    const pyprojectPath = join11(this.cwd, "pyproject.toml");
+    const requirementsPath = join11(this.cwd, "requirements.txt");
+    if (existsSync19(pyprojectPath) || existsSync19(requirementsPath)) {
       commands.test = commands.test || "pytest";
       commands.lint = commands.lint || "ruff check .";
-      if (existsSync18(join9(this.cwd, "uv.lock"))) {
+      if (existsSync19(join11(this.cwd, "uv.lock"))) {
         frameworks.push("uv");
         commands.test = "uv run pytest";
-      } else if (existsSync18(join9(this.cwd, "poetry.lock"))) {
+      } else if (existsSync19(join11(this.cwd, "poetry.lock"))) {
         frameworks.push("Poetry");
         commands.test = "poetry run pytest";
       }
     }
-    if (existsSync18(join9(this.cwd, "Dockerfile"))) {
+    if (existsSync19(join11(this.cwd, "Dockerfile"))) {
       infrastructure.push("Docker");
       const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
       commands.dockerBuild = `docker build -t ${sanitizedName || "app"} .`;
     }
-    if (existsSync18(join9(this.cwd, "nginx.conf"))) {
+    if (existsSync19(join11(this.cwd, "nginx.conf"))) {
       infrastructure.push("Nginx");
     }
-    if (existsSync18(join9(this.cwd, "src/api.ts")) || existsSync18(join9(this.cwd, "src/api"))) {
+    if (existsSync19(join11(this.cwd, "src/api.ts")) || existsSync19(join11(this.cwd, "src/api"))) {
       architectureNotes.push("Backend API endpoints and network client logic are centralized in `src/api`.");
     }
-    if (existsSync18(join9(this.cwd, "src/components"))) {
+    if (existsSync19(join11(this.cwd, "src/components"))) {
       architectureNotes.push("Reusable UI presentation components live in `src/components/`.");
     }
-    if (existsSync18(join9(this.cwd, "src/types.ts")) || existsSync18(join9(this.cwd, "src/types"))) {
+    if (existsSync19(join11(this.cwd, "src/types.ts")) || existsSync19(join11(this.cwd, "src/types"))) {
       architectureNotes.push("Shared TypeScript data models and interfaces are defined in `src/types`.");
     }
-    if (existsSync18(join9(this.cwd, ".env.example"))) {
+    if (existsSync19(join11(this.cwd, ".env.example"))) {
       architectureNotes.push("Environment configuration template is in `.env.example`.");
     }
     if (commands.typecheck || commands.lint || commands.test) {
@@ -7950,7 +8325,7 @@ class ProjectAnalyzer {
     let hasExistingInstructions = false;
     let existingInstructionFile;
     for (const f of instructionFiles) {
-      if (existsSync18(join9(this.cwd, f))) {
+      if (existsSync19(join11(this.cwd, f))) {
         hasExistingInstructions = true;
         existingInstructionFile = f;
         break;
@@ -8031,8 +8406,8 @@ class ProjectAnalyzer {
   extractReadmeMetadata() {
     const readmeFiles = ["README.md", "readme.md", "README.MD"];
     for (const file of readmeFiles) {
-      const fullPath = join9(this.cwd, file);
-      if (existsSync18(fullPath)) {
+      const fullPath = join11(this.cwd, file);
+      if (existsSync19(fullPath)) {
         try {
           const content = readFileSync13(fullPath, "utf8");
           const lines = content.split(`
@@ -8057,8 +8432,8 @@ class ProjectAnalyzer {
     return {};
   }
   detectProjectName() {
-    const pkgPath = join9(this.cwd, "package.json");
-    if (existsSync18(pkgPath)) {
+    const pkgPath = join11(this.cwd, "package.json");
+    if (existsSync19(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         if (pkg.name && pkg.name !== "frontend" && pkg.name !== "backend" && pkg.name !== "app") {
@@ -8066,73 +8441,73 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const cargoPath = join9(this.cwd, "Cargo.toml");
-    if (existsSync18(cargoPath)) {
+    const cargoPath = join11(this.cwd, "Cargo.toml");
+    if (existsSync19(cargoPath)) {
       try {
         const match = readFileSync13(cargoPath, "utf8").match(/name\s*=\s*"([^"]+)"/);
         if (match?.[1])
           return match[1];
       } catch {}
     }
-    const goModPath = join9(this.cwd, "go.mod");
-    if (existsSync18(goModPath)) {
+    const goModPath = join11(this.cwd, "go.mod");
+    if (existsSync19(goModPath)) {
       try {
         const match = readFileSync13(goModPath, "utf8").match(/module\s+([^\s]+)/);
         if (match?.[1])
-          return basename2(match[1]);
+          return basename3(match[1]);
       } catch {}
     }
-    return basename2(this.cwd);
+    return basename3(this.cwd);
   }
   detectLanguages() {
     const langs = new Set;
-    if (existsSync18(join9(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
+    if (existsSync19(join11(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
       langs.add("TypeScript");
     }
-    if (existsSync18(join9(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
+    if (existsSync19(join11(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
       langs.add("JavaScript");
     }
-    if (existsSync18(join9(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
+    if (existsSync19(join11(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
       langs.add("Rust");
     }
-    if (existsSync18(join9(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
+    if (existsSync19(join11(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
       langs.add("Go");
     }
-    if (existsSync18(join9(this.cwd, "pyproject.toml")) || existsSync18(join9(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
+    if (existsSync19(join11(this.cwd, "pyproject.toml")) || existsSync19(join11(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
       langs.add("Python");
     }
-    if (existsSync18(join9(this.cwd, "pom.xml")) || existsSync18(join9(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
+    if (existsSync19(join11(this.cwd, "pom.xml")) || existsSync19(join11(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
       langs.add("Java");
     }
-    if (existsSync18(join9(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
+    if (existsSync19(join11(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
       langs.add("C/C++");
     }
     return Array.from(langs);
   }
   detectPackageManager() {
-    if (existsSync18(join9(this.cwd, "bun.lockb")) || existsSync18(join9(this.cwd, "bun.lock")))
+    if (existsSync19(join11(this.cwd, "bun.lockb")) || existsSync19(join11(this.cwd, "bun.lock")))
       return "bun";
-    if (existsSync18(join9(this.cwd, "pnpm-lock.yaml")))
+    if (existsSync19(join11(this.cwd, "pnpm-lock.yaml")))
       return "pnpm";
-    if (existsSync18(join9(this.cwd, "yarn.lock")))
+    if (existsSync19(join11(this.cwd, "yarn.lock")))
       return "yarn";
-    if (existsSync18(join9(this.cwd, "package-lock.json")))
+    if (existsSync19(join11(this.cwd, "package-lock.json")))
       return "npm";
-    if (existsSync18(join9(this.cwd, "Cargo.lock")) || existsSync18(join9(this.cwd, "Cargo.toml")))
+    if (existsSync19(join11(this.cwd, "Cargo.lock")) || existsSync19(join11(this.cwd, "Cargo.toml")))
       return "cargo";
-    if (existsSync18(join9(this.cwd, "uv.lock")))
+    if (existsSync19(join11(this.cwd, "uv.lock")))
       return "uv";
-    if (existsSync18(join9(this.cwd, "poetry.lock")))
+    if (existsSync19(join11(this.cwd, "poetry.lock")))
       return "poetry";
-    if (existsSync18(join9(this.cwd, "go.sum")) || existsSync18(join9(this.cwd, "go.mod")))
+    if (existsSync19(join11(this.cwd, "go.sum")) || existsSync19(join11(this.cwd, "go.mod")))
       return "go";
-    if (existsSync18(join9(this.cwd, "package.json")))
+    if (existsSync19(join11(this.cwd, "package.json")))
       return "npm";
     return;
   }
   hasFileWithExtension(...exts) {
     try {
-      const entries = readdirSync6(this.cwd);
+      const entries = readdirSync8(this.cwd);
       return entries.some((e) => exts.some((ext) => e.endsWith(ext)));
     } catch {
       return false;
@@ -8140,16 +8515,16 @@ class ProjectAnalyzer {
   }
 }
 // src/init/init-command.ts
-import { existsSync as existsSync19, writeFileSync as writeFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync20, writeFileSync as writeFileSync7 } from "fs";
+import { join as join12 } from "path";
 function runProjectInit(options = {}) {
   const cwd = options.cwd || process.cwd();
   const filename = options.filename || "AGENTS.md";
-  const targetPath = join10(cwd, filename);
+  const targetPath = join12(cwd, filename);
   const analyzer = new ProjectAnalyzer(cwd);
   const analysis = analyzer.analyze();
   const content = analyzer.generateAgentsMarkdown(analysis);
-  const alreadyExists = existsSync19(targetPath);
+  const alreadyExists = existsSync20(targetPath);
   writeFileSync7(targetPath, content, "utf8");
   return {
     success: true,
@@ -8524,7 +8899,7 @@ Browser authorization opened automatically. If not, open:`);
     console.log(style.dim(`Waiting for authorization callback on port 1455 ...`));
     const creds = await waitForToken();
     console.log(style.green(`
-\u2713 Authentication Successful! Token saved to ~/.groupy/credentials.json`));
+\u2713 Authentication Successful! Token saved to ~/.pikaa/credentials.json`));
     console.log(style.dim(`  Gateway Base URL: ${creds.baseUrl}`));
   } catch (err) {
     console.log(style.yellow(`
@@ -8542,7 +8917,7 @@ Falling back to Direct Terminal Login:`));
         password
       });
       console.log(style.green(`
-\u2713 Successfully logged in! Token saved to ~/.groupy/credentials.json`));
+\u2713 Successfully logged in! Token saved to ~/.pikaa/credentials.json`));
       console.log(style.dim(`  Gateway Base URL: ${creds.baseUrl}`));
     } catch (directErr) {
       console.error(style.red(`
@@ -8755,7 +9130,7 @@ async function handleSkillsCommand(ctx, args) {
   const skills = loader.listSkills(ctx.session.cwd, { includeDisabled: true });
   if (skills.length === 0) {
     console.log(style.dim(`
-  No domain skills discovered in .agents/skills/ or ~/.groupy/skills/
+  No domain skills discovered in .agents/skills/ or ~/.pikaa/skills/
 `));
     return;
   }
@@ -8811,17 +9186,51 @@ async function handleSkillsCommand(ctx, args) {
 function printMemories(ctx) {
   const store2 = ctx.memoryStore;
   if (!store2) {
-    console.log(style.yellow("Memory store not active."));
+    console.log(style.yellow(`
+  Memory store not active.
+`));
     return;
   }
-  const memories = store2.getAllMemories(ctx.session.cwd);
+  const cwd = ctx.session.cwd;
+  const memoryDir = store2.getProjectMemoryDir(cwd);
+  const topics = store2.listProjectMemories(cwd);
+  const indexContent = store2.loadMemoryIndex(cwd);
+  const BOLD2 = "\x1B[1m";
+  const RESET2 = "\x1B[0m";
+  const DIM = "\x1B[2m";
+  const CYAN = "\x1B[38;2;120;190;255m";
+  const GREEN = "\x1B[38;2;140;220;140m";
+  const ORANGE = "\x1B[38;2;217;119;87m";
+  const PURPLE = "\x1B[38;2;190;140;240m";
+  const YELLOW = "\x1B[38;2;250;210;110m";
+  const getCategoryColor = (cat) => {
+    switch (cat.toLowerCase()) {
+      case "user":
+        return CYAN;
+      case "feedback":
+        return GREEN;
+      case "project":
+        return ORANGE;
+      case "reference":
+        return PURPLE;
+      default:
+        return YELLOW;
+    }
+  };
   console.log();
-  if (memories.length === 0) {
-    console.log(style.dim("  No persistent memories recorded yet."));
+  console.log(`  ${BOLD2}\uD83E\uDDE0 Project Auto-Memory Bank${RESET2}`);
+  console.log(`  ${DIM}Directory: ${memoryDir}${RESET2}`);
+  console.log(`  ${DIM}Status: ${GREEN}Active (Loaded into turn context \u2264200 lines)${RESET2}`);
+  console.log();
+  if (topics.length === 0) {
+    console.log(`  ${DIM}No persistent topic memories saved for this project yet.${RESET2}`);
+    console.log(`  ${DIM}As you work, Pikaa automatically records user preferences, feedback, and project context.${RESET2}`);
   } else {
-    console.log(style.bold("  Learned Preferences & Memories:"));
-    for (const m of memories) {
-      console.log(`    \u2022 [${style.cyan(m.category)}] (${style.dim(m.scope)}): ${m.content}`);
+    console.log(`  ${BOLD2}Learned Memory Topics (${topics.length}):${RESET2}`);
+    for (const t of topics) {
+      const color = getCategoryColor(t.type);
+      console.log(`    \u2022 ${color}[${t.type}]${RESET2} ${BOLD2}${t.name}${RESET2}: ${DIM}${t.description || t.content.split(`
+`)[0]}${RESET2}`);
     }
   }
   console.log();
@@ -9201,7 +9610,7 @@ function printReleaseNotes() {
     "",
     "  " + BOLD2 + WHITE2 + "\uD83D\uDE80 What's New in " + version + " (Latest)" + RESET2,
     "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Persistent Default AI Model" + RESET2 + ": Switch via " + ROSE2 + "/model" + RESET2 + " and save",
-    "    preference across sessions in ~/.groupy/credentials.json.",
+    "    preference across sessions in ~/.pikaa/credentials.json.",
     "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Real-time Git Branch Detection" + RESET2 + ": Header displays active branch",
     "    (\uE0A0 main) alongside user subscription tier (Groupy Pro / Max).",
     "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Claude Code Terminal UI Parity" + RESET2 + ": Authentic pixel emblem, fieldset",
@@ -9580,9 +9989,9 @@ class MarkdownHighlighter {
 }
 
 // src/cli/update-checker.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join13 } from "path";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 function parseSemver(v) {
   const clean = v.replace(/^v/, "").trim();
@@ -9603,8 +10012,8 @@ function isNewerVersion(current, remote) {
   return remPatch > curPatch;
 }
 function getUpdateCachePath() {
-  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join11(homedir9(), ".pikaa");
-  return join11(baseDir, "update-cache.json");
+  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join13(homedir5(), ".pikaa");
+  return join13(baseDir, "update-cache.json");
 }
 async function fetchLatestNpmVersion(packageName, timeoutMs = 1500) {
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
@@ -9637,7 +10046,7 @@ async function checkForUpdates(options = {}) {
   const cachePath = options.cachePath || getUpdateCachePath();
   const now = Date.now();
   let cached = null;
-  if (!options.force && existsSync20(cachePath)) {
+  if (!options.force && existsSync21(cachePath)) {
     try {
       const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
       if (raw && typeof raw.lastChecked === "number" && typeof raw.latestVersion === "string") {
@@ -9667,9 +10076,9 @@ async function checkForUpdates(options = {}) {
     return null;
   }
   try {
-    const parentDir = join11(cachePath, "..");
-    if (!existsSync20(parentDir)) {
-      mkdirSync10(parentDir, { recursive: true });
+    const parentDir = join13(cachePath, "..");
+    if (!existsSync21(parentDir)) {
+      mkdirSync11(parentDir, { recursive: true });
     }
     const cacheData = {
       lastChecked: now,
@@ -10091,7 +10500,7 @@ async function main() {
     resolve21(cwd, "mcp_config.json")
   ].filter(Boolean);
   for (const cfg of candidateConfigs) {
-    if (existsSync21(cfg)) {
+    if (existsSync22(cfg)) {
       try {
         await mcpManager.loadConfigFile(cfg);
         mcpManager.registerToolsIntoRouter(tools4);
@@ -10205,7 +10614,7 @@ Open the following link in your browser to complete authorization:`);
 Waiting for browser callback on http://localhost:1455/auth/callback ...`));
     const creds = await waitForToken();
     console.log(style.green(`
-\u2713 Authentication Successful! Token saved to ~/.groupy/credentials.json`));
+\u2713 Authentication Successful! Token saved to ~/.pikaa/credentials.json`));
     console.log(style.dim(`  Gateway Base URL: ${creds.baseUrl}`));
   } catch (err) {
     console.log(style.yellow(`
@@ -10224,7 +10633,7 @@ Falling back to Direct Terminal Login:`));
         password: password.trim()
       });
       console.log(style.green(`
-\u2713 Successfully logged in! Token saved to ~/.groupy/credentials.json`));
+\u2713 Successfully logged in! Token saved to ~/.pikaa/credentials.json`));
       console.log(style.dim(`  Gateway Base URL: ${creds.baseUrl}`));
     } catch (directErr) {
       rl.close();
@@ -10298,7 +10707,7 @@ function printSkillsList(loader, cwd) {
   const skills = loader.discoverSkills(cwd);
   console.log();
   if (skills.length === 0) {
-    console.log(style.dim("No skills found in .agents/skills/ or ~/.groupy/skills/"));
+    console.log(style.dim("No skills found in .agents/skills/ or ~/.pikaa/skills/"));
   } else {
     console.log(style.bold("Discovered Domain Skills:"));
     for (const s of skills) {