agentcache 0.3.4 → 0.4.1

package/dist/cli.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 var program = new Command();
 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-TVNRAAK3.js");
+  const { runSetup } = await import("./setup-45BVUDXN.js");
   await runSetup();
 });
 program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").action(async () => {
@@ -13,49 +13,270 @@ 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-HFZZ2LFA.js");
-  let payload;
   try {
-    let data = "";
-    for await (const chunk of process.stdin) {
-      data += chunk;
+    const { handleStop } = await import("./stop-TPCRE7RE.js");
+    let payload;
+    try {
+      let data = "";
+      for await (const chunk of process.stdin) {
+        data += chunk;
+      }
+      if (data.trim()) {
+        payload = JSON.parse(data);
+      }
+    } catch {
     }
-    if (data.trim()) {
-      payload = JSON.parse(data);
-    }
-  } catch {
+    await handleStop(payload);
+  } catch (err) {
+    process.stderr.write(`agentcache compile-session: ${err.message}
+`);
   }
-  await handleStop(payload);
 });
 program.command("discover").description("SessionStart hook: discover uncompiled transcripts").action(async () => {
-  const { handleSessionStart } = await import("./session-start-SUR6FXRD.js");
-  await handleSessionStart();
+  try {
+    const { handleSessionStart } = await import("./session-start-EIHYCS3J.js");
+    await handleSessionStart();
+  } catch (err) {
+    process.stderr.write(`agentcache discover: ${err.message}
+`);
+  }
 });
 program.command("enforce").description("PreToolUse hook: policy enforcement").action(async () => {
-  const { handlePreToolUse } = await import("./pre-tool-use-UBJFRHCW.js");
   let data = "";
   for await (const chunk of process.stdin) {
     data += chunk;
   }
   try {
+    const { handlePreToolUse } = await import("./pre-tool-use-7F7NTHCS.js");
     const input = JSON.parse(data);
     const result = handlePreToolUse(input);
     process.stdout.write(JSON.stringify(result));
-  } catch {
+  } catch (err) {
+    process.stderr.write(`agentcache enforce: ${err.message}
+`);
     process.stdout.write("{}");
   }
 });
+program.command("review").description("Review quarantined observations \u2014 approve or reject before they're injected").option("--approve-all", "Approve all pending items").option("--reject-all", "Reject (archive) all pending items").action(async (opts) => {
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId } = await import("./paths-5LZRKNYY.js");
+  if (!isInitialized()) {
+    console.log("AgentCache not initialized. Run: agentcache setup");
+    return;
+  }
+  const { SqliteKnowledgeRepository } = await import("./sqlite-NM2BVHUY.js");
+  const repo = new SqliteKnowledgeRepository(getDbPath());
+  const project = getProjectId(findProjectRoot());
+  const items = repo.getQuarantinedItems(project);
+  if (items.length === 0) {
+    console.log("No quarantined items. All observations are either approved or auto-promoted.");
+    repo.close();
+    return;
+  }
+  if (opts.approveAll) {
+    for (const item of items) {
+      repo.promoteItem(item.id);
+    }
+    console.log(`Approved ${items.length} items. They will now be injected into future sessions.`);
+    repo.close();
+    return;
+  }
+  if (opts.rejectAll) {
+    for (const item of items) {
+      repo.updateKnowledgeItem(item.id, { status: "archived", updatedAt: Date.now() });
+    }
+    console.log(`Rejected ${items.length} items. They will not be injected.`);
+    repo.close();
+    return;
+  }
+  console.log(`${items.length} quarantined observation(s):
+`);
+  for (const item of items) {
+    const age = Math.round((Date.now() - item.createdAt) / (1e3 * 60 * 60));
+    console.log(`  [${item.id}] (${item.type}/${item.scope}) ${age}h ago`);
+    console.log(`    ${item.content.slice(0, 120)}`);
+    console.log("");
+  }
+  console.log("Actions:");
+  console.log("  agentcache review --approve-all    Approve all and inject into sessions");
+  console.log("  agentcache review --reject-all     Archive all (won't be injected)");
+  console.log("  agentcache promote <id>            Approve a specific item");
+  repo.close();
+});
+program.command("promote <id>").description("Promote a specific quarantined item to approved (USER authority)").action(async (id) => {
+  const { getDbPath, isInitialized } = await import("./paths-5LZRKNYY.js");
+  if (!isInitialized()) {
+    console.log("AgentCache not initialized. Run: agentcache setup");
+    return;
+  }
+  const { SqliteKnowledgeRepository } = await import("./sqlite-NM2BVHUY.js");
+  const repo = new SqliteKnowledgeRepository(getDbPath());
+  const item = repo.getKnowledgeItem(id);
+  if (!item) {
+    console.log(`Item not found: ${id}`);
+    repo.close();
+    return;
+  }
+  repo.promoteItem(id);
+  console.log(`Promoted: ${item.content.slice(0, 80)}`);
+  repo.close();
+});
+program.command("add-rule <content>").description("Add an enforced policy rule (human-only, blocks tool calls that violate it)").option("--global", "Apply to all projects (default: current project only)").action(async (content, opts) => {
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId } = await import("./paths-5LZRKNYY.js");
+  const { randomUUID } = await import("crypto");
+  if (!isInitialized()) {
+    console.log("AgentCache not initialized. Run: agentcache setup");
+    return;
+  }
+  const { SqliteKnowledgeRepository } = await import("./sqlite-NM2BVHUY.js");
+  const { computeCanonicalHash } = await import("./3-canonicalizer-HIN2F7SZ.js");
+  const repo = new SqliteKnowledgeRepository(getDbPath());
+  const project = getProjectId(findProjectRoot());
+  const scope = opts.global ? "global" : "project";
+  repo.saveKnowledgeItem({
+    id: `ki_${randomUUID().slice(0, 8)}`,
+    canonicalHash: computeCanonicalHash(content),
+    type: "rule",
+    title: content.slice(0, 80),
+    content,
+    confidence: "high",
+    observationCount: 1,
+    authority: "USER",
+    status: "active",
+    enforce: true,
+    project,
+    scope,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    lastSeenAt: Date.now(),
+    metadata: { source: "cli" }
+  });
+  console.log(`Enforced rule added (${scope}): ${content}`);
+  repo.close();
+});
+program.command("doctor").description("Diagnose AgentCache installation and report problems").action(async () => {
+  const { existsSync, readFileSync } = await import("fs");
+  const { join } = await import("path");
+  const { homedir } = await import("os");
+  const { spawnSync } = await import("child_process");
+  const { getDataDir, getDbPath, isInitialized } = await import("./paths-5LZRKNYY.js");
+  let ok = 0;
+  let warn = 0;
+  let fail = 0;
+  function pass(msg) {
+    console.log(`  \u2713 ${msg}`);
+    ok++;
+  }
+  function warning(msg) {
+    console.log(`  \u26A0 ${msg}`);
+    warn++;
+  }
+  function error(msg) {
+    console.log(`  \u2717 ${msg}`);
+    fail++;
+  }
+  console.log("AgentCache Doctor\n");
+  console.log("Storage:");
+  const dataDir = getDataDir();
+  if (existsSync(dataDir)) {
+    pass(`Data directory exists: ${dataDir}`);
+  } else {
+    error(`Data directory missing: ${dataDir}`);
+  }
+  const dbPath = getDbPath();
+  if (existsSync(dbPath)) {
+    try {
+      const { SqliteKnowledgeRepository } = await import("./sqlite-NM2BVHUY.js");
+      const repo = new SqliteKnowledgeRepository(dbPath);
+      repo.close();
+      pass(`Database accessible: ${dbPath}`);
+    } catch (err) {
+      if (err.message?.includes("NODE_MODULE_VERSION") || err.message?.includes("was compiled against")) {
+        error(`Native module ABI mismatch \u2014 run: npm rebuild better-sqlite3 -g`);
+      } else {
+        error(`Database broken: ${err.message}`);
+      }
+    }
+  } else if (isInitialized()) {
+    warning("Database file missing but data directory exists");
+  } else {
+    warning("Not initialized yet \u2014 run: agentcache setup");
+  }
+  console.log("\nIDE registrations:");
+  const claudeJson = join(homedir(), ".claude.json");
+  if (existsSync(claudeJson)) {
+    try {
+      const config = JSON.parse(readFileSync(claudeJson, "utf-8"));
+      if (config.mcpServers?.agentcache) {
+        pass("Claude Code: registered");
+      } else {
+        warning("Claude Code: ~/.claude.json exists but no agentcache server");
+      }
+    } catch {
+      warning("Claude Code: ~/.claude.json unreadable");
+    }
+  } else {
+    warning("Claude Code: not registered");
+  }
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      const perms = settings.permissions?.allow || [];
+      if (perms.some((p) => p.includes("agentcache"))) {
+        pass("Claude Code permissions: auto-approved");
+      } else {
+        warning("Claude Code permissions: not in allow list");
+      }
+      if (settings.hooks?.Stop?.some((h) => JSON.stringify(h).includes("agentcache"))) {
+        pass("Claude Code hooks: registered");
+      } else {
+        warning("Claude Code hooks: not registered");
+      }
+    } catch {
+      warning("Claude Code settings: unreadable");
+    }
+  }
+  console.log("\nLLM backends (for compile-all):");
+  const backends = ["claude", "codex", "gemini", "copilot", "aider", "goose"];
+  const found = [];
+  for (const cmd of backends) {
+    try {
+      if (spawnSync("which", [cmd], { encoding: "utf-8", timeout: 3e3 }).status === 0) {
+        found.push(cmd);
+      }
+    } catch {
+    }
+  }
+  if (process.env.ANTHROPIC_API_KEY) found.push("Anthropic API (env)");
+  if (process.env.OPENAI_API_KEY) found.push("OpenAI API (env)");
+  if (found.length > 0) {
+    pass(`Available: ${found.join(", ")}`);
+  } else {
+    warning("No LLM backend found \u2014 compile-all won't work");
+  }
+  console.log("\nRuntime:");
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1));
+  if (major >= 20) {
+    pass(`Node ${nodeVersion}`);
+  } else {
+    error(`Node ${nodeVersion} \u2014 requires >=20.12.0`);
+  }
+  console.log(`
+${ok} passed, ${warn} warnings, ${fail} errors`);
+  if (fail > 0) process.exit(1);
+});
 program.command("compile-all").description("Batch-compile all unprocessed transcripts using an available LLM CLI").action(async () => {
-  const { runCompileAll } = await import("./compile-all-LB5S67BQ.js");
+  const { runCompileAll } = await import("./compile-all-7ESDEBFG.js");
   await runCompileAll();
 });
 program.command("status").description("Show AgentCache knowledge stats").action(async () => {
-  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-ULP2T4HZ.js");
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-5LZRKNYY.js");
   if (!isInitialized()) {
     console.log("AgentCache not initialized. Run: agentcache setup");
     return;
   }
-  const { SqliteKnowledgeRepository } = await import("./sqlite-MP6SRBBQ.js");
+  const { SqliteKnowledgeRepository } = await import("./sqlite-NM2BVHUY.js");
   const repo = new SqliteKnowledgeRepository(getDbPath());
   const projectRoot = findProjectRoot();
   const project = getProjectId(projectRoot);
@@ -68,10 +289,19 @@ program.command("status").description("Show AgentCache knowledge stats").action(
   const globalItems = items.filter((i) => i.scope === "global");
   const projectItems = items.filter((i) => i.scope === "project");
   const pending = repo.getPendingCount();
-  repo.close();
   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`);
+  const allProjects = repo.getProjectStats();
+  if (allProjects.length > 1) {
+    console.log("");
+    console.log("All projects:");
+    for (const p of allProjects) {
+      const marker = p.project === project ? " \u2190 current" : "";
+      console.log(`  ${p.project}: ${p.count} items${marker}`);
+    }
+  }
+  repo.close();
 });
 program.parse();

package/dist/{compile-all-LB5S67BQ.js → compile-all-7ESDEBFG.js}

@@ -2,11 +2,7 @@ import {
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-OXHITHDC.js";
-import {
-  acquireLock,
-  releaseLock
-} from "./chunk-VFE4SDMO.js";
+} from "./chunk-CUBZRYS5.js";
 import {
   findAllClaudeTranscripts,
   findAllCodexTranscripts,
@@ -14,15 +10,21 @@ import {
   findAllRooCodeTranscripts,
   getGooseDbPath,
   parseTranscript
-} from "./chunk-QVQJPJGX.js";
+} from "./chunk-IGCH7SZT.js";
+import {
+  acquireLock,
+  releaseLock
+} from "./chunk-JUDLOBOC.js";
+import "./chunk-GGAATZKM.js";
 import {
   getDbPath,
+  getGitRoot,
   getProjectId,
   isInitialized
-} from "./chunk-S4GSIEKL.js";
+} from "./chunk-T4COG3XD.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-ZVDODLZ7.js";
+} from "./chunk-PSASDZQE.js";
 import {
   __esm,
   __export,
@@ -90,7 +92,7 @@ var init_goose_sqlite = __esm({
 import { spawnSync } from "child_process";
 import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join2, dirname } from "path";
 import { randomUUID } from "crypto";
 function detectBackend() {
   const backends = [
@@ -304,15 +306,35 @@ function discoverAllTranscripts(repo) {
   }
   return results;
 }
-function inferProjectRoot(path) {
-  if (path.includes(".claude/projects/")) {
-    const slug = path.split(".claude/projects/")[1]?.split("/")[0] || "";
+function inferProjectRoot(transcriptPath) {
+  if (transcriptPath.includes(".claude/projects/")) {
+    const slug = transcriptPath.split(".claude/projects/")[1]?.split("/")[0] || "";
     if (slug.startsWith("-")) return slug.replace(/-/g, "/");
   }
-  if (path.includes(".codex/sessions/")) return process.cwd();
-  if (path.includes("roo-cline/tasks/")) return process.cwd();
+  try {
+    const events = parseTranscript(transcriptPath);
+    for (const event of events) {
+      const filePath = extractFilePath(event);
+      if (filePath) {
+        const root = getGitRoot(dirname(filePath));
+        if (root) return root;
+        return dirname(filePath);
+      }
+    }
+  } catch {
+  }
   return process.cwd();
 }
+function extractFilePath(event) {
+  if (event.tool_input) {
+    for (const val of Object.values(event.tool_input)) {
+      if (typeof val === "string" && val.startsWith("/") && val.includes("/") && !val.includes(" ")) {
+        return val;
+      }
+    }
+  }
+  return null;
+}
 function processOneTranscript(repo, path, project, projectRoot, backend) {
   const events = parseTranscript(path);
   if (events.length < 3) return { created: 0, reinforced: 0, skipped: true };

package/dist/mcp.js

@@ -2,27 +2,29 @@ import {
   evaluatePolicy
 } from "./chunk-T7BJPANN.js";
 import {
-  computeCanonicalHash,
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-OXHITHDC.js";
+} from "./chunk-CUBZRYS5.js";
+import {
+  parseTranscript
+} from "./chunk-IGCH7SZT.js";
 import {
   spawnCompileAll
-} from "./chunk-VFE4SDMO.js";
+} from "./chunk-JUDLOBOC.js";
 import {
-  parseTranscript
-} from "./chunk-QVQJPJGX.js";
+  computeCanonicalHash
+} from "./chunk-GGAATZKM.js";
 import {
   findProjectRoot,
   getDataDir,
   getDbPath,
   getProjectId,
   isInitialized
-} from "./chunk-S4GSIEKL.js";
+} from "./chunk-T4COG3XD.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-ZVDODLZ7.js";
+} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/mcp.ts
@@ -90,8 +92,34 @@ function checkForUpdates() {
 }
 
 // src/mcp.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+
+// src/utils/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_CONFIG = {
+  security: "auto"
+};
+function getConfigPath() {
+  return join2(getDataDir(), "config.json");
+}
+function getConfig() {
+  const path = getConfigPath();
+  if (!existsSync2(path)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf-8"));
+    return { ...DEFAULT_CONFIG, ...raw };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  writeFileSync2(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+// src/mcp.ts
 import { randomUUID } from "crypto";
+var PKG_VERSION = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf-8")).version;
 function defaultScope(type) {
   return type === "rule" || type === "lesson" ? "global" : "project";
 }
@@ -114,9 +142,20 @@ function getResolvedProjectRoot() {
 function getResolvedProjectId() {
   return getProjectId(getResolvedProjectRoot());
 }
+function migrateToV04() {
+  const config = getConfig();
+  if (config.migrated_v04) return;
+  try {
+    const repo = new SqliteKnowledgeRepository(getDbPath());
+    repo.grandfatherExistingItems();
+    repo.close();
+    saveConfig({ ...config, migrated_v04: true });
+  } catch {
+  }
+}
 async function startMcpServer() {
   const server = new Server(
-    { name: "agentcache", version: "0.1.0" },
+    { name: "agentcache", version: PKG_VERSION },
     {
       capabilities: { tools: {} },
       instructions: "AgentCache is your knowledge cache. At the START of every session, call inject_context to load compiled rules, lessons, decisions, and context. Submit observations INCREMENTALLY via compile_submit as you learn them \u2014 do not wait until session end."
@@ -125,6 +164,7 @@ async function startMcpServer() {
   server.oninitialized = async () => {
     await resolveRoots(server);
     checkForUpdates();
+    migrateToV04();
   };
   server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
     await resolveRoots(server);
@@ -157,8 +197,7 @@ async function startMcpServer() {
                   type: { type: "string", enum: ["rule", "lesson", "decision", "context"], description: "rule=standing constraint, lesson=mistake+fix, decision=arch choice+rationale, context=current state" },
                   content: { type: "string", description: "The observation content" },
                   sourceQuote: { type: "string", description: "Optional quote from conversation that triggered this" },
-                  confidence: { type: "string", enum: ["high", "medium"], description: "How confident: high=explicitly stated, medium=inferred" },
-                  scope: { type: "string", enum: ["global", "project"], description: "global=applies to all projects, project=this project only. Defaults: rule/lesson->global, decision/context->project" }
+                  confidence: { type: "string", enum: ["high", "medium"], description: "How confident: high=explicitly stated, medium=inferred" }
                 },
                 required: ["type", "content", "confidence"]
               }
@@ -219,13 +258,12 @@ async function startMcpServer() {
       },
       {
         name: "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.",
+        description: "Save a single observation immediately with USER authority (never overwritten by compiler). Use for important rules or decisions the user explicitly states.",
         inputSchema: {
           type: "object",
           properties: {
             type: { type: "string", enum: ["rule", "lesson", "decision", "context"] },
             content: { type: "string", description: "The observation content" },
-            enforce: { type: "boolean", description: "If true, this rule will BLOCK tool calls that violate it" },
             scope: { type: "string", enum: ["global", "project"], description: "Defaults: rule/lesson->global, decision/context->project" },
             project: { type: "string", description: "Project identifier. Auto-detected if omitted." }
           },
@@ -272,7 +310,8 @@ async function startMcpServer() {
         case "inject_context": {
           const args = request.params.arguments || {};
           const project = args.project || detectedProject;
-          const items = repo.getKnowledgeForContext(project);
+          const securityMode = getConfig().security;
+          const items = repo.getKnowledgeForContext(project, { userOnly: securityMode === "review" });
           const rules = items.filter((i) => i.type === "rule").slice(0, 20);
           const lessons = items.filter((i) => i.type === "lesson").slice(0, 10);
           const decisions = items.filter((i) => i.type === "decision").slice(0, 10);
@@ -310,18 +349,25 @@ ${pendingCount} sessions pending compilation (background compiler already runnin
 <!-- ${pendingCount} session(s) pending compilation (below threshold, will process when backlog grows). -->
 `;
           }
-          output += "\n---\nIMPORTANT: Submit observations incrementally as they happen during this session.\nWhen you learn something (rule, lesson, decision, context), call compile_submit immediately.\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
+          const quarantined = repo.getQuarantinedItems(project);
+          if (quarantined.length > 0) {
+            output += `
+---
+${quarantined.length} observation(s) pending review \u2014 run \`agentcache review\` to approve or they'll auto-promote when seen again.
+`;
+          }
+          output += "\n---\nIMPORTANT: Use save_observation for decisions the user explicitly states (injected immediately).\nUse compile_submit for patterns you infer (quarantined until confirmed in a second session).\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
           return { content: [{ type: "text", text: output.trim() }] };
         }
         case "compile_submit": {
+          const securityMode = getConfig().security;
+          if (securityMode === "locked") {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "compile_submit disabled \u2014 security mode is 'locked'. Use compile-all for batch processing." }) }], isError: true };
+          }
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const sessionId = `sess_${randomUUID().slice(0, 8)}`;
-          const observationsWithScope = args.observations.map((o) => ({
-            ...o,
-            scope: o.scope || defaultScope(o.type)
-          }));
-          const responseText = JSON.stringify({ observations: observationsWithScope });
+          const responseText = JSON.stringify({ observations: args.observations });
           startCompile([], sessionId, project, projectRoot, repo);
           const result = processExtraction(repo, responseText, sessionId, project, projectRoot);
           if (result.status === "complete") {
@@ -344,7 +390,7 @@ ${pendingCount} sessions pending compilation (background compiler already runnin
           if (!entry) {
             return { content: [{ type: "text", text: JSON.stringify({ message: "No pending sessions to compile." }) }] };
           }
-          if (!existsSync2(entry.transcriptPath)) {
+          if (!existsSync3(entry.transcriptPath)) {
             return { content: [{ type: "text", text: JSON.stringify({ message: `Transcript not found: ${entry.transcriptPath}, skipped.` }) }] };
           }
           const events = parseTranscript(entry.transcriptPath);
@@ -402,7 +448,7 @@ ${pendingCount} sessions pending compilation (background compiler already runnin
             observationCount: 1,
             authority: "USER",
             status: "active",
-            enforce: args.enforce || false,
+            enforce: false,
             project,
             scope,
             createdAt: Date.now(),

package/dist/{paths-ULP2T4HZ.js → paths-5LZRKNYY.js}

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

package/dist/postinstall.js

@@ -1,23 +1,26 @@
 import {
   spawnCompileAll
-} from "./chunk-VFE4SDMO.js";
+} from "./chunk-JUDLOBOC.js";
 import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-H3S3HDHK.js";
+} from "./chunk-JVLMZU5I.js";
 import {
   getDataDir,
   getDbPath,
   migrateFromLegacy
-} from "./chunk-S4GSIEKL.js";
+} from "./chunk-T4COG3XD.js";
 import {
   SqliteKnowledgeRepository
-} from "./chunk-ZVDODLZ7.js";
+} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/postinstall.ts
 import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { spawnSync } from "child_process";
 if (process.env.CI) {
   process.exit(0);
 }
@@ -33,15 +36,29 @@ try {
       registered.push(ide.name);
     }
   }
+  mkdirSync(join(homedir(), ".claude"), { recursive: true });
   registerClaudeHooks();
   if (registered.length > 0) {
-    console.error(`agentcache: registered with ${registered.join(", ")}`);
+    console.log(`agentcache: registered with ${registered.join(", ")}`);
   }
-  console.error("agentcache: ready. Knowledge compiles automatically across all sessions.");
-  const spawned = spawnCompileAll();
-  if (spawned) {
-    console.error("agentcache: background compilation started for existing transcripts.");
+  console.log("agentcache: ready. Knowledge compiles automatically across all sessions.");
+  const hasBackend = ["claude", "codex", "gemini", "copilot", "aider", "goose"].some((cmd) => {
+    try {
+      return spawnSync("which", [cmd], { encoding: "utf-8", timeout: 3e3 }).status === 0;
+    } catch {
+      return false;
+    }
+  }) || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  if (hasBackend) {
+    const spawned = spawnCompileAll();
+    if (spawned) {
+      console.log("agentcache: background compilation started for existing transcripts.");
+    }
+  } else {
+    console.log("agentcache: no LLM backend detected for batch compilation.");
+    console.log("  Install one of: claude, codex, gemini, copilot, aider, goose");
+    console.log("  Or set ANTHROPIC_API_KEY / OPENAI_API_KEY. Knowledge compiles via MCP in the meantime.");
   }
 } catch (err) {
-  console.error(`agentcache postinstall: ${err.message}. Run 'agentcache setup' manually.`);
+  console.log(`agentcache postinstall: ${err.message}. Run 'agentcache setup' manually.`);
 }

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

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