@remnic/core 1.0.0

package/dist/chunk-CXWFUJR2.js

@@ -0,0 +1,1203 @@
+import {
+  readEnvVar
+} from "./chunk-MARWOCVP.js";
+
+// src/access-mcp.ts
+import { readFile } from "fs/promises";
+import { randomUUID } from "crypto";
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var LEGACY_MCP_PREFIX = "engram.";
+var CANONICAL_MCP_PREFIX = "remnic.";
+function toCanonicalToolName(name) {
+  return name.startsWith(LEGACY_MCP_PREFIX) ? `${CANONICAL_MCP_PREFIX}${name.slice(LEGACY_MCP_PREFIX.length)}` : name;
+}
+function toLegacyToolName(name) {
+  return name.startsWith(CANONICAL_MCP_PREFIX) ? `${LEGACY_MCP_PREFIX}${name.slice(CANONICAL_MCP_PREFIX.length)}` : name;
+}
+function withToolAliases(tool) {
+  const canonicalName = toCanonicalToolName(tool.name);
+  const canonicalTool = canonicalName === tool.name ? tool : { ...tool, name: canonicalName };
+  if (canonicalName === tool.name) return [canonicalTool];
+  return [canonicalTool, tool];
+}
+async function getMcpServerVersion() {
+  const envVersion = readEnvVar("OPENCLAW_ENGRAM_VERSION")?.trim() || readEnvVar("npm_package_version")?.trim();
+  if (envVersion) return envVersion;
+  try {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const raw = await readFile(pkgPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.version?.trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var EngramMcpServer = class {
+  constructor(service, options = {}) {
+    this.service = service;
+    this.authenticatedPrincipal = options.principal?.trim() || readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() || void 0;
+    this.tools = [
+      {
+        name: "engram.recall",
+        description: "Recall Engram context for a query.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string" },
+            sessionKey: { type: "string" },
+            namespace: { type: "string" },
+            topK: { type: "number" },
+            mode: { type: "string", enum: ["auto", "no_recall", "minimal", "full", "graph_mode"] },
+            includeDebug: { type: "boolean" }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.recall_explain",
+        description: "Return the last recall snapshot for a session or the most recent one.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string" },
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.day_summary",
+        description: "Generate a structured end-of-day summary. When memories is omitted or empty, auto-gathers today's facts and hourly summaries from storage.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memories: { type: "string" },
+            sessionKey: { type: "string" },
+            namespace: { type: "string" }
+          },
+          required: [],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_governance_run",
+        description: "Run Remnic memory governance in a bounded shadow/apply pass.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" },
+            mode: { type: "string", enum: ["shadow", "apply"] },
+            recentDays: { type: "number" },
+            maxMemories: { type: "number" },
+            batchSize: { type: "number" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_get",
+        description: "Fetch one Remnic memory by id.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memoryId: { type: "string" },
+            namespace: { type: "string" }
+          },
+          required: ["memoryId"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_timeline",
+        description: "Fetch one Remnic memory timeline by id.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memoryId: { type: "string" },
+            namespace: { type: "string" },
+            limit: { type: "number" }
+          },
+          required: ["memoryId"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_store",
+        description: "Store an explicit Remnic memory through the access layer.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            schemaVersion: { type: "number" },
+            idempotencyKey: { type: "string" },
+            dryRun: { type: "boolean" },
+            sessionKey: { type: "string" },
+            content: { type: "string" },
+            category: { type: "string" },
+            confidence: { type: "number" },
+            namespace: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            entityRef: { type: "string" },
+            ttl: { type: "string" },
+            sourceReason: { type: "string" }
+          },
+          required: ["content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.suggestion_submit",
+        description: "Queue a suggested Remnic memory for review.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            schemaVersion: { type: "number" },
+            idempotencyKey: { type: "string" },
+            dryRun: { type: "boolean" },
+            sessionKey: { type: "string" },
+            content: { type: "string" },
+            category: { type: "string" },
+            confidence: { type: "number" },
+            namespace: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            entityRef: { type: "string" },
+            ttl: { type: "string" },
+            sourceReason: { type: "string" }
+          },
+          required: ["content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.entity_get",
+        description: "Fetch one Engram entity by name.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            namespace: { type: "string" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.review_queue_list",
+        description: "Fetch the latest Engram review queue artifact bundle.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            runId: { type: "string" },
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.observe",
+        description: "Feed conversation messages into Engram's memory pipeline (LCM archive + extraction).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string", description: "Conversation session identifier" },
+            messages: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  role: { type: "string", enum: ["user", "assistant"] },
+                  content: { type: "string" }
+                },
+                required: ["role", "content"]
+              },
+              description: "Conversation messages to observe"
+            },
+            namespace: { type: "string" },
+            skipExtraction: { type: "boolean" }
+          },
+          required: ["sessionKey", "messages"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.lcm_search",
+        description: "Search the LCM conversation archive for matching content.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            sessionKey: { type: "string", description: "Optional session filter" },
+            namespace: { type: "string" },
+            limit: { type: "number", description: "Max results to return" }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      },
+      // ── Continuity / Identity tools ─────────────────────────────────────
+      {
+        name: "engram.continuity_audit_generate",
+        description: "Generate a deterministic identity continuity audit report (weekly/monthly).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            period: { type: "string", enum: ["weekly", "monthly"] },
+            key: { type: "string", description: "Period key (weekly: YYYY-Www, monthly: YYYY-MM). Defaults to current." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.continuity_incident_open",
+        description: "Create a new continuity incident record in append-only storage.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            symptom: { type: "string", description: "Observed continuity failure symptom." },
+            namespace: { type: "string" },
+            triggerWindow: { type: "string", description: "Time window when incident occurred." },
+            suspectedCause: { type: "string" }
+          },
+          required: ["symptom"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.continuity_incident_close",
+        description: "Close an open continuity incident with verification details.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Incident ID to close." },
+            namespace: { type: "string" },
+            fixApplied: { type: "string", description: "What fix was applied." },
+            verificationResult: { type: "string", description: "How closure was verified." },
+            preventiveRule: { type: "string", description: "Optional preventive follow-up rule." }
+          },
+          required: ["id", "fixApplied", "verificationResult"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.continuity_incident_list",
+        description: "List continuity incidents, optionally filtered by state.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            state: { type: "string", enum: ["open", "closed", "all"] },
+            namespace: { type: "string" },
+            limit: { type: "number", description: "Max incidents (default 25, max 200)." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.continuity_loop_add_or_update",
+        description: "Add or update a continuity improvement loop entry.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Stable loop identifier." },
+            cadence: { type: "string", enum: ["daily", "weekly", "monthly", "quarterly"] },
+            purpose: { type: "string", description: "What this recurring loop improves." },
+            status: { type: "string", enum: ["active", "paused", "retired"] },
+            killCondition: { type: "string", description: "Clear condition for retiring this loop." },
+            namespace: { type: "string" },
+            lastReviewed: { type: "string", description: "ISO timestamp for last review." },
+            notes: { type: "string" }
+          },
+          required: ["id", "cadence", "purpose", "status", "killCondition"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.continuity_loop_review",
+        description: "Update review metadata for an existing continuity improvement loop.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Loop ID to review." },
+            namespace: { type: "string" },
+            status: { type: "string", enum: ["active", "paused", "retired"] },
+            notes: { type: "string" },
+            reviewedAt: { type: "string", description: "ISO timestamp for review event." }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.identity_anchor_get",
+        description: "Read the identity continuity anchor document (recovery-safe identity context).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.identity_anchor_update",
+        description: "Conservatively merge identity anchor sections without overwriting existing material.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" },
+            identityTraits: { type: "string", description: "Updates for 'Identity Traits' section." },
+            communicationPreferences: { type: "string", description: "Updates for 'Communication Preferences' section." },
+            operatingPrinciples: { type: "string", description: "Updates for 'Operating Principles' section." },
+            continuityNotes: { type: "string", description: "Updates for 'Continuity Notes' section." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_identity",
+        description: "Read the agent's identity reflections from the workspace IDENTITY.md file.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      // ── Work Layer tools ─────────────────────────────────────────────────
+      {
+        name: "engram.work_task",
+        description: "Manage work-layer tasks (create, get, list, update, transition, delete). Excluded from memory extraction.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: { type: "string", enum: ["create", "get", "list", "update", "transition", "delete"] },
+            id: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            status: { type: "string", enum: ["todo", "in_progress", "blocked", "done", "cancelled"] },
+            priority: { type: "string", enum: ["low", "medium", "high"] },
+            owner: { type: "string" },
+            assignee: { type: "string" },
+            projectId: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            dueAt: { type: "string" }
+          },
+          required: ["action"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.work_project",
+        description: "Manage work-layer projects (create, get, list, update, delete, link_task). Excluded from memory extraction.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: { type: "string", enum: ["create", "get", "list", "update", "delete", "link_task"] },
+            id: { type: "string" },
+            name: { type: "string" },
+            description: { type: "string" },
+            status: { type: "string", enum: ["active", "on_hold", "completed", "archived"] },
+            owner: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            taskId: { type: "string", description: "Task ID for link_task." },
+            projectId: { type: "string", description: "Project ID for link_task." }
+          },
+          required: ["action"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.work_board",
+        description: "Export/import work-layer board snapshots and markdown.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: { type: "string", enum: ["export_markdown", "export_snapshot", "import_snapshot"] },
+            projectId: { type: "string" },
+            snapshotJson: { type: "string", description: "Snapshot JSON for import_snapshot." },
+            linkToMemory: { type: "boolean", description: "If true, output can be retained as long-term memory." }
+          },
+          required: ["action"],
+          additionalProperties: false
+        }
+      },
+      // ── Shared Context / Compounding tools ────────────────────────────
+      {
+        name: "engram.shared_context_write_output",
+        description: "Write agent work product into shared-context directory for cross-agent coordination.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            agentId: { type: "string", description: "Agent ID producing this output." },
+            title: { type: "string", description: "Short title for the output." },
+            content: { type: "string", description: "Markdown content to write." }
+          },
+          required: ["agentId", "title", "content"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.shared_feedback_record",
+        description: "Append approval/rejection decision into shared-context feedback inbox for compounding learning.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            agent: { type: "string", description: "Agent name that produced the output." },
+            decision: { type: "string", enum: ["approved", "approved_with_feedback", "rejected"] },
+            reason: { type: "string" },
+            date: { type: "string", description: "ISO timestamp. Defaults to now." },
+            learning: { type: "string" },
+            outcome: { type: "string" },
+            severity: { type: "string", enum: ["low", "medium", "high"] },
+            confidence: { type: "number", description: "Confidence 0-1." },
+            workflow: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            evidenceWindowStart: { type: "string" },
+            evidenceWindowEnd: { type: "string" },
+            refs: { type: "array", items: { type: "string" } }
+          },
+          required: ["agent", "decision", "reason"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.shared_priorities_append",
+        description: "Append priorities text into shared-context inbox for curator merge.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            agentId: { type: "string" },
+            text: { type: "string", description: "Priority notes (markdown)." }
+          },
+          required: ["agentId", "text"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.shared_context_cross_signals_run",
+        description: "Generate cross-signal markdown + JSON artifacts from agent outputs and feedback.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            date: { type: "string", description: "YYYY-MM-DD. Defaults to today." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.shared_context_curate_daily",
+        description: "Generate daily roundtable summary (deterministic baseline aggregation).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            date: { type: "string", description: "YYYY-MM-DD. Defaults to today." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.compounding_weekly_synthesize",
+        description: "Generate weekly compounding outputs: reports, mistake registry, rubrics, and promotion candidates.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            weekId: { type: "string", description: "ISO week ID (YYYY-Www). Defaults to current week." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.compounding_promote_candidate",
+        description: "Promote a compounding candidate from weekly report into durable rule/principle memory.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            weekId: { type: "string" },
+            candidateId: { type: "string" },
+            dryRun: { type: "boolean", description: "Preview without writing." }
+          },
+          required: ["weekId", "candidateId"],
+          additionalProperties: false
+        }
+      },
+      // ── Compression Guidelines tools ────────────────────────────────────
+      {
+        name: "engram.compression_guidelines_optimize",
+        description: "Run compression guideline optimizer, optionally persisting new guidelines.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dryRun: { type: "boolean" },
+            eventLimit: { type: "number" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.compression_guidelines_activate",
+        description: "Promote staged compression guideline draft to active (after review).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            expectedContentHash: { type: "string" },
+            expectedGuidelineVersion: { type: "number" }
+          },
+          additionalProperties: false
+        }
+      },
+      // ── Memory search & debug tools ────────────────────────────────────
+      {
+        name: "engram.memory_search",
+        description: "Direct semantic search over memory files using the QMD index. Returns matching memories with relevance scores.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string" },
+            namespace: { type: "string" },
+            maxResults: { type: "number" },
+            collection: { type: "string", description: "QMD collection (omit for memory, 'global' for all)" }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_profile",
+        description: "Read the user's behavioral profile \u2014 a living document of their preferences, habits, and personality.",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_entities_list",
+        description: "List all tracked entities (people, projects, tools, companies).",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_questions",
+        description: "List open questions the system is curious about from past conversations.",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_last_recall",
+        description: "Return the last recall snapshot for a session (debug introspection).",
+        inputSchema: {
+          type: "object",
+          properties: { sessionKey: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_intent_debug",
+        description: "Return the last intent classification debug snapshot.",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_qmd_debug",
+        description: "Return QMD search index debug information from the last recall.",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_graph_explain",
+        description: "Explain the last entity graph recall \u2014 which entities were activated and why.",
+        inputSchema: {
+          type: "object",
+          properties: { namespace: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_feedback",
+        description: "Record relevance feedback (thumbs up/down) for a specific memory.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memoryId: { type: "string" },
+            vote: { type: "string", enum: ["up", "down"] },
+            note: { type: "string" }
+          },
+          required: ["memoryId", "vote"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_promote",
+        description: "Promote a memory's lifecycle state (e.g. from draft to active).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memoryId: { type: "string" },
+            namespace: { type: "string" },
+            sessionKey: { type: "string" }
+          },
+          required: ["memoryId"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.context_checkpoint",
+        description: "Save a structured context checkpoint for a session (preserves conversation state to disk).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string" },
+            context: { type: "string", description: "Context content to checkpoint" },
+            namespace: { type: "string" }
+          },
+          required: ["sessionKey", "context"],
+          additionalProperties: false
+        }
+      }
+    ].flatMap((tool) => withToolAliases(tool));
+  }
+  service;
+  buffer = Buffer.alloc(0);
+  flushTask = null;
+  tools;
+  authenticatedPrincipal;
+  /**
+   * MCP client info keyed by server-assigned session ID. On each `initialize`
+   * handshake the server generates a UUID, stores the client's clientInfo
+   * against it, and returns the ID as `Mcp-Session-Id` in the response
+   * metadata. Subsequent requests from the same client include this header,
+   * allowing per-session clientInfo lookup without cross-session leaks.
+   */
+  clientInfoBySession = /* @__PURE__ */ new Map();
+  /**
+   * Session IDs generated during initialize, keyed by caller-supplied correlation
+   * ID (unique per HTTP request) to avoid collisions when multiple clients send
+   * initialize with the same JSON-RPC id concurrently.
+   */
+  initSessionIds = /* @__PURE__ */ new Map();
+  /** Get clientInfo for a specific MCP session. Returns undefined for non-MCP requests. */
+  getClientInfo(sessionId) {
+    if (sessionId) {
+      return this.clientInfoBySession.get(sessionId);
+    }
+    return void 0;
+  }
+  /** Pop the session ID generated during an initialize handshake, keyed by correlation ID. */
+  popInitSessionId(correlationId) {
+    const sid = this.initSessionIds.get(correlationId);
+    if (sid !== void 0) this.initSessionIds.delete(correlationId);
+    return sid;
+  }
+  async handleRequest(request, options) {
+    const id = request.id ?? null;
+    const method = request.method ?? "";
+    if (method === "notifications/initialized") return null;
+    if (method === "ping") {
+      return { jsonrpc: "2.0", id, result: {} };
+    }
+    if (method === "initialize") {
+      const params = request.params ?? {};
+      const rawClientInfo = params.clientInfo;
+      const newSessionId = randomUUID();
+      if (rawClientInfo && typeof rawClientInfo.name === "string") {
+        const info = { name: rawClientInfo.name, version: rawClientInfo.version };
+        this.clientInfoBySession.set(newSessionId, info);
+        if (this.clientInfoBySession.size > 1e3) {
+          const firstKey = this.clientInfoBySession.keys().next().value;
+          if (firstKey) this.clientInfoBySession.delete(firstKey);
+        }
+      }
+      const version = await getMcpServerVersion();
+      const corrId = options?.correlationId;
+      if (corrId) this.initSessionIds.set(corrId, newSessionId);
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {
+            tools: {}
+          },
+          serverInfo: {
+            name: "remnic",
+            version
+          }
+        }
+      };
+    }
+    if (method === "tools/list") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          tools: this.tools
+        }
+      };
+    }
+    if (method === "tools/call") {
+      const params = request.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const argumentsObject = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {};
+      try {
+        const effectivePrincipal = options?.principalOverride ?? this.authenticatedPrincipal;
+        const result = await this.callTool(name, argumentsObject, effectivePrincipal);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+            isError: false
+          }
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: message }],
+            isError: true
+          }
+        };
+      }
+    }
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32601,
+        message: `Method not found: ${method}`
+      }
+    };
+  }
+  async runStdio(input, output) {
+    input.on("data", (chunk) => {
+      this.buffer = Buffer.concat([this.buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+      this.scheduleFlush(output);
+    });
+    await new Promise((resolve, reject) => {
+      input.on("end", resolve);
+      input.on("error", reject);
+    });
+    while (this.flushTask) {
+      await this.flushTask;
+    }
+  }
+  scheduleFlush(output) {
+    if (this.flushTask) return;
+    const task = this.flushBuffer(output).catch((err) => {
+      this.writeMessage(output, {
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      });
+    }).finally(() => {
+      if (this.flushTask === task) {
+        this.flushTask = null;
+      }
+      if (this.buffer.length > 0) {
+        this.scheduleFlush(output);
+      }
+    });
+    this.flushTask = task;
+  }
+  async flushBuffer(output) {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd < 0) return;
+      const headerText = this.buffer.slice(0, headerEnd).toString("utf-8");
+      const headers = headerText.split("\r\n");
+      const contentLengthHeader = headers.find((line) => line.toLowerCase().startsWith("content-length:"));
+      if (!contentLengthHeader) {
+        this.buffer = Buffer.alloc(0);
+        return;
+      }
+      const contentLength = parseInt(contentLengthHeader.split(":")[1]?.trim() ?? "0", 10);
+      if (!Number.isFinite(contentLength) || contentLength < 0) {
+        this.buffer = Buffer.alloc(0);
+        return;
+      }
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+      if (this.buffer.length < messageEnd) return;
+      const body = this.buffer.slice(messageStart, messageEnd).toString("utf-8");
+      this.buffer = this.buffer.slice(messageEnd);
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        this.writeMessage(output, {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: "Parse error"
+          }
+        });
+        continue;
+      }
+      const response = await this.handleRequest(parsed);
+      if (response) {
+        this.writeMessage(output, response);
+      }
+    }
+  }
+  writeMessage(output, payload) {
+    const body = JSON.stringify(payload);
+    const message = `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r
+\r
+${body}`;
+    output.write(message);
+  }
+  async callTool(name, args, effectivePrincipal) {
+    switch (toLegacyToolName(name)) {
+      case "engram.recall":
+        return this.service.recall({
+          query: typeof args.query === "string" ? args.query : "",
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          topK: typeof args.topK === "number" && Number.isFinite(args.topK) ? args.topK : void 0,
+          mode: typeof args.mode === "string" ? args.mode : void 0,
+          includeDebug: args.includeDebug === true
+        });
+      case "engram.recall_explain":
+        return this.service.recallExplain({
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0
+        });
+      case "engram.day_summary":
+        return this.service.daySummary({
+          memories: typeof args.memories === "string" ? args.memories : "",
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0
+        });
+      case "engram.memory_governance_run":
+        return this.service.governanceRun({
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          mode: args.mode === "apply" ? "apply" : "shadow",
+          recentDays: typeof args.recentDays === "number" && Number.isFinite(args.recentDays) ? args.recentDays : void 0,
+          maxMemories: typeof args.maxMemories === "number" && Number.isFinite(args.maxMemories) ? args.maxMemories : void 0,
+          batchSize: typeof args.batchSize === "number" && Number.isFinite(args.batchSize) ? args.batchSize : void 0,
+          authenticatedPrincipal: effectivePrincipal
+        }, effectivePrincipal);
+      case "engram.memory_get":
+        return this.service.memoryGet(
+          typeof args.memoryId === "string" ? args.memoryId : "",
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.memory_timeline": {
+        const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? args.limit : 200;
+        return this.service.memoryTimeline(
+          typeof args.memoryId === "string" ? args.memoryId : "",
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          limit,
+          effectivePrincipal
+        );
+      }
+      case "engram.memory_store":
+        return this.service.memoryStore({
+          schemaVersion: typeof args.schemaVersion === "number" ? args.schemaVersion : void 0,
+          idempotencyKey: typeof args.idempotencyKey === "string" ? args.idempotencyKey : void 0,
+          dryRun: args.dryRun === true,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          authenticatedPrincipal: effectivePrincipal,
+          content: typeof args.content === "string" ? args.content : "",
+          category: typeof args.category === "string" ? args.category : void 0,
+          confidence: typeof args.confidence === "number" ? args.confidence : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((tag) => typeof tag === "string") : void 0,
+          entityRef: typeof args.entityRef === "string" ? args.entityRef : void 0,
+          ttl: typeof args.ttl === "string" ? args.ttl : void 0,
+          sourceReason: typeof args.sourceReason === "string" ? args.sourceReason : void 0
+        });
+      case "engram.suggestion_submit":
+        return this.service.suggestionSubmit({
+          schemaVersion: typeof args.schemaVersion === "number" ? args.schemaVersion : void 0,
+          idempotencyKey: typeof args.idempotencyKey === "string" ? args.idempotencyKey : void 0,
+          dryRun: args.dryRun === true,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          authenticatedPrincipal: effectivePrincipal,
+          content: typeof args.content === "string" ? args.content : "",
+          category: typeof args.category === "string" ? args.category : void 0,
+          confidence: typeof args.confidence === "number" ? args.confidence : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((tag) => typeof tag === "string") : void 0,
+          entityRef: typeof args.entityRef === "string" ? args.entityRef : void 0,
+          ttl: typeof args.ttl === "string" ? args.ttl : void 0,
+          sourceReason: typeof args.sourceReason === "string" ? args.sourceReason : void 0
+        });
+      case "engram.entity_get":
+        return this.service.entityGet(
+          typeof args.name === "string" ? args.name : "",
+          typeof args.namespace === "string" ? args.namespace : void 0
+        );
+      case "engram.review_queue_list":
+        return this.service.reviewQueue(
+          typeof args.runId === "string" ? args.runId : void 0,
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.observe":
+        return this.service.observe({
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : "",
+          messages: Array.isArray(args.messages) ? args.messages : [],
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          authenticatedPrincipal: effectivePrincipal,
+          skipExtraction: args.skipExtraction === true
+        });
+      case "engram.lcm_search":
+        return this.service.lcmSearch({
+          query: typeof args.query === "string" ? args.query : "",
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          limit: typeof args.limit === "number" && Number.isFinite(args.limit) ? args.limit : void 0,
+          authenticatedPrincipal: effectivePrincipal
+        });
+      // ── Continuity / Identity tools ───────────────────────────────────
+      case "engram.continuity_audit_generate":
+        return this.service.continuityAuditGenerate({
+          period: args.period === "monthly" ? "monthly" : args.period === "weekly" ? "weekly" : void 0,
+          key: typeof args.key === "string" ? args.key : void 0
+        });
+      case "engram.continuity_incident_open":
+        return this.service.continuityIncidentOpen({
+          symptom: typeof args.symptom === "string" ? args.symptom : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          triggerWindow: typeof args.triggerWindow === "string" ? args.triggerWindow : void 0,
+          suspectedCause: typeof args.suspectedCause === "string" ? args.suspectedCause : void 0
+        });
+      case "engram.continuity_incident_close":
+        return this.service.continuityIncidentClose({
+          id: typeof args.id === "string" ? args.id : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          fixApplied: typeof args.fixApplied === "string" ? args.fixApplied : "",
+          verificationResult: typeof args.verificationResult === "string" ? args.verificationResult : "",
+          preventiveRule: typeof args.preventiveRule === "string" ? args.preventiveRule : void 0
+        });
+      case "engram.continuity_incident_list":
+        return this.service.continuityIncidentList({
+          state: args.state === "closed" ? "closed" : args.state === "all" ? "all" : args.state === "open" ? "open" : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          limit: typeof args.limit === "number" ? args.limit : void 0
+        });
+      case "engram.continuity_loop_add_or_update":
+        return this.service.continuityLoopAddOrUpdate({
+          id: typeof args.id === "string" ? args.id : "",
+          cadence: args.cadence ?? "weekly",
+          purpose: typeof args.purpose === "string" ? args.purpose : "",
+          status: args.status ?? "active",
+          killCondition: typeof args.killCondition === "string" ? args.killCondition : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          lastReviewed: typeof args.lastReviewed === "string" ? args.lastReviewed : void 0,
+          notes: typeof args.notes === "string" ? args.notes : void 0
+        });
+      case "engram.continuity_loop_review":
+        return this.service.continuityLoopReview({
+          id: typeof args.id === "string" ? args.id : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          status: args.status === "active" || args.status === "paused" || args.status === "retired" ? args.status : void 0,
+          notes: typeof args.notes === "string" ? args.notes : void 0,
+          reviewedAt: typeof args.reviewedAt === "string" ? args.reviewedAt : void 0
+        });
+      case "engram.identity_anchor_get":
+        return this.service.identityAnchorGet({
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal
+        });
+      case "engram.identity_anchor_update":
+        return this.service.identityAnchorUpdate({
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          identityTraits: typeof args.identityTraits === "string" ? args.identityTraits : void 0,
+          communicationPreferences: typeof args.communicationPreferences === "string" ? args.communicationPreferences : void 0,
+          operatingPrinciples: typeof args.operatingPrinciples === "string" ? args.operatingPrinciples : void 0,
+          continuityNotes: typeof args.continuityNotes === "string" ? args.continuityNotes : void 0
+        });
+      case "engram.memory_identity":
+        return this.service.memoryIdentity({
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal
+        });
+      // ── Work Layer tools ──────────────────────────────────────────────
+      case "engram.work_task":
+        return this.service.workTask({
+          action: args.action ?? "list",
+          id: typeof args.id === "string" ? args.id : void 0,
+          title: typeof args.title === "string" ? args.title : void 0,
+          description: typeof args.description === "string" ? args.description : void 0,
+          status: typeof args.status === "string" ? args.status : void 0,
+          priority: typeof args.priority === "string" ? args.priority : void 0,
+          owner: typeof args.owner === "string" ? args.owner : void 0,
+          assignee: typeof args.assignee === "string" ? args.assignee : void 0,
+          projectId: typeof args.projectId === "string" ? args.projectId : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((x) => typeof x === "string") : void 0,
+          dueAt: typeof args.dueAt === "string" ? args.dueAt : void 0
+        });
+      case "engram.work_project":
+        return this.service.workProject({
+          action: args.action ?? "list",
+          id: typeof args.id === "string" ? args.id : void 0,
+          name: typeof args.name === "string" ? args.name : void 0,
+          description: typeof args.description === "string" ? args.description : void 0,
+          status: typeof args.status === "string" ? args.status : void 0,
+          owner: typeof args.owner === "string" ? args.owner : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((x) => typeof x === "string") : void 0,
+          taskId: typeof args.taskId === "string" ? args.taskId : void 0,
+          projectId: typeof args.projectId === "string" ? args.projectId : void 0
+        });
+      case "engram.work_board":
+        return this.service.workBoard({
+          action: args.action ?? "export_markdown",
+          projectId: typeof args.projectId === "string" ? args.projectId : void 0,
+          snapshotJson: typeof args.snapshotJson === "string" ? args.snapshotJson : void 0,
+          linkToMemory: args.linkToMemory === true
+        });
+      // ── Shared Context / Compounding tools ─────────────────────────
+      case "engram.shared_context_write_output":
+        return this.service.sharedContextWriteOutput({
+          agentId: typeof args.agentId === "string" ? args.agentId : "",
+          title: typeof args.title === "string" ? args.title : "",
+          content: typeof args.content === "string" ? args.content : ""
+        });
+      case "engram.shared_feedback_record":
+        return this.service.sharedFeedbackRecord({
+          agent: typeof args.agent === "string" ? args.agent : "",
+          decision: args.decision ?? "approved",
+          reason: typeof args.reason === "string" ? args.reason : "",
+          date: typeof args.date === "string" ? args.date : void 0,
+          learning: typeof args.learning === "string" ? args.learning : void 0,
+          outcome: typeof args.outcome === "string" ? args.outcome : void 0,
+          severity: args.severity === "low" || args.severity === "medium" || args.severity === "high" ? args.severity : void 0,
+          confidence: typeof args.confidence === "number" ? args.confidence : void 0,
+          workflow: typeof args.workflow === "string" ? args.workflow : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((x) => typeof x === "string") : void 0,
+          evidenceWindowStart: typeof args.evidenceWindowStart === "string" ? args.evidenceWindowStart : void 0,
+          evidenceWindowEnd: typeof args.evidenceWindowEnd === "string" ? args.evidenceWindowEnd : void 0,
+          refs: Array.isArray(args.refs) ? args.refs.filter((x) => typeof x === "string") : void 0
+        });
+      case "engram.shared_priorities_append":
+        return this.service.sharedPrioritiesAppend({
+          agentId: typeof args.agentId === "string" ? args.agentId : "",
+          text: typeof args.text === "string" ? args.text : ""
+        });
+      case "engram.shared_context_cross_signals_run":
+        return this.service.sharedContextCrossSignalsRun({
+          date: typeof args.date === "string" ? args.date : void 0
+        });
+      case "engram.shared_context_curate_daily":
+        return this.service.sharedContextCurateDaily({
+          date: typeof args.date === "string" ? args.date : void 0
+        });
+      case "engram.compounding_weekly_synthesize":
+        return this.service.compoundingWeeklySynthesize({
+          weekId: typeof args.weekId === "string" ? args.weekId : void 0
+        });
+      case "engram.compounding_promote_candidate":
+        return this.service.compoundingPromoteCandidate({
+          weekId: typeof args.weekId === "string" ? args.weekId : "",
+          candidateId: typeof args.candidateId === "string" ? args.candidateId : "",
+          dryRun: args.dryRun === true
+        });
+      // ── Compression Guidelines tools ───────────────────────────────────
+      case "engram.compression_guidelines_optimize":
+        return this.service.compressionGuidelinesOptimize({
+          dryRun: args.dryRun === true,
+          eventLimit: typeof args.eventLimit === "number" ? args.eventLimit : void 0
+        });
+      case "engram.compression_guidelines_activate":
+        return this.service.compressionGuidelinesActivate({
+          expectedContentHash: typeof args.expectedContentHash === "string" ? args.expectedContentHash : void 0,
+          expectedGuidelineVersion: typeof args.expectedGuidelineVersion === "number" ? args.expectedGuidelineVersion : void 0
+        });
+      // ── Memory search & debug tools ──────────────────────────────────
+      case "engram.memory_search":
+        return this.service.memorySearch({
+          query: typeof args.query === "string" ? args.query : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          maxResults: typeof args.maxResults === "number" && Number.isFinite(args.maxResults) ? args.maxResults : void 0,
+          collection: typeof args.collection === "string" ? args.collection : void 0,
+          principal: effectivePrincipal
+        });
+      case "engram.memory_profile":
+        return this.service.memoryProfile(
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.memory_entities_list":
+        return this.service.memoryEntitiesList(
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.memory_questions":
+        return this.service.memoryQuestions(
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.memory_last_recall":
+        return this.service.lastRecallSnapshot(
+          typeof args.sessionKey === "string" ? args.sessionKey : void 0
+        );
+      case "engram.memory_intent_debug":
+        return this.service.intentDebug(
+          typeof args.namespace === "string" ? args.namespace : void 0
+        );
+      case "engram.memory_qmd_debug":
+        return this.service.qmdDebug(
+          typeof args.namespace === "string" ? args.namespace : void 0
+        );
+      case "engram.memory_graph_explain":
+        return this.service.graphExplainLastRecall(
+          typeof args.namespace === "string" ? args.namespace : void 0
+        );
+      case "engram.memory_feedback":
+        return this.service.memoryFeedback({
+          memoryId: typeof args.memoryId === "string" ? args.memoryId : "",
+          vote: args.vote === "down" ? "down" : "up",
+          note: typeof args.note === "string" ? args.note : void 0
+        });
+      case "engram.memory_promote":
+        return this.service.memoryPromote({
+          memoryId: typeof args.memoryId === "string" ? args.memoryId : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0
+        });
+      case "engram.context_checkpoint":
+        return this.service.contextCheckpoint({
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : "",
+          context: typeof args.context === "string" ? args.context : "",
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal
+        });
+      default:
+        throw new Error(`unknown tool: ${name}`);
+    }
+  }
+};
+
+export {
+  EngramMcpServer
+};
+//# sourceMappingURL=chunk-CXWFUJR2.js.map