agentcache 0.3.0 → 0.3.2

package/README.md

@@ -27,33 +27,43 @@ No `init`. No `setup`. No config. No second command. The install itself:
 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
+5. Spawns `compile-all` in background — compiles your entire transcript history from all IDEs immediately
 
 ## How It Works
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                        Your Machine                              │
-│                                                                  │
-│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
-│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...   │
-│  │   Code   │  │          │  │   Code   │  │          │       │
-│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
-│       │              │              │              │              │
-│       └──────────────┴──────────────┴──────────────┘              │
-│                              │                                    │
-│                    MCP Protocol (stdio)                           │
-│                              │                                    │
-│                 ┌────────────┴────────────┐                      │
-│                 │  AgentCache MCP Server   │                      │
-│                 │   (agentcache serve)     │                      │
-│                 └────────────┬────────────┘                      │
-│                              │                                    │
-│                    ┌─────────┴─────────┐                         │
-│                    │ ~/.agentcache/     │                         │
-│                    │  agentcache.db     │                         │
-│                    │  (SQLite + WAL)    │                         │
-│                    └───────────────────┘                         │
-└─────────────────────────────────────────────────────────────────┘
+┌────────────────────────────────────────────────────────────────────────┐
+│                           Your Machine                                 │
+│                                                                        │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐                │
+│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...           │
+│  │   Code   │  │          │  │   Code   │  │          │                │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘                │
+│       │             │             │             │                      │
+│       └─────────────┴─────────────┴─────────────┘                      │
+│                              │                                         │
+│                    MCP Protocol (stdio)                                │
+│                              │                                         │
+│                 ┌────────────┴────────────┐     ┌────────────────────┐ │
+│                 │  AgentCache MCP Server  │     │  agentcache        │ │
+│                 │   (agentcache serve)    │     │  compile-all       │ │
+│                 │                         │     │  (standalone CLI)  │ │
+│                 │  spawns compile-all ────┼────▶│                    │ │
+│                 │  when pending > 20      │     │  Uses: claude,     │ │
+│                 └────────────┬────────────┘     │  codex, gemini,    │ │
+│                              │                  │  ollama, API keys  │ │
+│                              │                  └─────────┬──────────┘ │
+│                              │                            │            │
+│                    ┌─────────┴────────────────────────────┘            │
+│                    │                                                   │
+│                    ▼                                                   │
+│           ┌────────────────────┐                                       │
+│           │ ~/.agentcache/     │                                       │
+│           │  agentcache.db     │                                       │
+│           │  compile-all.lock  │                                       │
+│           │  (SQLite + WAL)    │                                       │
+│           └────────────────────┘                                       │
+└────────────────────────────────────────────────────────────────────────┘
 ```
 
 ### The Cycle
@@ -92,9 +102,33 @@ AgentCache exposes 8 tools via the Model Context Protocol (prefixed as `mcp--age
 
 ```bash
 agentcache status          # Show knowledge stats for current project
+agentcache compile-all     # Batch-compile all unprocessed transcripts
 agentcache setup           # Re-register with IDEs (only if postinstall failed)
 ```
 
+### `compile-all` — Standalone Batch Compilation
+
+Processes all pending transcripts across every IDE without depending on MCP pipes or active sessions. Runs independently in a terminal.
+
+```bash
+agentcache compile-all
+```
+
+**LLM backend detection** (first available wins):
+1. CLI tools with stored auth: `claude`, `codex`, `gemini`, `copilot`, `aider`, `goose`
+2. Ollama running locally (`localhost:11434`)
+3. `ANTHROPIC_API_KEY` environment variable
+4. `OPENAI_API_KEY` environment variable
+
+No API keys needed if you have any coding CLI installed — it uses their stored authentication.
+
+**Automatic triggers:**
+- Runs as a background process after `npm install -g agentcache` (clears initial backlog)
+- Spawned by the MCP server when pending transcripts exceed 20 (ongoing janitor)
+- Lockfile (`~/.agentcache/compile-all.lock`) prevents concurrent runs
+
+**Transcript sources:** Claude Code, Continue, Codex, Roo Code, Goose
+
 Internal commands (called by hooks automatically, never by users):
 ```bash
 agentcache serve           # MCP server (IDEs spawn this)
@@ -119,9 +153,10 @@ One database per developer (`~/.agentcache/agentcache.db`), not per project. Rul
 
 ### Resilient to Abrupt Exits
 
-Sessions can end without warning (crash, ctrl-c, network drop). AgentCache handles this through:
+Sessions can end without warning (crash, ctrl-c, network drop, MCP pipe death). AgentCache handles this through:
 - **Incremental submission** — observations are saved as they happen, not batched at the end
-- **Transcript recovery** — for Claude Code and Continue, transcripts persist on disk and are compiled next session
+- **Transcript recovery** — transcripts persist on disk across 5 IDEs (Claude Code, Continue, Codex, Roo Code, Goose) and are compiled by `compile-all`
+- **Pipe-independent compilation** — `compile-all` runs as a standalone process, not through MCP stdio pipes that can break during long operations
 - **Pending queue in SQLite** — concurrent access is safe, nothing lost to race conditions
 
 ### Anti-Bloat
@@ -138,22 +173,70 @@ AgentCache prevents knowledge from growing unbounded:
 |-----|-----|-------------|--------------------|----|
 | Claude Code | Yes | Yes (automatic) | Full (JSONL) | Stop, SessionStart, PreToolUse |
 | Cursor | Yes | Yes (automatic) | Incremental only | — |
-| Roo Code | Yes | Yes (automatic) | Incremental only | — |
+| Roo Code | Yes | Yes (automatic) | Full (JSON via compile-all) | — |
 | Windsurf | Yes | Yes (automatic) | Incremental only | — |
 | Continue | Yes | Yes (automatic) | Full (JSON) | — |
-| Codex | Yes | Yes (automatic) | Incremental only | — |
+| Codex | Yes | Yes (automatic) | Full (JSONL via compile-all) | — |
+| Goose | — | — | Full (SQLite via compile-all) | — |
 
 All IDEs are fully auto-approved at install time — no manual steps required.
 
 "Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
 
+"via compile-all" means `agentcache compile-all` discovers and processes these transcripts in batch, independent of any active MCP session.
+
+## Skill Output (Agent Skills Spec)
+
+Compiled knowledge is automatically projected to SKILL.md files — the [Agent Skills open standard](https://agentskills.io) supported by 38+ tools (Claude Code, Cursor, Codex, Gemini CLI, Copilot, Roo Code, and more).
+
+```
+~/.agentcache/skills/developer-knowledge/SKILL.md    # Global: rules + lessons
+<repo>/.agentcache/skills/project-knowledge/SKILL.md  # Project: decisions + context
+```
+
+**Global skill** (`~/.agentcache/skills/`) — your developer identity. Rules and lessons learned across all projects. Auto-discovered by any Agent Skills-compatible tool without MCP.
+
+**Project skill** (`<repo>/.agentcache/skills/`) — project-specific decisions, context, and rules. Git-trackable. Team members get it on clone. **This is team knowledge sharing without a sync server — just git.**
+
+Skills auto-refresh on every compilation. Each file stays under 5,000 tokens (Agent Skills budget limit). High-confidence items appear first.
+
+Example output:
+```markdown
+---
+name: project-knowledge
+description: "Project-specific decisions, rules, context, and lessons — compiled automatically from coding sessions by AgentCache"
+---
+
+## Rules
+
+Follow these without exception:
+
+- Always use path aliases in imports
+- Never commit .env files [ENFORCED]
+
+## Decisions
+
+Architectural choices in effect — do not contradict:
+
+- Using Drizzle ORM over Prisma for raw SQL escape hatches
+- PostgreSQL for all persistent state, Redis for ephemeral cache only
+
+## Current Context
+
+Active project state (may be temporal):
+
+- Migrating from REST to GraphQL, both coexist until Q3
+```
+
 ## Data Storage
 
-All data lives in `~/.agentcache/agentcache.db` (SQLite with WAL mode for concurrent access).
+All data lives in `~/.agentcache/` (SQLite with WAL mode for concurrent access).
 
 ```
 ~/.agentcache/
-└── agentcache.db    # All knowledge, observations, sessions, pending queue
+├── agentcache.db                          # Knowledge, observations, sessions, pending queue
+├── compile-all.lock                       # Prevents concurrent compilation
+└── skills/developer-knowledge/SKILL.md    # Global skill (auto-generated)
 ```
 
 No data leaves your machine. No network calls. No telemetry. No accounts.
@@ -176,7 +259,13 @@ Extract → Normalize → Canonicalize → Cluster → Detect Contradictions →
                                                             - authority: AUTO/USER
 ```
 
-The compiler is the LLM itself (the agent in your session). AgentCache provides extraction prompts and the agent processes them — no separate API keys or LLM calls needed.
+**Two compilation paths:**
+- **In-session** — the agent in your IDE processes extraction prompts via MCP tools (no separate LLM calls needed)
+- **Batch (`compile-all`)** — runs independently using any available LLM CLI or API, processes the full backlog without depending on active sessions
+
+**Two output formats:**
+- **MCP injection** — structured context served to agents at session start via `inject_context`
+- **SKILL.md files** — Agent Skills spec-compliant files auto-discovered by 38+ tools without MCP
 
 ## Project Identity
 
@@ -197,7 +286,7 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 | Windsurf | Supported |
 | Continue | Supported |
 | Codex | Supported |
-| Goose (Block) | Coming soon |
+| Goose | Supported (transcript recovery via SQLite) |
 | Aider | Coming soon |
 | GitHub Copilot | Coming soon |
 | Zed AI | Coming soon |

package/dist/{chunk-IER56P6A.js → chunk-OXHITHDC.js}

@@ -1,7 +1,7 @@
 import {
   getDataDir,
   getGitContext
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 
 // src/knowledge/passes/3-canonicalizer.ts
 import { createHash } from "crypto";
@@ -428,6 +428,97 @@ function formatItems(items) {
   }).join("\n") + "\n";
 }
 
+// src/knowledge/passes/7b-skill-projector.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var MAX_SKILL_TOKENS = 5e3;
+var AVG_CHARS_PER_TOKEN = 4;
+var MAX_SKILL_CHARS = MAX_SKILL_TOKENS * AVG_CHARS_PER_TOKEN;
+function projectToSkills(items, projectRoot) {
+  const active = items.filter((i) => i.status === "active");
+  const globalItems = active.filter((i) => i.scope === "global");
+  const projectItems = active.filter((i) => i.scope === "project");
+  writeGlobalSkill(globalItems);
+  writeProjectSkill(projectItems, projectRoot);
+}
+function writeGlobalSkill(items) {
+  const skillDir = join(homedir(), ".agentcache", "skills", "developer-knowledge");
+  mkdirSync2(skillDir, { recursive: true });
+  const rules = items.filter((i) => i.type === "rule").sort(byConfidence);
+  const lessons = items.filter((i) => i.type === "lesson").sort(byConfidence);
+  const body = buildSkillBody(rules, lessons, [], []);
+  const content = buildSkillFile(
+    "developer-knowledge",
+    "Engineering rules and lessons learned across all projects \u2014 compiled automatically from coding sessions by AgentCache",
+    body
+  );
+  writeFileSync2(join(skillDir, "SKILL.md"), truncateToLimit(content), "utf-8");
+}
+function writeProjectSkill(items, projectRoot) {
+  if (!projectRoot || projectRoot === process.cwd()) return;
+  if (items.length === 0) return;
+  const skillDir = join(projectRoot, ".agentcache", "skills", "project-knowledge");
+  mkdirSync2(skillDir, { recursive: true });
+  const rules = items.filter((i) => i.type === "rule").sort(byConfidence);
+  const lessons = items.filter((i) => i.type === "lesson").sort(byConfidence);
+  const decisions = items.filter((i) => i.type === "decision").sort(byConfidence);
+  const context = items.filter((i) => i.type === "context").sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  const body = buildSkillBody(rules, lessons, decisions, context);
+  const content = buildSkillFile(
+    "project-knowledge",
+    "Project-specific decisions, rules, context, and lessons \u2014 compiled automatically from coding sessions by AgentCache",
+    body
+  );
+  writeFileSync2(join(skillDir, "SKILL.md"), truncateToLimit(content), "utf-8");
+}
+function buildSkillFile(name, description, body) {
+  return `---
+name: ${name}
+description: "${description}"
+---
+
+${body}`;
+}
+function buildSkillBody(rules, lessons, decisions, context) {
+  let out = "";
+  if (rules.length > 0) {
+    out += "## Rules\n\nFollow these without exception:\n\n";
+    out += rules.map((r) => `- ${r.content}${enforceTag(r)}`).join("\n") + "\n\n";
+  }
+  if (lessons.length > 0) {
+    out += "## Lessons\n\nPitfalls learned from past sessions:\n\n";
+    out += lessons.map((l) => `- ${l.content}`).join("\n") + "\n\n";
+  }
+  if (decisions.length > 0) {
+    out += "## Decisions\n\nArchitectural choices in effect \u2014 do not contradict:\n\n";
+    out += decisions.map((d) => `- ${d.content}`).join("\n") + "\n\n";
+  }
+  if (context.length > 0) {
+    out += "## Current Context\n\nActive project state (may be temporal):\n\n";
+    out += context.map((c) => `- ${c.content}`).join("\n") + "\n\n";
+  }
+  return out.trimEnd() + "\n";
+}
+function enforceTag(item) {
+  return item.enforce ? " [ENFORCED]" : "";
+}
+function byConfidence(a, b) {
+  const order = { high: 3, medium: 2, low: 1 };
+  return (order[b.confidence] || 0) - (order[a.confidence] || 0);
+}
+function truncateToLimit(content) {
+  if (content.length <= MAX_SKILL_CHARS) return content;
+  const lines = content.split("\n");
+  let result = "";
+  for (const line of lines) {
+    if ((result + line + "\n").length > MAX_SKILL_CHARS - 50) break;
+    result += line + "\n";
+  }
+  result += "\n<!-- Truncated to stay within 5000 token skill budget -->\n";
+  return result;
+}
+
 // src/knowledge/compiler.ts
 var COMPILER_VERSION = "0.1.0";
 function startCompile(events, sessionId, project, projectRoot, repo, transcriptPath) {
@@ -472,7 +563,9 @@ function processExtraction(repo, responseText, sessionId, project, projectRoot)
   repo.saveObservations(normalized);
   if (canonicalized.needsClustering.length === 0) {
     saveCompileRun(repo, sessionId, project, normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, Date.now());
-    projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+    const activeItems = repo.getKnowledgeItems(project, { status: "active" });
+    projectToMarkdown(activeItems, getDataDir(), COMPILER_VERSION);
+    projectToSkills(activeItems, projectRoot);
     return {
       status: "complete",
       diagnostics: formatDiagnostics(normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, project, sessionId)
@@ -539,7 +632,9 @@ function processClustering(repo, responseText, sessionId, project, projectRoot)
   }
   const totalObs = sessionObs.length;
   saveCompileRun(repo, sessionId, project, totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, startedAt);
-  projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+  const activeItems = repo.getKnowledgeItems(project, { status: "active" });
+  projectToMarkdown(activeItems, getDataDir(), COMPILER_VERSION);
+  projectToSkills(activeItems, projectRoot);
   return {
     status: "complete",
     diagnostics: formatDiagnostics(totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, project, sessionId)

package/dist/{chunk-TE6DBLJ5.js → chunk-QVQJPJGX.js}

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

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

@@ -8,12 +8,14 @@ import { createHash } from "crypto";
 import { execSync } from "child_process";
 function run(cmd, cwd) {
   try {
-    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
 }
 function getGitContext(projectRoot) {
+  const empty = { branch: "", commit: "", recentCommits: [], modifiedFiles: [] };
+  if (!run("git rev-parse --git-dir", projectRoot)) return empty;
   const branch = run("git rev-parse --abbrev-ref HEAD", projectRoot);
   const commit = run("git rev-parse --short HEAD", projectRoot);
   const recentCommits = run("git log --oneline -10", projectRoot).split("\n").filter(Boolean);

package/dist/{chunk-RXBTPJVW.js → chunk-VFE4SDMO.js}

@@ -1,6 +1,6 @@
 import {
   getDataDir
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 
 // src/utils/background-compile.ts
 import { spawn } from "child_process";

package/dist/{chunk-MMSMDJ4O.js → chunk-ZVDODLZ7.js}

@@ -128,6 +128,9 @@ var SqliteKnowledgeRepository = class {
     if (!row) return null;
     return this.mapSession(row);
   }
+  updateSessionTranscriptPath(sessionId, transcriptPath) {
+    this.db.prepare("UPDATE sessions SET transcript_path = ? WHERE id = ?").run(transcriptPath, sessionId);
+  }
   getCompiledTranscriptPaths(project) {
     const rows = this.db.prepare("SELECT transcript_path FROM sessions WHERE project = ? AND transcript_path != ''").all(project);
     return rows.map((r) => r.transcript_path);

package/dist/cli.js

@@ -3,9 +3,9 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.0");
+program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.1");
 program.command("setup").description("Detect IDEs and register AgentCache (runs automatically on install)").action(async () => {
-  const { runSetup } = await import("./setup-5APZETPV.js");
+  const { runSetup } = await import("./setup-TVNRAAK3.js");
   await runSetup();
 });
 program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").action(async () => {
@@ -13,7 +13,7 @@ program.command("serve").description("Start AgentCache MCP server (spawned by ID
   await startMcpServer();
 });
 program.command("compile-session").description("Stop hook: queue transcript for compilation").action(async () => {
-  const { handleStop } = await import("./stop-6SROS34Q.js");
+  const { handleStop } = await import("./stop-HFZZ2LFA.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-YSRUGD5N.js");
+  const { handleSessionStart } = await import("./session-start-SUR6FXRD.js");
   await handleSessionStart();
 });
 program.command("enforce").description("PreToolUse hook: policy enforcement").action(async () => {
-  const { handlePreToolUse } = await import("./pre-tool-use-OWWS54XG.js");
+  const { handlePreToolUse } = await import("./pre-tool-use-UBJFRHCW.js");
   let data = "";
   for await (const chunk of process.stdin) {
     data += chunk;
@@ -46,16 +46,16 @@ program.command("enforce").description("PreToolUse hook: policy enforcement").ac
   }
 });
 program.command("compile-all").description("Batch-compile all unprocessed transcripts using an available LLM CLI").action(async () => {
-  const { runCompileAll } = await import("./compile-all-RWCAU7MO.js");
+  const { runCompileAll } = await import("./compile-all-XQBGUI3F.js");
   await runCompileAll();
 });
 program.command("status").description("Show AgentCache knowledge stats").action(async () => {
-  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-LOLEIMI5.js");
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-ULP2T4HZ.js");
   if (!isInitialized()) {
     console.log("AgentCache not initialized. Run: agentcache setup");
     return;
   }
-  const { SqliteKnowledgeRepository } = await import("./sqlite-AUND6HGQ.js");
+  const { SqliteKnowledgeRepository } = await import("./sqlite-MP6SRBBQ.js");
   const repo = new SqliteKnowledgeRepository(getDbPath());
   const projectRoot = findProjectRoot();
   const project = getProjectId(projectRoot);

package/dist/{compile-all-RWCAU7MO.js → compile-all-XQBGUI3F.js}

@@ -2,11 +2,11 @@ import {
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-IER56P6A.js";
+} from "./chunk-OXHITHDC.js";
 import {
   acquireLock,
   releaseLock
-} from "./chunk-RXBTPJVW.js";
+} from "./chunk-VFE4SDMO.js";
 import {
   findAllClaudeTranscripts,
   findAllCodexTranscripts,
@@ -14,15 +14,15 @@ import {
   findAllRooCodeTranscripts,
   getGooseDbPath,
   parseTranscript
-} from "./chunk-TE6DBLJ5.js";
+} from "./chunk-QVQJPJGX.js";
 import {
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import {
   __esm,
   __export,
@@ -317,16 +317,18 @@ function processOneTranscript(repo, path, project, projectRoot, backend) {
   const events = parseTranscript(path);
   if (events.length < 3) return { created: 0, reinforced: 0, skipped: true };
   const sessionId = `sess_${randomUUID().slice(0, 8)}`;
-  const state = startCompile(events, sessionId, project, projectRoot, repo, path);
+  const state = startCompile(events, sessionId, project, projectRoot, repo);
   const extractionResponse = backend.invoke(state.prompt);
   if (!extractionResponse) return { created: 0, reinforced: 0, skipped: true };
   const extractResult = processExtraction(repo, extractionResponse, sessionId, project, projectRoot);
   if (extractResult.status === "complete") {
+    repo.updateSessionTranscriptPath(sessionId, path);
     return { created: 0, reinforced: 0, skipped: false };
   }
   const clusterResponse = backend.invoke(extractResult.clusteringPrompt);
   if (!clusterResponse) return { created: 0, reinforced: 0, skipped: true };
   const clusterResult = processClustering(repo, clusterResponse, sessionId, project, projectRoot);
+  repo.updateSessionTranscriptPath(sessionId, path);
   const diag = clusterResult.diagnostics;
   const createdMatch = diag.match(/(\d+) new knowledge/);
   const reinforcedMatch = diag.match(/(\d+) reinforced/);

package/dist/mcp.js

@@ -6,22 +6,22 @@ import {
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-IER56P6A.js";
+} from "./chunk-OXHITHDC.js";
 import {
   spawnCompileAll
-} from "./chunk-RXBTPJVW.js";
+} from "./chunk-VFE4SDMO.js";
 import {
   parseTranscript
-} from "./chunk-TE6DBLJ5.js";
+} from "./chunk-QVQJPJGX.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/mcp.ts

package/dist/{paths-LOLEIMI5.js → paths-ULP2T4HZ.js}

@@ -8,7 +8,7 @@ import {
   getProjectId,
   isInitialized,
   migrateFromLegacy
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import "./chunk-KFQGP6VL.js";
 export {
   findProjectRoot,

package/dist/postinstall.js

@@ -1,6 +1,6 @@
 import {
   spawnCompileAll
-} from "./chunk-RXBTPJVW.js";
+} from "./chunk-VFE4SDMO.js";
 import {
   detectInstalledIdes,
   registerClaudeHooks,
@@ -10,10 +10,10 @@ import {
   getDataDir,
   getDbPath,
   migrateFromLegacy
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/postinstall.ts

package/dist/{pre-tool-use-OWWS54XG.js → pre-tool-use-UBJFRHCW.js}

@@ -6,10 +6,10 @@ import {
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/pre-tool-use.ts

package/dist/{session-start-YSRUGD5N.js → session-start-SUR6FXRD.js}

@@ -3,15 +3,15 @@ import {
   findAllCodexTranscripts,
   findAllContinueTranscripts,
   findAllRooCodeTranscripts
-} from "./chunk-TE6DBLJ5.js";
+} from "./chunk-QVQJPJGX.js";
 import {
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/session-start.ts

package/dist/{setup-5APZETPV.js → setup-TVNRAAK3.js}

@@ -7,10 +7,10 @@ import {
   getDataDir,
   getDbPath,
   migrateFromLegacy
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/setup.ts

package/dist/{sqlite-AUND6HGQ.js → sqlite-MP6SRBBQ.js}

@@ -1,6 +1,6 @@
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 export {
   SqliteKnowledgeRepository

package/dist/{stop-6SROS34Q.js → stop-HFZZ2LFA.js}

@@ -1,15 +1,15 @@
 import {
   findLatestTranscript
-} from "./chunk-TE6DBLJ5.js";
+} from "./chunk-QVQJPJGX.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-WHP4Z32Z.js";
+} from "./chunk-S4GSIEKL.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-MMSMDJ4O.js";
+} from "./chunk-ZVDODLZ7.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/stop.ts

package/package.json

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