agentcache 0.1.4 → 0.2.0

package/README.md

@@ -23,7 +23,7 @@ npm install -g agentcache
 Done. Start a new session in any IDE. AgentCache is already running.
 
 No `init`. No `setup`. No config. No second command. The install itself:
-1. Creates `~/.loop/loop.db` (your knowledge store)
+1. Creates `~/.agentcache/agentcache.db` (your knowledge store)
 2. Detects installed IDEs (Claude Code, Cursor, Roo Code, Windsurf, Continue, Codex)
 3. Registers itself as an MCP server in each
 4. Sets up Claude Code hooks for automatic transcript recovery
@@ -49,7 +49,8 @@ No `init`. No `setup`. No config. No second command. The install itself:
 │                 └────────────┬────────────┘                      │
 │                              │                                    │
 │                    ┌─────────┴─────────┐                         │
-│                    │  ~/.loop/loop.db   │                         │
+│                    │ ~/.agentcache/     │                         │
+│                    │  agentcache.db     │                         │
 │                    │  (SQLite + WAL)    │                         │
 │                    └───────────────────┘                         │
 └─────────────────────────────────────────────────────────────────┘
@@ -57,8 +58,8 @@ No `init`. No `setup`. No config. No second command. The install itself:
 
 ### The Cycle
 
-1. **Session starts** — agent calls `loop_inject_context` → gets compiled rules, lessons, decisions
-2. **During session** — agent calls `loop_compile_submit` incrementally as it learns things
+1. **Session starts** — agent calls `agentcache_inject_context` → gets compiled rules, lessons, decisions
+2. **During session** — agent calls `agentcache_compile_submit` incrementally as it learns things
 3. **Session ends** — knowledge is already saved. If agent didn't submit (abrupt exit), transcript recovery handles it next session.
 
 ### Knowledge Types
@@ -78,14 +79,14 @@ AgentCache exposes 8 tools via the Model Context Protocol:
 
 | Tool | Purpose |
 |------|---------|
-| `loop_inject_context` | Load compiled knowledge at session start |
-| `loop_compile_submit` | Submit observations incrementally during session |
-| `loop_compile_cluster` | Resolve clustering when observations overlap existing knowledge |
-| `loop_compile_extract` | Process queued transcripts from previous sessions |
-| `loop_enforce` | Check tool calls against enforced policy rules |
-| `loop_save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
-| `loop_get_knowledge` | Query the knowledge database |
-| `loop_deprecate_knowledge` | Mark knowledge as deprecated when it's no longer valid |
+| `agentcache_inject_context` | Load compiled knowledge at session start |
+| `agentcache_compile_submit` | Submit observations incrementally during session |
+| `agentcache_compile_cluster` | Resolve clustering when observations overlap existing knowledge |
+| `agentcache_compile_extract` | Process queued transcripts from previous sessions |
+| `agentcache_enforce` | Check tool calls against enforced policy rules |
+| `agentcache_save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
+| `agentcache_get_knowledge` | Query the knowledge database |
+| `agentcache_deprecate_knowledge` | Mark knowledge as deprecated when it's no longer valid |
 
 ## CLI Commands
 
@@ -114,7 +115,7 @@ AgentCache uses MCP (Model Context Protocol) as its only interface. Any IDE that
 
 ### Developer-Scoped
 
-One database per developer (`~/.loop/loop.db`), not per project. Rules and lessons learned in one project benefit all your projects. Project-specific decisions stay scoped to their project.
+One database per developer (`~/.agentcache/agentcache.db`), not per project. Rules and lessons learned in one project benefit all your projects. Project-specific decisions stay scoped to their project.
 
 ### Resilient to Abrupt Exits
 
@@ -154,11 +155,11 @@ Cursor does not support programmatic auto-approve for MCP tools. After installin
 
 ## Data Storage
 
-All data lives in `~/.loop/loop.db` (SQLite with WAL mode for concurrent access).
+All data lives in `~/.agentcache/agentcache.db` (SQLite with WAL mode for concurrent access).
 
 ```
-~/.loop/
-└── loop.db          # All knowledge, observations, sessions, pending queue
+~/.agentcache/
+└── agentcache.db    # All knowledge, observations, sessions, pending queue
 ```
 
 No data leaves your machine. No network calls. No telemetry. No accounts.
@@ -193,8 +194,8 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 ## Contributing
 
 ```bash
-git clone https://github.com/raghav-a21ai/loop-eng
-cd loop-eng
+git clone https://github.com/raghav-a21ai/agentcache
+cd agentcache
 npm install
 npm run build
 npm test

package/dist/{chunk-MKQKD2PY.js → chunk-LDQPTAZ7.js}

@@ -90,14 +90,14 @@ function isVscodeExtensionIde(ide) {
   return ide.name === "Roo Code" || ide.name === "Continue";
 }
 var ALL_TOOLS = [
-  "loop_inject_context",
-  "loop_compile_submit",
-  "loop_compile_cluster",
-  "loop_compile_extract",
-  "loop_enforce",
-  "loop_save_observation",
-  "loop_get_knowledge",
-  "loop_deprecate_knowledge"
+  "agentcache_inject_context",
+  "agentcache_compile_submit",
+  "agentcache_compile_cluster",
+  "agentcache_compile_extract",
+  "agentcache_enforce",
+  "agentcache_save_observation",
+  "agentcache_get_knowledge",
+  "agentcache_deprecate_knowledge"
 ];
 function registerMcpServer(ide) {
   if (!ide.detected) return false;
@@ -126,14 +126,17 @@ function registerClaudeCode() {
     }
   }
   if (!config.mcpServers) config.mcpServers = {};
-  if (config.mcpServers.agentcache) return false;
-  config.mcpServers.agentcache = {
-    type: "stdio",
-    command: "agentcache",
-    args: ["serve"],
-    env: {}
-  };
-  writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
+  let serverRegistered = false;
+  if (!config.mcpServers.agentcache) {
+    config.mcpServers.agentcache = {
+      type: "stdio",
+      command: "agentcache",
+      args: ["serve"],
+      env: {}
+    };
+    writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
+    serverRegistered = true;
+  }
   const settingsPath = join2(homedir2(), ".claude", "settings.json");
   if (existsSync2(join2(homedir2(), ".claude"))) {
     let settings = {};
@@ -148,14 +151,18 @@ function registerClaudeCode() {
     if (!settings.permissions.allow) settings.permissions.allow = [];
     const allowList = settings.permissions.allow;
     const mcpPerms = ALL_TOOLS.map((t) => `mcp__agentcache__${t}`);
+    let permsUpdated = false;
     for (const perm of mcpPerms) {
       if (!allowList.includes(perm)) {
         allowList.push(perm);
+        permsUpdated = true;
       }
     }
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    if (permsUpdated) {
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    }
   }
-  return true;
+  return serverRegistered;
 }
 function registerMcpJson(ide) {
   let config = {};
@@ -167,7 +174,7 @@ function registerMcpJson(ide) {
     }
   }
   if (!config.mcpServers) config.mcpServers = {};
-  if (config.mcpServers.agentcache) return false;
+  const existing = config.mcpServers.agentcache;
   if (isVscodeExtensionIde(ide)) {
     const nodeBin = findNodeBinary();
     const script = findAgentcacheScript();
@@ -177,16 +184,18 @@ function registerMcpJson(ide) {
       alwaysAllow: ALL_TOOLS,
       disabled: false
     };
-  } else {
+  } else if (!existing) {
     const agentcacheBin = findAgentcacheScript();
     config.mcpServers.agentcache = {
       command: agentcacheBin,
       args: ["serve"]
     };
+  } else {
+    return false;
   }
   mkdirSync(dirname(ide.mcpConfigPath), { recursive: true });
   writeFileSync(ide.mcpConfigPath, JSON.stringify(config, null, 2));
-  return true;
+  return !existing;
 }
 function registerContinue(ide) {
   const configPath = ide.mcpConfigPath;
@@ -245,17 +254,17 @@ function registerClaudeHooks() {
   }
   if (!settings.hooks) settings.hooks = {};
   const hooks = settings.hooks;
-  const loopHooks = {
+  const agentcacheHooks = {
     Stop: [{ matcher: "", hooks: [{ type: "command", command: "agentcache compile-session" }] }],
     SessionStart: [{ matcher: "", hooks: [{ type: "command", command: "agentcache discover" }] }],
     PreToolUse: [{ matcher: "", hooks: [{ type: "command", command: "agentcache enforce" }] }]
   };
   let registered = false;
-  for (const [event, hookConfig] of Object.entries(loopHooks)) {
+  for (const [event, hookConfig] of Object.entries(agentcacheHooks)) {
     if (!hooks[event]) hooks[event] = [];
     const existing = hooks[event];
-    const hasLoop = existing.some((h) => h.hooks?.some((hh) => hh.command?.includes("agentcache")));
-    if (!hasLoop) {
+    const hasAgentcache = existing.some((h) => h.hooks?.some((hh) => hh.command?.includes("agentcache")));
+    if (!hasAgentcache) {
       hooks[event].push(...hookConfig);
       registered = true;
     }

package/dist/{chunk-QGG25FWV.js → chunk-OSFK44XC.js}

@@ -1,7 +1,7 @@
 import {
   getClaudeTranscriptsDir,
   getContinueSessionsDir
-} from "./chunk-VPEEZXLK.js";
+} from "./chunk-WHP4Z32Z.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/{chunk-PYGRUQNL.js → chunk-T7BJPANN.js}

@@ -1,8 +1,8 @@
 // src/policy/engine.ts
 var HARDCODED_BLOCKS = [
-  { pattern: /git\s+push\s+--force\s+(origin\s+)?(main|master)/i, reason: "Force-push to main/master is blocked by Loop policy" },
-  { pattern: /rm\s+-rf\s+[\/~]/i, reason: "Destructive rm -rf on root or home is blocked by Loop policy" },
-  { pattern: />\s*(.*\.(env|pem|key))/i, reason: "Writing to sensitive files (.env, .pem, .key) is blocked by Loop policy" }
+  { pattern: /git\s+push\s+--force\s+(origin\s+)?(main|master)/i, reason: "Force-push to main/master is blocked by AgentCache policy" },
+  { pattern: /rm\s+-rf\s+[\/~]/i, reason: "Destructive rm -rf on root or home is blocked by AgentCache policy" },
+  { pattern: />\s*(.*\.(env|pem|key))/i, reason: "Writing to sensitive files (.env, .pem, .key) is blocked by AgentCache policy" }
 ];
 function evaluatePolicy(input, enforcedRules) {
   const command = extractCommand(input.tool_name, input.tool_input);

package/dist/{chunk-VPEEZXLK.js → chunk-WHP4Z32Z.js}

@@ -1,6 +1,6 @@
 // src/utils/paths.ts
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync, renameSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
 
@@ -26,15 +26,23 @@ function getGitRoot(cwd) {
 }
 
 // src/utils/paths.ts
-function getGlobalLoopDir() {
-  return join(homedir(), ".loop");
+function getDataDir() {
+  return join(homedir(), ".agentcache");
 }
 function getDbPath() {
-  return join(getGlobalLoopDir(), "loop.db");
+  return join(getDataDir(), "agentcache.db");
 }
-function isLoopInitialized() {
+function isInitialized() {
   return existsSync(getDbPath());
 }
+function migrateFromLegacy() {
+  const legacyDb = join(homedir(), ".loop", "loop.db");
+  const newDb = getDbPath();
+  if (existsSync(legacyDb) && !existsSync(newDb)) {
+    mkdirSync(dirname(newDb), { recursive: true });
+    renameSync(legacyDb, newDb);
+  }
+}
 function findProjectRoot(cwd) {
   const dir = cwd || process.cwd();
   const gitRoot = getGitRoot(dir);
@@ -57,9 +65,10 @@ function getContinueSessionsDir() {
 
 export {
   getGitContext,
-  getGlobalLoopDir,
+  getDataDir,
   getDbPath,
-  isLoopInitialized,
+  isInitialized,
+  migrateFromLegacy,
   findProjectRoot,
   getProjectId,
   getProjectDisplayName,

package/dist/cli.js

@@ -4,16 +4,16 @@
 import { Command } from "commander";
 var program = new Command();
 program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.0");
-program.command("setup").description("Detect IDEs and register Loop (runs automatically on install)").action(async () => {
-  const { runSetup } = await import("./setup-YHD2FO4N.js");
+program.command("setup").description("Detect IDEs and register AgentCache (runs automatically on install)").action(async () => {
+  const { runSetup } = await import("./setup-YCFTG2KT.js");
   await runSetup();
 });
-program.command("serve").description("Start Loop MCP server (spawned by IDEs automatically)").action(async () => {
+program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").action(async () => {
   const { startMcpServer } = await import("./mcp.js");
   await startMcpServer();
 });
 program.command("compile-session").description("Stop hook: queue transcript for compilation").action(async () => {
-  const { handleStop } = await import("./stop-DRL3LXFQ.js");
+  const { handleStop } = await import("./stop-6MKD743B.js");
   let payload;
   try {
     let data = "";
@@ -28,11 +28,11 @@ program.command("compile-session").description("Stop hook: queue transcript for
   await handleStop(payload);
 });
 program.command("discover").description("SessionStart hook: discover uncompiled transcripts").action(async () => {
-  const { handleSessionStart } = await import("./session-start-ILEPFZZC.js");
+  const { handleSessionStart } = await import("./session-start-BIY7CBXU.js");
   await handleSessionStart();
 });
 program.command("enforce").description("PreToolUse hook: policy enforcement").action(async () => {
-  const { handlePreToolUse } = await import("./pre-tool-use-2P5P6JWE.js");
+  const { handlePreToolUse } = await import("./pre-tool-use-TPCPTJXS.js");
   let data = "";
   for await (const chunk of process.stdin) {
     data += chunk;
@@ -45,10 +45,10 @@ program.command("enforce").description("PreToolUse hook: policy enforcement").ac
     process.stdout.write("{}");
   }
 });
-program.command("status").description("Show Loop knowledge stats").action(async () => {
-  const { getDbPath, isLoopInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-TWJ7GAJY.js");
-  if (!isLoopInitialized()) {
-    console.log("Loop not initialized. Run: agentcache setup");
+program.command("status").description("Show AgentCache knowledge stats").action(async () => {
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-LEZQCRKI.js");
+  if (!isInitialized()) {
+    console.log("AgentCache not initialized. Run: agentcache setup");
     return;
   }
   const { SqliteKnowledgeRepository } = await import("./sqlite-5V565IV3.js");
@@ -65,7 +65,7 @@ program.command("status").description("Show Loop knowledge stats").action(async
   const projectItems = items.filter((i) => i.scope === "project");
   const pending = repo.getPendingCount();
   repo.close();
-  console.log(`Loop \u2014 ${displayName} (${project})`);
+  console.log(`AgentCache \u2014 ${displayName} (${project})`);
   console.log(`  ${items.length} items (${globalItems.length} global, ${projectItems.length} project)`);
   console.log(`  ${rules.length} rules | ${lessons.length} lessons | ${decisions.length} decisions | ${context.length} context`);
   if (pending > 0) console.log(`  ${pending} sessions pending compilation`);

package/dist/mcp.js

@@ -1,16 +1,16 @@
 import {
   evaluatePolicy
-} from "./chunk-PYGRUQNL.js";
+} from "./chunk-T7BJPANN.js";
 import {
   parseTranscript
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   findProjectRoot,
   getDbPath,
   getGitContext,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -528,7 +528,7 @@ function saveCompileRun(repo, sessionId, project, observationsProcessed, autoRei
 }
 function formatDiagnostics(extracted, autoReinforced, created, reinforced, superseded, deprecated, ignored, project, sessionId) {
   return [
-    `Loop Compiler v${COMPILER_VERSION}`,
+    `AgentCache Compiler v${COMPILER_VERSION}`,
     `Project: ${project} | Session: ${sessionId}`,
     `  ${extracted} observations processed`,
     autoReinforced > 0 ? `  ${autoReinforced} auto-reinforced (no LLM needed)` : "",
@@ -570,7 +570,7 @@ async function startMcpServer() {
     { name: "agentcache", version: "0.1.0" },
     {
       capabilities: { tools: {} },
-      instructions: "AgentCache is your knowledge cache. At the START of every session, call loop_inject_context to load compiled rules, lessons, decisions, and context. Submit observations INCREMENTALLY via loop_compile_submit as you learn them \u2014 do not wait until session end."
+      instructions: "AgentCache is your knowledge cache. At the START of every session, call agentcache_inject_context to load compiled rules, lessons, decisions, and context. Submit observations INCREMENTALLY via agentcache_compile_submit as you learn them \u2014 do not wait until session end."
     }
   );
   server.oninitialized = async () => {
@@ -582,7 +582,7 @@ async function startMcpServer() {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
       {
-        name: "loop_inject_context",
+        name: "agentcache_inject_context",
         description: "Get compiled engineering knowledge for this project. Returns global rules/lessons (apply everywhere) + project-specific decisions/context. Call this at the START of every session.",
         inputSchema: {
           type: "object",
@@ -593,7 +593,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_submit",
+        name: "agentcache_compile_submit",
         description: "Submit observations extracted from your session. Call this INCREMENTALLY \u2014 each time you learn a rule, lesson, decision, or context item. Do NOT batch until end of session; sessions can terminate without warning.",
         inputSchema: {
           type: "object",
@@ -619,12 +619,12 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_cluster",
-        description: "Submit clustering decisions when loop_compile_submit returns needs_clustering. Determines whether observations create new knowledge or relate to existing items.",
+        name: "agentcache_compile_cluster",
+        description: "Submit clustering decisions when agentcache_compile_submit returns needs_clustering. Determines whether observations create new knowledge or relate to existing items.",
         inputSchema: {
           type: "object",
           properties: {
-            sessionId: { type: "string", description: "Session ID from loop_compile_submit response" },
+            sessionId: { type: "string", description: "Session ID from agentcache_compile_submit response" },
             clusters: {
               type: "array",
               items: {
@@ -644,8 +644,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_extract",
-        description: "For PREVIOUS sessions stored as transcript files. Reads a queued transcript and returns an extraction prompt for you to process. After processing, call loop_compile_submit with the results.",
+        name: "agentcache_compile_extract",
+        description: "For PREVIOUS sessions stored as transcript files. Reads a queued transcript and returns an extraction prompt for you to process. After processing, call agentcache_compile_submit with the results.",
         inputSchema: {
           type: "object",
           properties: {
@@ -655,8 +655,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_enforce",
-        description: "Check if a tool call is allowed by Loop's policy rules. Call this BEFORE executing risky operations (file deletions, force pushes, etc). Returns allow or block with reason.",
+        name: "agentcache_enforce",
+        description: "Check if a tool call is allowed by AgentCache policy rules. Call this BEFORE executing risky operations (file deletions, force pushes, etc). Returns allow or block with reason.",
         inputSchema: {
           type: "object",
           properties: {
@@ -668,7 +668,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_save_observation",
+        name: "agentcache_save_observation",
         description: "Save a single observation immediately with USER authority (never overwritten by compiler). Use for important rules or decisions that should persist permanently.",
         inputSchema: {
           type: "object",
@@ -683,8 +683,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_get_knowledge",
-        description: "Query knowledge items from Loop's compiled database.",
+        name: "agentcache_get_knowledge",
+        description: "Query knowledge items from AgentCache knowledge database.",
         inputSchema: {
           type: "object",
           properties: {
@@ -697,7 +697,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_deprecate_knowledge",
+        name: "agentcache_deprecate_knowledge",
         description: "Mark a knowledge item as deprecated. Use when a rule, lesson, or decision is no longer valid. Works on both auto-compiled and user-saved items.",
         inputSchema: {
           type: "object",
@@ -711,15 +711,15 @@ async function startMcpServer() {
     ]
   }));
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (!isLoopInitialized()) {
-      return { content: [{ type: "text", text: "Loop not initialized. Run: agentcache setup" }], isError: true };
+    if (!isInitialized()) {
+      return { content: [{ type: "text", text: "AgentCache not initialized. Run: agentcache setup" }], isError: true };
     }
     const repo = new SqliteKnowledgeRepository(getDbPath());
     const projectRoot = getResolvedProjectRoot();
     const detectedProject = getResolvedProjectId();
     try {
       switch (request.params.name) {
-        case "loop_inject_context": {
+        case "agentcache_inject_context": {
           const args = request.params.arguments || {};
           const project = args.project || detectedProject;
           const items = repo.getKnowledgeForContext(project);
@@ -740,17 +740,17 @@ async function startMcpServer() {
           if (context.length) {
             output += "# Context\n" + context.map((c) => `- ${c.content}`).join("\n") + "\n\n";
           }
-          if (!output) output = "No compiled knowledge yet. This will populate as you use Loop across sessions.\n";
+          if (!output) output = "No compiled knowledge yet. This will populate as you use AgentCache across sessions.\n";
           const pendingCount = repo.getPendingCount();
           if (pendingCount > 0) {
-            output = `<!-- ${pendingCount} previous session(s) pending compilation. Call loop_compile_extract to process. -->
+            output = `<!-- ${pendingCount} previous session(s) pending compilation. Call agentcache_compile_extract to process. -->
 
 ` + output;
           }
-          output += "\n---\nIMPORTANT: Submit observations incrementally as they happen during this session.\nWhen you learn something (rule, lesson, decision, context), call loop_compile_submit immediately.\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
+          output += "\n---\nIMPORTANT: Submit observations incrementally as they happen during this session.\nWhen you learn something (rule, lesson, decision, context), call agentcache_compile_submit immediately.\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
           return { content: [{ type: "text", text: output.trim() }] };
         }
-        case "loop_compile_submit": {
+        case "agentcache_compile_submit": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const sessionId = `sess_${randomUUID4().slice(0, 8)}`;
@@ -768,14 +768,14 @@ async function startMcpServer() {
             content: [{ type: "text", text: JSON.stringify({ status: "needs_clustering", sessionId: result.sessionId, clusteringContext: result.clusteringPrompt }) }]
           };
         }
-        case "loop_compile_cluster": {
+        case "agentcache_compile_cluster": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const responseText = JSON.stringify({ clusters: args.clusters });
           const result = processClustering(repo, responseText, args.sessionId, project, projectRoot);
           return { content: [{ type: "text", text: JSON.stringify({ status: "complete", diagnostics: result.diagnostics }) }] };
         }
-        case "loop_compile_extract": {
+        case "agentcache_compile_extract": {
           const args = request.params.arguments || {};
           const entry = repo.popPendingTranscript();
           if (!entry) {
@@ -793,14 +793,14 @@ async function startMcpServer() {
           const state = startCompile(events, sessionId, project, entry.projectRoot || projectRoot, repo, entry.transcriptPath);
           return { content: [{ type: "text", text: JSON.stringify({ sessionId: state.sessionId, prompt: state.prompt }) }] };
         }
-        case "loop_enforce": {
+        case "agentcache_enforce": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const input = { tool_name: args.tool_name, tool_input: args.tool_input || {} };
           const result = evaluatePolicy(input, repo.getEnforcedRules(project));
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
-        case "loop_save_observation": {
+        case "agentcache_save_observation": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const scope = args.scope || defaultScope(args.type);
@@ -849,7 +849,7 @@ async function startMcpServer() {
           });
           return { content: [{ type: "text", text: JSON.stringify({ saved: true, scope }) }] };
         }
-        case "loop_get_knowledge": {
+        case "agentcache_get_knowledge": {
           const args = request.params.arguments || {};
           const project = args.project || detectedProject;
           const items = repo.getKnowledgeItems(project, {
@@ -860,7 +860,7 @@ async function startMcpServer() {
           const summary = filtered.map((i) => `[${i.id}] [${i.scope}/${i.confidence}] (${i.type}) ${i.content}`).join("\n");
           return { content: [{ type: "text", text: summary || "No knowledge items found." }] };
         }
-        case "loop_deprecate_knowledge": {
+        case "agentcache_deprecate_knowledge": {
           const args = request.params.arguments;
           const item = repo.getKnowledgeItem(args.id);
           if (!item) {

package/dist/{paths-TWJ7GAJY.js → paths-LEZQCRKI.js}

@@ -2,20 +2,22 @@ import {
   findProjectRoot,
   getClaudeTranscriptsDir,
   getContinueSessionsDir,
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir,
   getProjectDisplayName,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized,
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import "./chunk-MLKGABMK.js";
 export {
   findProjectRoot,
   getClaudeTranscriptsDir,
   getContinueSessionsDir,
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir,
   getProjectDisplayName,
   getProjectId,
-  isLoopInitialized
+  isInitialized,
+  migrateFromLegacy
 };

package/dist/postinstall.js

@@ -2,11 +2,12 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-MKQKD2PY.js";
+} from "./chunk-LDQPTAZ7.js";
 import {
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir
-} from "./chunk-VPEEZXLK.js";
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -18,7 +19,8 @@ if (process.env.CI) {
   process.exit(0);
 }
 try {
-  mkdirSync(getGlobalLoopDir(), { recursive: true });
+  migrateFromLegacy();
+  mkdirSync(getDataDir(), { recursive: true });
   const repo = new SqliteKnowledgeRepository(getDbPath());
   repo.close();
   const ides = detectInstalledIdes().filter((i) => i.detected);

package/dist/{pre-tool-use-2P5P6JWE.js → pre-tool-use-TPCPTJXS.js}

@@ -1,12 +1,12 @@
 import {
   evaluatePolicy
-} from "./chunk-PYGRUQNL.js";
+} from "./chunk-T7BJPANN.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -14,7 +14,7 @@ import "./chunk-MLKGABMK.js";
 
 // src/hooks/pre-tool-use.ts
 function handlePreToolUse(input) {
-  if (!isLoopInitialized()) return {};
+  if (!isInitialized()) return {};
   const projectRoot = findProjectRoot();
   const repo = new SqliteKnowledgeRepository(getDbPath());
   try {

package/dist/{session-start-ILEPFZZC.js → session-start-BIY7CBXU.js}

@@ -1,12 +1,12 @@
 import {
   findAllClaudeTranscripts,
   findAllContinueTranscripts
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -25,7 +25,7 @@ function inferProjectRootFromTranscriptPath(path) {
   return dir;
 }
 async function handleSessionStart() {
-  if (!isLoopInitialized()) return;
+  if (!isInitialized()) return;
   const repo = new SqliteKnowledgeRepository(getDbPath());
   const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
   const allTranscripts = [

package/dist/{setup-YHD2FO4N.js → setup-YCFTG2KT.js}

@@ -2,11 +2,12 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-MKQKD2PY.js";
+} from "./chunk-LDQPTAZ7.js";
 import {
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir
-} from "./chunk-VPEEZXLK.js";
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -15,13 +16,14 @@ import "./chunk-MLKGABMK.js";
 // src/setup.ts
 import { mkdirSync } from "fs";
 async function runSetup() {
-  mkdirSync(getGlobalLoopDir(), { recursive: true });
+  migrateFromLegacy();
+  mkdirSync(getDataDir(), { recursive: true });
   const repo = new SqliteKnowledgeRepository(getDbPath());
   repo.close();
   const ides = detectInstalledIdes();
   const detected = ides.filter((i) => i.detected);
   console.log(`
-Loop setup complete.`);
+AgentCache setup complete.`);
   console.log(`  Central DB: ${getDbPath()}
 `);
   if (detected.length === 0) {
@@ -40,7 +42,7 @@ Loop setup complete.`);
   Claude Code hooks: registered (Stop, SessionStart, PreToolUse)`);
   }
   console.log(`
-Done. Loop compiles knowledge across all sessions and IDEs.`);
+Done. AgentCache compiles knowledge across all sessions and IDEs.`);
 }
 export {
   runSetup

package/dist/{stop-DRL3LXFQ.js → stop-6MKD743B.js}

@@ -1,12 +1,12 @@
 import {
   findLatestTranscript
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -15,7 +15,7 @@ import "./chunk-MLKGABMK.js";
 // src/hooks/stop.ts
 import { randomUUID } from "crypto";
 async function handleStop(payload) {
-  if (!isLoopInitialized()) return;
+  if (!isInitialized()) return;
   const transcriptPath = payload?.transcript_path || findLatestTranscript();
   if (!transcriptPath) return;
   const repo = new SqliteKnowledgeRepository(getDbPath());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcache",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Knowledge cache for AI agents — learns how you work, remembers across sessions, works everywhere",
   "type": "module",
   "license": "MIT",