npm - @pikaa-ai/pikaa - Versions diffs - 0.3.14 → 0.3.16 - Mend

@pikaa-ai/pikaa 0.3.14 → 0.3.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/cli.js +801 -387
package/dist/index.js +698 -319
package/package.json +1 -1
package/templates/base/groupy_prompt.md +14 -0

package/dist/cli.js CHANGED Viewed

@@ -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.16",
   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, "/")}`;
   }
@@ -6690,8 +7065,8 @@ class InteractiveLineEditor {
       let cursor = 0;
       let selectedIndex = 0;
       let scrollTop = 0;
-      let renderedMenuLines = 0;
       let popupDismissed = false;
+      let lastCursorRowFromTop = 0;
       if (process.stdin.isTTY) {
         try {
           process.stdin.setRawMode(true);
@@ -6754,20 +7129,21 @@ class InteractiveLineEditor {
         if (scrollTop > maxScroll)
           scrollTop = maxScroll;
       };
-      const clearMenu = () => {
-        if (renderedMenuLines > 0) {
-          process.stdout.write("\x1B[J");
-          renderedMenuLines = 0;
-        }
-      };
       const redraw = () => {
-        process.stdout.write("\x1B[J");
-        process.stdout.write(`\r\x1B[2K${this.promptSymbol}${buffer}`);
+        const termCols = getTerminalCols();
+        const visiblePromptWidth = this.promptSymbol.replace(/\x1b\[[0-9;]*m/g, "").length;
+        if (lastCursorRowFromTop > 0) {
+          process.stdout.write(`\x1B[${lastCursorRowFromTop}A`);
+        }
+        process.stdout.write("\r\x1B[J");
+        process.stdout.write(`${this.promptSymbol}${buffer}`);
+        const totalPromptChars = visiblePromptWidth + buffer.length;
+        const promptRows = Math.max(1, Math.floor(totalPromptChars / termCols) + 1);
         const slashMatches = getMatchingCommands();
         const activeFile = getActiveFileQuery();
         const fileMatches = activeFile ? getMatchingFiles(activeFile.query) : [];
+        let menuRows = 0;
         if (buffer.startsWith("/") && !popupDismissed && slashMatches.length > 0) {
-          const termCols = getTerminalCols();
           const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(slashMatches.length, 7);
           ensureVisible(slashMatches.length, maxVisible);
@@ -6798,10 +7174,8 @@ class InteractiveLineEditor {
             process.stdout.write(`
 \x1B[2K${line}`);
           }
-          renderedMenuLines = menuLines.length;
-          process.stdout.write(`\x1B[${renderedMenuLines}A`);
+          menuRows = menuLines.length;
         } else if (activeFile && !popupDismissed && fileMatches.length > 0) {
-          const termCols = getTerminalCols();
           const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(fileMatches.length, 7);
           ensureVisible(fileMatches.length, maxVisible);
@@ -6837,8 +7211,7 @@ class InteractiveLineEditor {
             process.stdout.write(`
 \x1B[2K${line}`);
           }
-          renderedMenuLines = menuLines.length;
-          process.stdout.write(`\x1B[${renderedMenuLines}A`);
+          menuRows = menuLines.length;
         } else {
           const RULE_COLOR2 = "\x1B[38;2;60;60;68m";
           const bottomRule = `  ${RULE_COLOR2}${getRule()}\x1B[0m`;
@@ -6846,16 +7219,20 @@ class InteractiveLineEditor {
           process.stdout.write(`
 \x1B[2K${bottomRule}
 \x1B[2K${modeLine}`);
-          renderedMenuLines = 2;
-          process.stdout.write(`\x1B[2A`);
+          menuRows = 2;
+        }
+        const cursorCharsFromTop = visiblePromptWidth + cursor;
+        const cursorRow = Math.floor(cursorCharsFromTop / termCols);
+        const cursorCol = cursorCharsFromTop % termCols;
+        const moveUpRows = promptRows - 1 - cursorRow + menuRows;
+        if (moveUpRows > 0) {
+          process.stdout.write(`\x1B[${moveUpRows}A`);
         }
-        const visiblePromptLength = this.promptSymbol.replace(/\x1b\[[0-9;]*m/g, "").length;
-        const cursorCol = visiblePromptLength + cursor;
+        process.stdout.write("\r");
         if (cursorCol > 0) {
-          process.stdout.write(`\r\x1B[${cursorCol}C`);
-        } else {
-          process.stdout.write("\r");
+          process.stdout.write(`\x1B[${cursorCol}C`);
         }
+        lastCursorRowFromTop = cursorRow;
       };
       const onResize = () => {
         redraw();
@@ -6867,19 +7244,22 @@ class InteractiveLineEditor {
         if (process.stdout && typeof process.stdout.removeListener === "function") {
           process.stdout.removeListener("resize", onResize);
         }
-        clearMenu();
         process.stdin.removeListener("keypress", onKeypress);
         if (process.stdin.isTTY) {
           try {
             process.stdin.setRawMode(false);
           } catch {}
         }
+        if (lastCursorRowFromTop > 0) {
+          process.stdout.write(`\x1B[${lastCursorRowFromTop}A`);
+        }
+        process.stdout.write("\r\x1B[J");
         if (result.trim().length > 0 && !result.startsWith("/")) {
-          process.stdout.write(`\x1B[1A\r\x1B[2K\x1B[J${CliFormatter.formatClaudeUserPrompt(result)}
+          process.stdout.write(`${CliFormatter.formatClaudeUserPrompt(result)}
 `);
         } else {
-          process.stdout.write(`\x1B[1A\r\x1B[2K\x1B[J
+          process.stdout.write(`
 `);
         }
         resolve17(result);
@@ -6900,7 +7280,10 @@ class InteractiveLineEditor {
           if (process.stdout && typeof process.stdout.removeListener === "function") {
             process.stdout.removeListener("resize", onResize);
           }
-          clearMenu();
+          if (lastCursorRowFromTop > 0) {
+            process.stdout.write(`\x1B[${lastCursorRowFromTop}A`);
+          }
+          process.stdout.write("\r\x1B[J");
           if (process.stdin.isTTY) {
             try {
               process.stdin.setRawMode(false);
@@ -6915,12 +7298,9 @@ class InteractiveLineEditor {
           process.exit(0);
         }
         if (key.name === "escape") {
-          if (renderedMenuLines > 0) {
-            popupDismissed = true;
-            clearMenu();
-            redraw();
-            return;
-          }
+          popupDismissed = true;
+          redraw();
+          return;
         }
         if (key.ctrl && key.name === "d") {
           cleanupAndResolve("/exit");
@@ -7520,8 +7900,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 +8039,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 +8158,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 +8177,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 +8251,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 +8263,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 +8273,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 +8283,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 +8330,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 +8411,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 +8437,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 +8446,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 +8520,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 +8904,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 +8922,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 +9135,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 +9191,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 +9615,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 +9994,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 +10017,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 +10051,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 +10081,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 +10505,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 +10619,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 +10638,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 +10712,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) {