agentcache 0.1.0

package/dist/mcp.js

@@ -0,0 +1,884 @@
+import {
+  evaluatePolicy
+} from "./chunk-PYGRUQNL.js";
+import {
+  parseTranscript
+} from "./chunk-QGG25FWV.js";
+import {
+  findProjectRoot,
+  getDbPath,
+  getGitContext,
+  getProjectId,
+  isLoopInitialized
+} from "./chunk-VPEEZXLK.js";
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-MMSMDJ4O.js";
+import "./chunk-MLKGABMK.js";
+
+// src/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, RootsListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/knowledge/compiler.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/knowledge/passes/1-extractor.ts
+import { randomUUID } from "crypto";
+var EXTRACT_PROMPT_VERSION = "extract-v1";
+function buildExtractionPrompt(events) {
+  const transcript = events.filter((e) => e.content || e.tool_name).map((e) => {
+    if (e.role) return `[${e.role}]: ${e.content}`;
+    if (e.tool_name) return `[tool:${e.tool_name}]: ${JSON.stringify(e.tool_input).slice(0, 500)}`;
+    return "";
+  }).filter(Boolean).join("\n");
+  return `You are a knowledge extraction engine. Analyze this coding session transcript and extract distinct learnings.
+
+Extract into four types:
+- rule: a standing instruction or constraint the developer expressed
+- lesson: a mistake made and what fixed it
+- decision: an architectural or design choice with rationale
+- context: current task state, open threads, what was left in progress
+
+Return ONLY valid JSON: { "observations": [{ "type": "rule"|"lesson"|"decision"|"context", "content": "...", "sourceQuote": "...", "confidence": "high"|"medium" }] }
+
+Only return high and medium confidence items. Ignore conversational noise, tool outputs, and implementation details that aren't generalizable.
+
+<transcript>
+${transcript}
+</transcript>`;
+}
+function parseExtractionResponse(text, sessionId, project) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) return [];
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.observations || !Array.isArray(parsed.observations)) return [];
+  const now = Date.now();
+  return parsed.observations.filter((o) => o.type && o.content && o.confidence).filter((o) => ["high", "medium"].includes(o.confidence)).map((o) => ({
+    id: `obs_${randomUUID().slice(0, 8)}`,
+    sessionId,
+    timestamp: now,
+    type: o.type,
+    content: o.content,
+    sourceQuote: o.sourceQuote || "",
+    confidence: o.confidence,
+    project,
+    scope: o.scope || (o.type === "rule" || o.type === "lesson" ? "global" : "project")
+  }));
+}
+
+// src/knowledge/passes/2-normalizer.ts
+var FILLER_PATTERNS = [
+  /^i (noticed|realized|learned|found|discovered|think) that /i,
+  /^it (seems|appears|looks) (like|that) /i,
+  /^we should /i,
+  /^you should /i,
+  /^basically,? /i,
+  /^essentially,? /i,
+  /^actually,? /i
+];
+var IMPERATIVE_RULES = [
+  [/^you should never /i, "Never "],
+  [/^we should never /i, "Never "],
+  [/^don't ever /i, "Never "],
+  [/^never /i, "Never "],
+  [/^you should always /i, "Always "],
+  [/^we should always /i, "Always "],
+  [/^always /i, "Always "]
+];
+function normalize(observations) {
+  const normalized = observations.map((obs) => ({
+    ...obs,
+    content: normalizeContent(obs.content, obs.type)
+  }));
+  const seen = /* @__PURE__ */ new Set();
+  return normalized.filter((obs) => {
+    const key = obs.content.toLowerCase().trim();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeContent(content, type) {
+  let text = content.trim();
+  for (const pattern of FILLER_PATTERNS) {
+    text = text.replace(pattern, "");
+  }
+  if (type === "rule") {
+    for (const [pattern, replacement] of IMPERATIVE_RULES) {
+      if (pattern.test(text)) {
+        text = text.replace(pattern, replacement);
+        break;
+      }
+    }
+  }
+  text = text.charAt(0).toUpperCase() + text.slice(1);
+  const firstSentenceEnd = text.search(/\. [A-Z]/);
+  if (firstSentenceEnd > 0) {
+    text = text.slice(0, firstSentenceEnd + 1);
+  }
+  return text;
+}
+
+// src/knowledge/passes/3-canonicalizer.ts
+import { createHash } from "crypto";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "yet",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "i",
+  "we",
+  "you",
+  "they",
+  "he",
+  "she"
+]);
+var ANTONYM_MAP = [
+  [/\bnever\b/g, "forbidden"],
+  [/\bdon'?t\b/g, "forbidden"],
+  [/\bavoid\b/g, "forbidden"],
+  [/\bprohibit(ed)?\b/g, "forbidden"],
+  [/\balways\b/g, "required"],
+  [/\bmust\b/g, "required"],
+  [/\brequire(d)?\b/g, "required"],
+  [/\buse\b/g, "use"],
+  [/\bprefer\b/g, "use"]
+];
+function canonicalize(observations, existingCanonicalKeys) {
+  const canonicalized = observations.map((obs) => ({
+    ...obs,
+    canonicalKey: computeCanonicalKey(obs.content)
+  }));
+  const existingSet = new Set(existingCanonicalKeys || []);
+  const autoReinforced = [];
+  const needsClustering = [];
+  for (const obs of canonicalized) {
+    if (existingSet.has(obs.canonicalKey)) {
+      autoReinforced.push(obs);
+    } else {
+      needsClustering.push(obs);
+    }
+  }
+  return { observations: canonicalized, autoReinforced, needsClustering };
+}
+function computeCanonicalKey(content) {
+  let text = content.toLowerCase().trim();
+  for (const [pattern, replacement] of ANTONYM_MAP) {
+    text = text.replace(pattern, replacement);
+  }
+  text = text.replace(/[^\w\s]/g, " ");
+  const tokens = text.split(/\s+/).filter((t) => !STOP_WORDS.has(t) && t.length > 1).sort();
+  return tokens.join(" ");
+}
+function computeCanonicalHash(content) {
+  const key = computeCanonicalKey(content);
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+
+// src/knowledge/passes/4-clusterer.ts
+var CLUSTER_PROMPT_VERSION = "cluster-v1";
+function buildClusteringPrompt(observations, existingItems) {
+  const obsJson = observations.map((o) => ({
+    id: o.id,
+    type: o.type,
+    content: o.content,
+    canonicalKey: o.canonicalKey
+  }));
+  const itemsJson = existingItems.filter((i) => i.status === "active").map((i) => ({
+    id: i.id,
+    type: i.type,
+    content: i.content,
+    canonicalHash: i.canonicalHash
+  }));
+  return `You are a knowledge clustering engine. Determine whether new observations create new knowledge or relate to existing items. Be conservative.
+
+For each observation, assign an action:
+CREATE    \u2014 genuinely new knowledge, no existing item covers it
+REINFORCE \u2014 confirms an existing item (provide targetKnowledgeItemId)
+SUPERSEDE \u2014 replaces/corrects an existing item (provide targetKnowledgeItemId)
+DEPRECATE \u2014 makes an existing item irrelevant (provide targetKnowledgeItemId)
+IGNORE    \u2014 duplicate, trivial, or too vague to keep
+
+New observations:
+${JSON.stringify(obsJson, null, 2)}
+
+Existing knowledge items:
+${JSON.stringify(itemsJson, null, 2)}
+
+Return ONLY valid JSON: { "clusters": [{ "observationId": "...", "action": "CREATE"|"REINFORCE"|"SUPERSEDE"|"DEPRECATE"|"IGNORE", "targetKnowledgeItemId": "..." (only if action targets an existing item), "reasoning": "..." }] }`;
+}
+function parseClusteringResponse(text, observations) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    return observations.map((o) => ({ observationId: o.id, action: "CREATE", reasoning: "Parse failure \u2014 defaulting to CREATE" }));
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.clusters || !Array.isArray(parsed.clusters)) {
+    return observations.map((o) => ({ observationId: o.id, action: "CREATE", reasoning: "Parse failure \u2014 defaulting to CREATE" }));
+  }
+  return parsed.clusters.map((c) => ({
+    observationId: c.observationId,
+    action: c.action || "CREATE",
+    targetKnowledgeItemId: c.targetKnowledgeItemId || void 0,
+    reasoning: c.reasoning || ""
+  }));
+}
+
+// src/knowledge/passes/5-contradiction.ts
+var CONTRADICTION_PROMPT_VERSION = "contradiction-v1";
+
+// src/knowledge/passes/6-compile.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function calculateConfidence(count) {
+  if (count >= 7) return "high";
+  if (count >= 3) return "medium";
+  return "low";
+}
+function compileKnowledge(clusters, existingItems, observations, project, now) {
+  const itemMap = new Map(existingItems.map((i) => [i.id, { ...i }]));
+  const obsMap = new Map(observations.map((o) => [o.id, o]));
+  const result = {
+    created: [],
+    reinforced: [],
+    superseded: [],
+    deprecated: [],
+    ignored: 0
+  };
+  for (const cluster of clusters) {
+    const obs = obsMap.get(cluster.observationId);
+    if (!obs) continue;
+    switch (cluster.action) {
+      case "CREATE": {
+        const newItem = {
+          id: `ki_${randomUUID2().slice(0, 8)}`,
+          canonicalHash: computeCanonicalHash(obs.content),
+          type: obs.type,
+          title: obs.content.slice(0, 80),
+          content: obs.content,
+          confidence: "low",
+          observationCount: 1,
+          authority: "AUTO",
+          status: "active",
+          supersededById: void 0,
+          enforce: false,
+          project,
+          scope: obs.scope || (obs.type === "rule" || obs.type === "lesson" ? "global" : "project"),
+          createdAt: now,
+          updatedAt: now,
+          lastSeenAt: now,
+          metadata: {}
+        };
+        result.created.push(newItem);
+        break;
+      }
+      case "REINFORCE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (!target) break;
+        target.observationCount += 1;
+        target.lastSeenAt = now;
+        target.updatedAt = now;
+        target.confidence = calculateConfidence(target.observationCount);
+        result.reinforced.push(target);
+        break;
+      }
+      case "SUPERSEDE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (target) {
+          const newItem = {
+            id: `ki_${randomUUID2().slice(0, 8)}`,
+            canonicalHash: computeCanonicalHash(obs.content),
+            type: obs.type,
+            title: obs.content.slice(0, 80),
+            content: obs.content,
+            confidence: "low",
+            observationCount: 1,
+            authority: "AUTO",
+            status: "active",
+            supersededById: void 0,
+            enforce: false,
+            project,
+            scope: obs.scope || (obs.type === "rule" || obs.type === "lesson" ? "global" : "project"),
+            createdAt: now,
+            updatedAt: now,
+            lastSeenAt: now,
+            metadata: {}
+          };
+          target.status = "superseded";
+          target.updatedAt = now;
+          target.supersededById = newItem.id;
+          result.superseded.push(target);
+          result.created.push(newItem);
+        }
+        break;
+      }
+      case "DEPRECATE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (target) {
+          target.status = "deprecated";
+          target.updatedAt = now;
+          result.deprecated.push(target);
+        }
+        break;
+      }
+      case "IGNORE":
+        result.ignored += 1;
+        break;
+    }
+  }
+  return result;
+}
+
+// src/knowledge/compiler.ts
+var COMPILER_VERSION = "0.1.0";
+function startCompile(events, sessionId, project, projectRoot, repo, transcriptPath) {
+  const git = getGitContext(projectRoot);
+  const session = {
+    id: sessionId,
+    project,
+    startedAt: Date.now() - 6e4,
+    endedAt: Date.now(),
+    gitBranch: git.branch,
+    gitCommit: git.commit,
+    provider: "agent",
+    model: "host-agent",
+    transcriptPath: transcriptPath || "",
+    observationCount: 0
+  };
+  repo.saveSession(session);
+  const prompt = buildExtractionPrompt(events);
+  return { sessionId, project, projectRoot, prompt };
+}
+function processExtraction(repo, responseText, sessionId, project, projectRoot) {
+  const rawObservations = parseExtractionResponse(responseText, sessionId, project);
+  const normalized = normalize(rawObservations);
+  const existingItems = repo.getKnowledgeItems(project, { status: "active" });
+  const existingKeys = existingItems.map((i) => computeCanonicalKey(i.content));
+  const canonicalized = canonicalize(normalized, existingKeys);
+  for (const obs of canonicalized.autoReinforced) {
+    const matchingItem = existingItems.find(
+      (item) => computeCanonicalKey(item.content) === obs.canonicalKey
+    );
+    if (matchingItem) {
+      const newCount = matchingItem.observationCount + 1;
+      const confidence = newCount >= 7 ? "high" : newCount >= 3 ? "medium" : "low";
+      repo.updateKnowledgeItem(matchingItem.id, {
+        observationCount: newCount,
+        lastSeenAt: Date.now(),
+        updatedAt: Date.now(),
+        confidence
+      });
+    }
+  }
+  repo.saveObservations(normalized);
+  if (canonicalized.needsClustering.length === 0) {
+    saveCompileRun(repo, sessionId, project, normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, Date.now());
+    return {
+      status: "complete",
+      diagnostics: formatDiagnostics(normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, project, sessionId)
+    };
+  }
+  const clusteringPrompt = buildClusteringPrompt(canonicalized.needsClustering, existingItems);
+  return {
+    status: "needs_clustering",
+    clusteringPrompt,
+    sessionId
+  };
+}
+function processClustering(repo, responseText, sessionId, project, projectRoot) {
+  const startedAt = Date.now();
+  const existingItems = repo.getKnowledgeItems(project, { status: "active" });
+  const observations = repo.getObservations(project);
+  const sessionObs = observations.filter((o) => o.sessionId === sessionId);
+  const canonicalized = canonicalize(sessionObs);
+  const needsClustering = canonicalized.needsClustering;
+  const clusters = parseClusteringResponse(responseText, needsClustering);
+  const contradictions = [];
+  const supersedeActions = clusters.filter((c) => c.action === "SUPERSEDE");
+  for (const s of supersedeActions) {
+    if (s.targetKnowledgeItemId) {
+      const target = existingItems.find((i) => i.id === s.targetKnowledgeItemId);
+      if (target) {
+        contradictions.push({
+          id: `con_${randomUUID3().slice(0, 8)}`,
+          project,
+          itemAId: target.id,
+          itemBId: s.observationId,
+          topic: target.title.slice(0, 50),
+          description: `"${target.content}" superseded by new observation`,
+          recommendation: "keep_newer",
+          resolved: false,
+          createdAt: Date.now()
+        });
+      }
+    }
+  }
+  for (const c of contradictions) {
+    repo.saveContradiction(c);
+  }
+  const now = Date.now();
+  const compiled = compileKnowledge(clusters, existingItems, needsClustering, project, now);
+  for (const item of compiled.created) repo.saveKnowledgeItem(item);
+  for (const item of compiled.reinforced) {
+    repo.updateKnowledgeItem(item.id, {
+      observationCount: item.observationCount,
+      lastSeenAt: item.lastSeenAt,
+      updatedAt: item.updatedAt,
+      confidence: item.confidence
+    });
+  }
+  for (const item of compiled.superseded) {
+    repo.updateKnowledgeItem(item.id, {
+      status: item.status,
+      updatedAt: item.updatedAt,
+      supersededById: item.supersededById
+    });
+  }
+  for (const item of compiled.deprecated) {
+    repo.updateKnowledgeItem(item.id, { status: item.status, updatedAt: item.updatedAt });
+  }
+  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);
+  return {
+    status: "complete",
+    diagnostics: formatDiagnostics(totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, project, sessionId)
+  };
+}
+function saveCompileRun(repo, sessionId, project, observationsProcessed, autoReinforced, created, reinforced, superseded, deprecated, ignored, startedAt) {
+  const endedAt = Date.now();
+  const run = {
+    id: `cr_${randomUUID3().slice(0, 8)}`,
+    project,
+    sessionId,
+    compilerVersion: COMPILER_VERSION,
+    promptVersions: { extract: EXTRACT_PROMPT_VERSION, cluster: CLUSTER_PROMPT_VERSION, contradiction: CONTRADICTION_PROMPT_VERSION },
+    startedAt,
+    endedAt,
+    durationMs: endedAt - startedAt,
+    observationsProcessed,
+    knowledgeCreated: created,
+    knowledgeReinforced: reinforced + autoReinforced,
+    knowledgeDeprecated: deprecated,
+    knowledgeSuperseded: superseded,
+    knowledgeIgnored: ignored,
+    contradictionsDetected: 0,
+    diagnostics: ""
+  };
+  repo.saveCompileRun(run);
+}
+function formatDiagnostics(extracted, autoReinforced, created, reinforced, superseded, deprecated, ignored, project, sessionId) {
+  return [
+    `Loop Compiler v${COMPILER_VERSION}`,
+    `Project: ${project} | Session: ${sessionId}`,
+    `  ${extracted} observations processed`,
+    autoReinforced > 0 ? `  ${autoReinforced} auto-reinforced (no LLM needed)` : "",
+    `  ${created} new knowledge items`,
+    `  ${reinforced} reinforced`,
+    superseded > 0 ? `  ${superseded} superseded` : "",
+    deprecated > 0 ? `  ${deprecated} deprecated` : "",
+    ignored > 0 ? `  ${ignored} ignored` : ""
+  ].filter(Boolean).join("\n");
+}
+
+// src/mcp.ts
+import { existsSync } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+function defaultScope(type) {
+  return type === "rule" || type === "lesson" ? "global" : "project";
+}
+var cachedProjectRoot = null;
+async function resolveRoots(server) {
+  try {
+    const result = await server.listRoots();
+    if (result.roots.length > 0) {
+      const uri = result.roots[0].uri;
+      if (uri.startsWith("file://")) {
+        cachedProjectRoot = uri.slice(7);
+      }
+    }
+  } catch {
+  }
+}
+function getResolvedProjectRoot() {
+  return cachedProjectRoot || findProjectRoot();
+}
+function getResolvedProjectId() {
+  return getProjectId(getResolvedProjectRoot());
+}
+async function startMcpServer() {
+  const server = new Server(
+    { 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."
+    }
+  );
+  server.oninitialized = async () => {
+    await resolveRoots(server);
+  };
+  server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
+    await resolveRoots(server);
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "loop_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",
+          properties: {
+            project: { type: "string", description: "Project identifier. Auto-detected from workspace roots if omitted." }
+          },
+          required: []
+        }
+      },
+      {
+        name: "loop_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",
+          properties: {
+            observations: {
+              type: "array",
+              description: "Observations extracted from the session",
+              items: {
+                type: "object",
+                properties: {
+                  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" }
+                },
+                required: ["type", "content", "confidence"]
+              }
+            },
+            project: { type: "string", description: "Project identifier. Auto-detected if omitted." }
+          },
+          required: ["observations"]
+        }
+      },
+      {
+        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.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionId: { type: "string", description: "Session ID from loop_compile_submit response" },
+            clusters: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  observationId: { type: "string" },
+                  action: { type: "string", enum: ["CREATE", "REINFORCE", "SUPERSEDE", "DEPRECATE", "IGNORE"] },
+                  targetKnowledgeItemId: { type: "string", description: "Required for REINFORCE, SUPERSEDE, DEPRECATE" },
+                  reasoning: { type: "string" }
+                },
+                required: ["observationId", "action", "reasoning"]
+              }
+            },
+            project: { type: "string", description: "Project identifier. Auto-detected if omitted." }
+          },
+          required: ["sessionId", "clusters"]
+        }
+      },
+      {
+        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.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Project identifier. Auto-detected if omitted." }
+          },
+          required: []
+        }
+      },
+      {
+        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.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tool_name: { type: "string", description: "Name of the tool being called (e.g. 'Bash', 'Write')" },
+            tool_input: { type: "object", description: "The tool's input parameters" },
+            project: { type: "string", description: "Project identifier. Auto-detected if omitted." }
+          },
+          required: ["tool_name"]
+        }
+      },
+      {
+        name: "loop_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",
+          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." }
+          },
+          required: ["type", "content"]
+        }
+      },
+      {
+        name: "loop_get_knowledge",
+        description: "Query knowledge items from Loop's compiled database.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["rule", "lesson", "decision", "context"] },
+            status: { type: "string", enum: ["active", "deprecated", "superseded", "archived"] },
+            scope: { type: "string", enum: ["global", "project"] },
+            project: { type: "string", description: "Filter by project. Omit to see all." }
+          },
+          required: []
+        }
+      },
+      {
+        name: "loop_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",
+          properties: {
+            id: { type: "string", description: "Knowledge item ID to deprecate" },
+            reason: { type: "string", description: "Why this item is being deprecated" }
+          },
+          required: ["id", "reason"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (!isLoopInitialized()) {
+      return { content: [{ type: "text", text: "Loop 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": {
+          const args = request.params.arguments || {};
+          const project = args.project || detectedProject;
+          const items = repo.getKnowledgeForContext(project);
+          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);
+          const context = items.filter((i) => i.type === "context").slice(0, 5);
+          let output = "";
+          if (rules.length) {
+            output += "# Rules\n" + rules.map((r) => `- ${r.content}`).join("\n") + "\n\n";
+          }
+          if (lessons.length) {
+            output += "# Lessons\n" + lessons.map((l) => `- ${l.content}`).join("\n") + "\n\n";
+          }
+          if (decisions.length) {
+            output += "# Decisions\n" + decisions.map((d) => `- ${d.content}`).join("\n") + "\n\n";
+          }
+          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";
+          const pendingCount = repo.getPendingCount();
+          if (pendingCount > 0) {
+            output = `<!-- ${pendingCount} previous session(s) pending compilation. Call loop_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";
+          return { content: [{ type: "text", text: output.trim() }] };
+        }
+        case "loop_compile_submit": {
+          const args = request.params.arguments;
+          const project = args.project || detectedProject;
+          const sessionId = `sess_${randomUUID4().slice(0, 8)}`;
+          const observationsWithScope = args.observations.map((o) => ({
+            ...o,
+            scope: o.scope || defaultScope(o.type)
+          }));
+          const responseText = JSON.stringify({ observations: observationsWithScope });
+          startCompile([], sessionId, project, projectRoot, repo);
+          const result = processExtraction(repo, responseText, sessionId, project, projectRoot);
+          if (result.status === "complete") {
+            return { content: [{ type: "text", text: JSON.stringify({ status: "complete", diagnostics: result.diagnostics }) }] };
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify({ status: "needs_clustering", sessionId: result.sessionId, clusteringContext: result.clusteringPrompt }) }]
+          };
+        }
+        case "loop_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": {
+          const args = request.params.arguments || {};
+          const entry = repo.popPendingTranscript();
+          if (!entry) {
+            return { content: [{ type: "text", text: JSON.stringify({ message: "No pending sessions to compile." }) }] };
+          }
+          if (!existsSync(entry.transcriptPath)) {
+            return { content: [{ type: "text", text: JSON.stringify({ message: `Transcript not found: ${entry.transcriptPath}, skipped.` }) }] };
+          }
+          const events = parseTranscript(entry.transcriptPath);
+          if (events.length === 0) {
+            return { content: [{ type: "text", text: JSON.stringify({ message: "Empty transcript, skipped." }) }] };
+          }
+          const sessionId = `sess_${randomUUID4().slice(0, 8)}`;
+          const project = entry.project || (args.project || detectedProject);
+          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": {
+          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": {
+          const args = request.params.arguments;
+          const project = args.project || detectedProject;
+          const scope = args.scope || defaultScope(args.type);
+          const sessionId = `manual_${randomUUID4().slice(0, 8)}`;
+          repo.saveSession({
+            id: sessionId,
+            project,
+            startedAt: Date.now(),
+            endedAt: Date.now(),
+            gitBranch: "",
+            gitCommit: "",
+            provider: "manual",
+            model: "manual",
+            transcriptPath: "",
+            observationCount: 1
+          });
+          const obs = {
+            id: `obs_${randomUUID4().slice(0, 8)}`,
+            sessionId,
+            timestamp: Date.now(),
+            type: args.type,
+            content: args.content,
+            sourceQuote: "manual entry via MCP",
+            confidence: "high",
+            project,
+            scope
+          };
+          repo.saveObservation(obs);
+          repo.saveKnowledgeItem({
+            id: `ki_${randomUUID4().slice(0, 8)}`,
+            canonicalHash: computeCanonicalHash(args.content),
+            type: args.type,
+            title: args.content.slice(0, 80),
+            content: args.content,
+            confidence: "high",
+            observationCount: 1,
+            authority: "USER",
+            status: "active",
+            enforce: args.enforce || false,
+            project,
+            scope,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            lastSeenAt: Date.now(),
+            metadata: { source: "mcp" }
+          });
+          return { content: [{ type: "text", text: JSON.stringify({ saved: true, scope }) }] };
+        }
+        case "loop_get_knowledge": {
+          const args = request.params.arguments || {};
+          const project = args.project || detectedProject;
+          const items = repo.getKnowledgeItems(project, {
+            type: args.type,
+            status: args.status || "active"
+          });
+          const filtered = args.scope ? items.filter((i) => i.scope === args.scope) : items;
+          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": {
+          const args = request.params.arguments;
+          const item = repo.getKnowledgeItem(args.id);
+          if (!item) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `Item not found: ${args.id}` }) }], isError: true };
+          }
+          repo.updateKnowledgeItem(args.id, { status: "deprecated", updatedAt: Date.now() });
+          return { content: [{ type: "text", text: JSON.stringify({ deprecated: true, id: args.id, content: item.content, reason: args.reason }) }] };
+        }
+        default:
+          return { content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }], isError: true };
+      }
+    } finally {
+      repo.close();
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  startMcpServer
+};