@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-WZYKANL3.js

@@ -0,0 +1,2800 @@
+import {
+  REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
+  REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL,
+  REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_HTML,
+  REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
+  buildChatGptMemoryInspectorActionRequest,
+  buildChatGptMemoryInspectorResult
+} from "./chunk-C5BCH4ZS.js";
+import {
+  buildCitationGuidance
+} from "./chunk-IQT3XTKW.js";
+import {
+  EngramAccessInputError
+} from "./chunk-M23FSH32.js";
+import {
+  validateBriefingFormat
+} from "./chunk-VW676BEI.js";
+import {
+  expandTildePath
+} from "./chunk-QRNI5JBH.js";
+import {
+  readEnvVar
+} from "./chunk-XIG5PDM7.js";
+import {
+  validateRequest
+} from "./chunk-A2XUIMJ3.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];
+}
+function resolveChatGptInspectorRecallSessionKey(explicitSessionKey, authenticatedPrincipal) {
+  if (explicitSessionKey) return explicitSessionKey;
+  if (!authenticatedPrincipal) return void 0;
+  return `remnic:chatgpt-memory-inspector:${randomUUID()}`;
+}
+var STRICT_MCP_SCHEMA_KEYS = {
+  capsuleExport: [
+    "name",
+    "namespace",
+    "since",
+    "includeKinds",
+    "peerIds",
+    "includeTranscripts",
+    "encrypt"
+  ],
+  capsuleImport: ["archivePath", "namespace", "mode"],
+  capsuleList: ["namespace"]
+};
+function parseMcpRequest(schemaName, args) {
+  const allowedKeys = STRICT_MCP_SCHEMA_KEYS[schemaName];
+  if (allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    const unexpected = Object.keys(args).filter((key) => !allowed.has(key));
+    if (unexpected.length > 0) {
+      throw new EngramAccessInputError(
+        `request validation failed: (root): Unrecognized key(s) in object: ${unexpected.join(", ")}`
+      );
+    }
+  }
+  const validation = validateRequest(schemaName, args);
+  if (validation.success) return validation.data;
+  const details = validation.error.details.map((detail) => `${detail.field}: ${detail.message}`).join("; ");
+  throw new EngramAccessInputError(
+    details.length > 0 ? `${validation.error.error}: ${details}` : validation.error.error
+  );
+}
+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.citationsEnabled = options.citationsEnabled === true;
+    this.citationsAutoDetect = options.citationsAutoDetect !== false;
+    this.authenticatedPrincipal = options.principal?.trim() || readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() || void 0;
+    this.resources = [
+      {
+        uri: REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
+        name: "remnic-memory-inspector",
+        title: "Remnic Memory Inspector",
+        description: "Apps-compatible widget for inspecting retrieved Remnic memories, provenance, safety, and correction/scoping affordances.",
+        mimeType: REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
+        _meta: {
+          ui: {
+            csp: {
+              connectDomains: [],
+              resourceDomains: []
+            },
+            prefersBorder: true
+          },
+          "openai/widgetDescription": "Inspect retrieved Remnic memories, provenance, safety, and correction/scoping affordances."
+        }
+      }
+    ];
+    this.resourceTextByUri = /* @__PURE__ */ new Map([
+      [
+        REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
+        REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_HTML
+      ]
+    ]);
+    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" },
+            // Recall disclosure depth (issue #677).  Default `chunk` when
+            // omitted.  Section/raw payload shaping ships in PR 2; this PR
+            // wires the field end-to-end so clients can already pass it
+            // without it being silently dropped.
+            disclosure: { type: "string", enum: ["chunk", "section", "raw"] },
+            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
+            projectTag: { type: "string", description: "Project tag for non-git project scoping (e.g. 'blend-supply')." },
+            asOf: {
+              type: "string",
+              description: "Historical recall pin (issue #680). ISO 8601 timestamp; when set, the recall returns the corpus as it existed at this instant."
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Filter recall results to memories whose frontmatter tags match (issue #689)."
+            },
+            tagMatch: {
+              type: "string",
+              enum: ["any", "all"],
+              description: "Tag-filter match mode. 'any' (default) admits results with at least one filter tag; 'all' requires every filter tag."
+            }
+          },
+          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.set_coding_context",
+        description: "Attach a coding-agent context (project / branch) to a session so recall routes to a project- / branch-scoped namespace (issue #569). For MCP clients that do not ship cwd automatically (Cursor, generic agents, etc.). Also aliased as remnic.set_coding_context. Pass codingContext: null to clear. Alternatively, pass just a projectTag for non-git project scoping (e.g. OpenClaw channels).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: {
+              type: "string",
+              description: "Session identifier the context should attach to."
+            },
+            codingContext: {
+              anyOf: [
+                { type: "null" },
+                {
+                  type: "object",
+                  properties: {
+                    projectId: { type: "string", description: "Stable project id (origin:<hex> or root:<hex>)." },
+                    branch: { type: ["string", "null"], description: "Current branch, or null in detached HEAD." },
+                    rootPath: { type: "string", description: "Absolute path to the repo root." },
+                    defaultBranch: { type: ["string", "null"], description: "Default branch (usually main/master), or null when unknown." }
+                  },
+                  required: ["projectId", "branch", "rootPath", "defaultBranch"],
+                  additionalProperties: false
+                }
+              ],
+              description: "The context to attach, or null to clear. Omit when using projectTag instead."
+            },
+            projectTag: {
+              type: "string",
+              description: "Arbitrary project tag for non-git project scoping (e.g. 'blend-supply'). Creates a coding context with projectId 'tag:<projectTag>'. Use instead of codingContext when the session isn't tied to a specific git repo."
+            }
+          },
+          required: ["sessionKey"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.recall_tier_explain",
+        description: "Return a structured tier-explain payload for the last direct-answer-eligible recall (issue #518). Orthogonal to engram.recall_explain, which returns a graph-path explanation.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: {
+              type: "string",
+              description: "Optional session key. Omit to read the most recent snapshot."
+            },
+            namespace: {
+              type: "string",
+              description: "Optional namespace to scope the returned snapshot."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        // Registered as `engram.recall_xray`; `withToolAliases` below
+        // emits the canonical `remnic.recall_xray` alias automatically
+        // (dual-naming invariant for every new MCP tool).
+        name: "engram.recall_xray",
+        description: "Run a recall with X-ray capture enabled and return the unified per-result attribution snapshot (tier + audit + MMR + filters in one view). Issue #570.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Query to recall against. Required; non-empty."
+            },
+            sessionKey: {
+              type: "string",
+              description: "Optional session key to scope the recall."
+            },
+            namespace: {
+              type: "string",
+              description: "Optional namespace. Enforced against the caller's principal; a mismatch yields snapshotFound:false."
+            },
+            budget: {
+              type: "integer",
+              minimum: 1,
+              description: "Optional positive-integer override for the recall character budget."
+            },
+            disclosure: {
+              type: "string",
+              enum: ["chunk", "section", "raw"],
+              description: "Optional disclosure depth for X-ray telemetry (issue #677). When set, populates the per-disclosure token-spend summary on each result."
+            }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.action_confidence",
+        description: "Advisory ask/draft/act/refuse/escalate decision helper for interruption budgeting. Read-only; never mutates memory.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            intendedAction: { type: "string" },
+            confidence: { type: "number", minimum: 0, maximum: 1 },
+            risk: {
+              type: "string",
+              enum: ["low", "medium", "high", "irreversible", "restricted"]
+            },
+            contextReadiness: {
+              type: "string",
+              enum: ["none", "partial", "sufficient"]
+            },
+            currentContextScopes: {
+              type: "array",
+              items: { type: "string" }
+            },
+            userRules: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  kind: {
+                    type: "string",
+                    enum: [
+                      "ask-before",
+                      "do-not-use-outside-this-context",
+                      "never",
+                      "requires-escalation"
+                    ]
+                  },
+                  description: { type: "string" },
+                  matched: { type: "boolean" }
+                },
+                required: ["kind"],
+                additionalProperties: false
+              }
+            },
+            retrievedMemories: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  source: { type: "string" },
+                  created: { type: "string" },
+                  updated: { type: "string" },
+                  scope: { type: "string" },
+                  userContextScopes: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  retrievalReason: { type: "string" },
+                  confidence: { type: "number", minimum: 0, maximum: 1 },
+                  stale: { type: "boolean" },
+                  corrected: { type: "boolean" },
+                  correctionState: {
+                    type: "string",
+                    enum: ["none", "correction", "superseded", "disputed", "forgotten"]
+                  },
+                  safeToUse: { type: "boolean" },
+                  safety: {
+                    type: "string",
+                    enum: ["safe", "requires-review", "blocked"]
+                  },
+                  safetyReasons: {
+                    type: "array",
+                    items: { type: "string" }
+                  }
+                },
+                additionalProperties: false
+              }
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL,
+        title: "Show Remnic Memory Inspector",
+        description: "Use this when the user wants a ChatGPT Apps-compatible UI for inspecting Remnic recall, provenance, safety, and correction/forget/scoping affordances. Read-only; correction and forget actions are proposed as follow-up prompts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Memory question to inspect."
+            },
+            sessionKey: {
+              type: "string",
+              description: "Optional Remnic session key for scoped recall."
+            },
+            namespace: {
+              type: "string",
+              description: "Optional Remnic namespace to inspect."
+            },
+            currentContextScopes: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional current user-context scopes, such as repo, work, personal, client, or private."
+            }
+          },
+          required: ["query"],
+          additionalProperties: false
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            app: { type: "object" },
+            query: { type: "string" },
+            sessionKey: { type: "string" },
+            namespace: { type: "string" },
+            safeRecallPreview: { type: "string" },
+            memoryCount: { type: "number" },
+            memoryIds: { type: "array", items: { type: "string" } },
+            memories: { type: "array", items: { type: "object" } },
+            actionConfidence: { type: "object" },
+            affordances: { type: "array", items: { type: "object" } },
+            guidance: { type: "object" }
+          },
+          required: [
+            "app",
+            "query",
+            "namespace",
+            "safeRecallPreview",
+            "memoryCount",
+            "memoryIds",
+            "memories",
+            "actionConfidence",
+            "affordances",
+            "guidance"
+          ],
+          additionalProperties: false
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        },
+        _meta: {
+          ui: {
+            resourceUri: REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
+            visibility: ["model", "app"]
+          },
+          "openai/outputTemplate": REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
+          "openai/toolInvocation/invoking": "Inspecting Remnic memory...",
+          "openai/toolInvocation/invoked": "Remnic memory inspector ready."
+        }
+      },
+      {
+        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.capsule_export",
+        description: "Export a portable Remnic capsule archive from the namespace-scoped memory store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Capsule id (alphanumeric with single dashes, max 64 characters)."
+            },
+            namespace: { type: "string" },
+            since: {
+              type: "string",
+              description: "Only include files modified on or after this ISO 8601 timestamp."
+            },
+            includeKinds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional top-level directory allow-list."
+            },
+            peerIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional peer id allow-list for the peers/ subtree."
+            },
+            includeTranscripts: { type: "boolean" },
+            encrypt: { type: "boolean" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.capsule_import",
+        description: "Import a Remnic capsule archive into the namespace-scoped memory store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            archivePath: {
+              type: "string",
+              description: "Path to a .capsule.json.gz or .capsule.json.gz.enc archive."
+            },
+            namespace: { type: "string" },
+            mode: {
+              type: "string",
+              enum: ["skip", "overwrite", "fork"],
+              description: "Conflict handling mode. Defaults to skip."
+            }
+          },
+          required: ["archivePath"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.capsule_list",
+        description: "List capsule archives in the namespace-scoped capsule store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          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.procedure_mining_run",
+        description: "Run procedural memory mining from causal trajectories (issue #519). Respects procedural.enabled; writes under procedures/ when clusters qualify.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.pattern_reinforcement_run",
+        description: "Run the pattern-reinforcement maintenance job (issue #687 PR 2/4). Clusters duplicate non-procedural memories by normalized content, promotes the most-recent member to canonical, and supersedes the older duplicates. Gated on patternReinforcementEnabled and the patternReinforcementCadenceMs floor \u2014 pass force=true to bypass the cadence for an ad-hoc operator run.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" },
+            force: { type: "boolean" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        // The canonical `remnic.procedural_stats` alias is added automatically
+        // by `withToolAliases` — the dual-naming invariant keeps both names
+        // alive for the legacy surface.
+        name: "engram.procedural_stats",
+        description: "Procedural memory stats (issue #567): counts by status, recent write activity, and the active procedural.* config. Read-only, namespace-scoped.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          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" },
+                  sourceFormat: {
+                    type: "string",
+                    enum: ["openai", "anthropic", "openclaw", "pi", "lossless-claw", "remnic"]
+                  },
+                  rawContent: {
+                    description: "Optional native provider content blocks for structured message-part capture."
+                  },
+                  parts: {
+                    type: "array",
+                    description: "Optional normalized Remnic LCM message parts.",
+                    items: {
+                      type: "object",
+                      properties: {
+                        ordinal: { type: ["number", "null"], minimum: 0 },
+                        kind: {
+                          type: "string",
+                          enum: [
+                            "text",
+                            "tool_call",
+                            "tool_result",
+                            "patch",
+                            "file_read",
+                            "file_write",
+                            "step_start",
+                            "step_finish",
+                            "snapshot",
+                            "retry"
+                          ]
+                        },
+                        payload: { type: "object", additionalProperties: true },
+                        toolName: { type: ["string", "null"] },
+                        tool_name: { type: ["string", "null"] },
+                        filePath: { type: ["string", "null"] },
+                        file_path: { type: ["string", "null"] },
+                        createdAt: { type: ["string", "null"] },
+                        created_at: { type: ["string", "null"] }
+                      },
+                      required: ["kind", "payload"],
+                      additionalProperties: false
+                    }
+                  }
+                },
+                required: ["role", "content"],
+                additionalProperties: false
+              },
+              description: "Conversation messages to observe"
+            },
+            namespace: { type: "string" },
+            skipExtraction: { type: "boolean" },
+            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
+            projectTag: { type: "string", description: "Project tag for non-git project scoping (e.g. 'blend-supply')." }
+          },
+          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
+        }
+      },
+      {
+        name: "engram.lcm_compaction_flush",
+        description: "Flush pending LCM observe work and incremental summaries before a host compacts session context.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string", description: "Conversation session identifier" },
+            namespace: { type: "string" }
+          },
+          required: ["sessionKey"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.lcm_compaction_record",
+        description: "Record a host compaction event with before/after token counts in the LCM archive.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string", description: "Conversation session identifier" },
+            namespace: { type: "string" },
+            tokensBefore: { type: "integer", minimum: 0 },
+            tokensAfter: { type: "integer", minimum: 0 }
+          },
+          required: ["sessionKey", "tokensBefore", "tokensAfter"],
+          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
+        }
+      },
+      {
+        // Graph snapshot for the admin pane (issue #691 PR 2/5).  Returns
+        // a read-only `{ nodes, edges, generatedAt }` view of the
+        // multi-graph adjacency, with the same filter knobs as the HTTP
+        // surface so connectors / CLI clients can hit either endpoint
+        // interchangeably.
+        name: "engram.graph_snapshot",
+        description: "Return a read-only graph snapshot (nodes + edges) for the admin pane. Filters: limit (default 500, max 5000), since (ISO timestamp), focusNodeId (restricts to neighborhood), categories (allow-list of memory categories).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" },
+            limit: { type: "number", description: "Maximum number of edges to return (default 500, max 5000)." },
+            since: { type: "string", description: "Inclusive lower bound on edge timestamp (ISO-8601)." },
+            focusNodeId: { type: "string", description: "When set, restrict the snapshot to the focus node and its neighbors." },
+            categories: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional category allow-list (e.g. ['fact', 'decision'])."
+            }
+          },
+          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
+        }
+      },
+      // Memory Worth outcome signal (issue #560 PR 3). Callers record whether
+      // a session that used a given memory ultimately succeeded or failed;
+      // the counter is persisted in the memory's frontmatter (mw_success /
+      // mw_fail) and will feed the recall-time filter added in PR 4.
+      {
+        name: "engram.memory_outcome",
+        description: "Record a Memory Worth outcome (success/failure) for a memory. Increments mw_success or mw_fail in the memory's frontmatter for use by the recall filter.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            memoryId: { type: "string" },
+            outcome: { type: "string", enum: ["success", "failure"] },
+            namespace: { type: "string" },
+            sessionKey: { type: "string" },
+            timestamp: { type: "string", description: "Optional ISO-8601 timestamp of the observation." }
+          },
+          required: ["memoryId", "outcome"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_action_apply",
+        description: "Record a memory-action application event for policy-learning telemetry.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "store_episode",
+                "store_note",
+                "update_note",
+                "create_artifact",
+                "summarize_node",
+                "discard",
+                "link_graph"
+              ]
+            },
+            category: { type: "string" },
+            content: { type: "string" },
+            outcome: { type: "string", enum: ["applied", "skipped", "failed"] },
+            reason: { type: "string" },
+            memoryId: { type: "string" },
+            sessionKey: { type: "string" },
+            linkTargetId: { type: "string" },
+            linkType: { type: "string" },
+            linkStrength: { type: "number" },
+            artifactType: { type: "string" },
+            execute: { type: "boolean" },
+            sourcePrompt: { type: "string" },
+            namespace: { type: "string" },
+            dryRun: { type: "boolean" }
+          },
+          required: ["action"],
+          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
+        }
+      },
+      // ── Daily Context Briefing (#370) ───────────────────────────────────
+      // Uses the legacy "engram.*" prefix like every other tool in this array;
+      // withToolAliases (applied via .flatMap below) generates the canonical
+      // "remnic.briefing" alias automatically.
+      ...service.briefingEnabled ? [{
+        name: "engram.briefing",
+        description: "Generate a daily context briefing by cross-referencing active entities, recent facts, open commitments, and optional calendar events.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            since: { type: "string", description: "Lookback window (e.g. 'yesterday', '3d', '1w', '24h')." },
+            focus: { type: "string", description: "Optional focus filter (e.g. 'person:Jane Doe', 'project:remnic-core', 'topic:retrieval')." },
+            namespace: { type: "string" },
+            format: { type: "string", enum: ["markdown", "json"] },
+            maxFollowups: { type: "number", description: "Maximum LLM-suggested follow-ups (0 disables that section)." }
+          },
+          additionalProperties: false
+        }
+      }] : [],
+      // ── Contradiction Review (issue #520) ────────────────────────────────
+      {
+        name: "engram.review_list",
+        description: "List contradiction review items pending user resolution.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            filter: { type: "string", enum: ["all", "unresolved", "contradicts", "independent", "duplicates", "needs-user"], description: "Filter by verdict type. Default: unresolved." },
+            namespace: { type: "string" },
+            limit: { type: "number", description: "Max items to return (default 50)." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.review_resolve",
+        description: "Resolve a contradiction pair with a chosen verb.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pairId: { type: "string", description: "The contradiction pair ID to resolve." },
+            verb: { type: "string", enum: ["keep-a", "keep-b", "merge", "both-valid", "needs-more-context"], description: "Resolution action." },
+            mergedMemoryId: { type: "string", description: "Existing merged memory ID to use when verb is merge." },
+            mergedContent: { type: "string", description: "Content for a new merged memory when verb is merge." }
+          },
+          required: ["pairId", "verb"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.contradiction_scan_run",
+        description: "Run an on-demand contradiction scan over the memory corpus.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.memory_summarize_hourly",
+        description: "Generate hourly summaries for recent conversations.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.conversation_index_update",
+        description: "Chunk transcript history into conversation-index documents.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string" },
+            hours: { type: "number", description: "How many hours of transcript history to include." },
+            embed: { type: "boolean", description: "If true, run QMD embed after update for this invocation." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.profiling_report",
+        description: "Return timing and performance data for Remnic recall and extraction pipelines. Requires profilingEnabled: true.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            format: {
+              type: "string",
+              enum: ["ascii", "json"],
+              description: "Output format. Defaults to ascii."
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 20,
+              description: "Number of recent traces to include. Defaults to 5."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.graph_edge_decay_run",
+        description: "Run the graph-edge-confidence decay maintenance pass (issue #681 PR 2/3). Respects graphEdgeDecayEnabled; writes a structured telemetry record to state/graph-edge-decay-status.json.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dryRun: { type: "boolean" }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.live_connectors_run",
+        description: "Run due live connectors once. Used by the live-connector cron and available for operator-triggered sync checks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            force: {
+              type: "boolean",
+              description: "When true, run enabled connectors even if their poll interval has not elapsed."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      // ── Peer Registry tools (issue #679 PR 4/5) ─────────────────────────
+      {
+        name: "engram.peer_list",
+        description: "List all registered peers in the peer registry (issue #679). Returns an array of peer identity records sorted alphabetically by id.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.peer_get",
+        description: "Get a single peer by id. Returns the peer's identity record or { found: false } when not found (issue #679).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Peer id to look up." }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.peer_set",
+        description: "Create or update a peer identity record (issue #679). On first write, creates the peer with the given kind (default 'human'). On subsequent writes, updates displayName and/or notes; kind and createdAt are immutable.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Peer id \u2014 must match PEER_ID_PATTERN." },
+            kind: {
+              type: "string",
+              enum: ["self", "human", "agent", "integration"],
+              description: "Kind of peer. Required on first write; ignored on updates."
+            },
+            displayName: { type: "string", description: "Human-readable display name." },
+            notes: { type: "string", description: "Optional free-form markdown notes." }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.peer_delete",
+        description: "Delete a peer's identity record (issue #679). Idempotent \u2014 succeeds even if the peer does not exist. The peer directory is preserved so profile and interaction-log data are not destroyed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Peer id to delete." }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.peer_profile_get",
+        description: "Get the evolving cognitive profile for a peer (issue #679). Returns the profile written by the async reasoner (PR 2/5), or { found: false } if no profile has been generated yet.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Peer id whose profile to retrieve." }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.peer_forget",
+        description: "DESTRUCTIVELY purge the entire peer directory (identity.md + profile.md + interactions.log.md and any companion files). Requires confirm: 'yes'. Idempotent \u2014 safe to call twice. Use engram.peer_delete when you only want to remove the identity record and preserve profile data.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Peer id to purge." },
+            confirm: {
+              type: "string",
+              enum: ["yes"],
+              description: "Must be exactly 'yes' to proceed. Guard against accidental invocation."
+            }
+          },
+          required: ["id", "confirm"],
+          additionalProperties: false
+        }
+      },
+      // ── Operator Console state (issue #688 PR 2/3) ─────────────────────────
+      {
+        name: "engram.console_state",
+        description: "Return a point-in-time ConsoleStateSnapshot of the engine's runtime state \u2014 buffer, extraction queue, dedup decisions, maintenance ledger tail, QMD probe, and daemon info (issue #688). Read-only; never mutates state.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: {
+              type: "string",
+              description: "Optional namespace to scope the snapshot."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      // ── Dreams telemetry (issue #678 PR 3+4) ─────────────────────────────
+      {
+        name: "engram.dreams_status",
+        description: "Return per-phase Dreams pipeline telemetry for the last N hours (default 24). Reports run count, total duration, and items processed for each phase: lightSleep, rem, deepSleep.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            windowHours: {
+              type: "number",
+              description: "How many hours to look back (default 24, minimum 1)."
+            },
+            namespace: {
+              type: "string",
+              description: "Optional namespace to read Dreams telemetry from."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.dreams_run",
+        description: "Manually invoke a single Dreams pipeline phase (lightSleep, rem, or deepSleep). Returns the same telemetry shape as a scheduled run. Pass dryRun: true to preview without committing writes.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            phase: {
+              type: "string",
+              enum: ["lightSleep", "rem", "deepSleep"],
+              description: "Which phase to run."
+            },
+            dryRun: {
+              type: "boolean",
+              description: "When true, report what would change without committing writes (default false)."
+            },
+            namespace: {
+              type: "string",
+              description: "Optional namespace to run the phase in."
+            }
+          },
+          required: ["phase"],
+          additionalProperties: false
+        }
+      }
+    ].flatMap((tool) => withToolAliases(tool));
+  }
+  service;
+  buffer = Buffer.alloc(0);
+  flushTask = null;
+  tools;
+  resources;
+  resourceTextByUri;
+  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();
+  /** Whether oai-mem-citation guidance is explicitly enabled via config. */
+  citationsEnabled;
+  /** Whether to auto-enable citations for Codex adapter connections. */
+  citationsAutoDetect;
+  /** 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: {},
+            resources: {}
+          },
+          serverInfo: {
+            name: "remnic",
+            version
+          }
+        }
+      };
+    }
+    if (method === "tools/list") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          tools: this.tools
+        }
+      };
+    }
+    if (method === "resources/list") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resources: this.resources
+        }
+      };
+    }
+    if (method === "resources/templates/list") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resourceTemplates: []
+        }
+      };
+    }
+    if (method === "resources/read") {
+      const params = request.params ?? {};
+      const uri = typeof params.uri === "string" ? params.uri : "";
+      const resource = this.resources.find((entry) => entry.uri === uri);
+      if (!resource) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32602,
+            message: `Unknown resource URI: ${uri}`
+          }
+        };
+      }
+      const text = this.resourceTextByUri.get(resource.uri);
+      if (text === void 0) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32603,
+            message: `Resource content unavailable: ${resource.uri}`
+          }
+        };
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          contents: [
+            {
+              uri: resource.uri,
+              mimeType: resource.mimeType,
+              text,
+              _meta: resource._meta
+            }
+          ]
+        }
+      };
+    }
+    if (method === "tools/call") {
+      const params = request.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      try {
+        let argumentsObject = {};
+        if ("arguments" in params && params.arguments !== void 0) {
+          if (params.arguments === null || typeof params.arguments !== "object" || Array.isArray(params.arguments)) {
+            throw new EngramAccessInputError("tools/call arguments must be an object when provided");
+          }
+          argumentsObject = params.arguments;
+        }
+        const effectivePrincipal = options?.principalOverride ?? this.authenticatedPrincipal;
+        const result = await this.callTool(name, argumentsObject, effectivePrincipal, options?.sessionId);
+        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);
+  }
+  /**
+   * Determine whether oai-mem-citation guidance should be appended to recall.
+   * Returns true when explicitly enabled via config OR when auto-detect is
+   * active and the current MCP session belongs to a Codex adapter client.
+   *
+   * When no sessionId is provided (e.g., stdio transport where there are no
+   * HTTP headers carrying mcp-session-id), fall back to checking if there is
+   * exactly one known session whose clientInfo matches the Codex pattern.
+   * This covers the common stdio case where a single client connection exists.
+   */
+  shouldEmitCitations(mcpSessionId) {
+    if (this.citationsEnabled) return true;
+    if (!this.citationsAutoDetect) return false;
+    if (mcpSessionId) {
+      const info = this.clientInfoBySession.get(mcpSessionId);
+      if (!info) return false;
+      return this.isCodexClient(info);
+    }
+    if (this.clientInfoBySession.size === 1) {
+      const [info] = [...this.clientInfoBySession.values()];
+      if (info) return this.isCodexClient(info);
+    }
+    return false;
+  }
+  /** Check whether a clientInfo record identifies a Codex adapter client. */
+  isCodexClient(info) {
+    const lowerName = info.name.toLowerCase();
+    return lowerName === "codex-mcp-client" || lowerName.includes("codex");
+  }
+  /**
+   * Build citation metadata for each recall result that has a path.
+   * Line range defaults to 1-1 when not determinable from the summary.
+   */
+  buildRecallCitations(response) {
+    return response.results.filter((r) => r.path && r.path.length > 0).map((r) => ({
+      memoryId: r.id,
+      path: r.path,
+      lineStart: 1,
+      lineEnd: 1,
+      noteDefault: r.preview?.slice(0, 60) || r.id
+    }));
+  }
+  async callTool(name, args, effectivePrincipal, mcpSessionId) {
+    switch (toLegacyToolName(name)) {
+      case "engram.recall": {
+        let disclosure;
+        if ("disclosure" in args && args.disclosure !== void 0 && args.disclosure !== null) {
+          if (typeof args.disclosure !== "string") {
+            throw new EngramAccessInputError(
+              "disclosure must be a string (one of: chunk, section, raw)"
+            );
+          }
+          disclosure = args.disclosure;
+        }
+        if ("cwd" in args && args.cwd !== void 0 && args.cwd !== null && typeof args.cwd !== "string") {
+          throw new EngramAccessInputError("cwd must be a string");
+        }
+        if ("projectTag" in args && args.projectTag !== void 0 && args.projectTag !== null && typeof args.projectTag !== "string") {
+          throw new EngramAccessInputError("projectTag must be a string");
+        }
+        if ("asOf" in args && args.asOf !== void 0 && args.asOf !== null && typeof args.asOf !== "string") {
+          throw new EngramAccessInputError("asOf must be a string (ISO 8601 timestamp)");
+        }
+        let tags;
+        if ("tags" in args && args.tags !== void 0 && args.tags !== null) {
+          if (!Array.isArray(args.tags) || !args.tags.every((t) => typeof t === "string")) {
+            throw new EngramAccessInputError("tags must be an array of strings");
+          }
+          tags = args.tags;
+        }
+        let tagMatch;
+        if ("tagMatch" in args && args.tagMatch !== void 0 && args.tagMatch !== null) {
+          if (typeof args.tagMatch !== "string" || args.tagMatch !== "any" && args.tagMatch !== "all") {
+            throw new EngramAccessInputError(
+              `tagMatch must be one of: any, all (got: ${String(args.tagMatch)})`
+            );
+          }
+          tagMatch = args.tagMatch;
+        }
+        const response = await this.service.recall({
+          query: typeof args.query === "string" ? args.query : "",
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          authenticatedPrincipal: effectivePrincipal,
+          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,
+          disclosure,
+          cwd: typeof args.cwd === "string" ? args.cwd : void 0,
+          projectTag: typeof args.projectTag === "string" ? args.projectTag : void 0,
+          asOf: typeof args.asOf === "string" ? args.asOf : void 0,
+          ...tags !== void 0 ? { tags } : {},
+          ...tagMatch !== void 0 ? { tagMatch } : {}
+        });
+        if (this.shouldEmitCitations(mcpSessionId)) {
+          const citations = this.buildRecallCitations(response);
+          const guidance = buildCitationGuidance(citations);
+          if (guidance.length > 0) {
+            return {
+              ...response,
+              context: response.context + guidance,
+              citations
+            };
+          }
+        }
+        return response;
+      }
+      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.set_coding_context": {
+        const sessionKey = typeof args.sessionKey === "string" ? args.sessionKey : "";
+        const hasProjectTag = typeof args.projectTag === "string" && args.projectTag.trim().length > 0;
+        const hasCodingContext = "codingContext" in args;
+        if (!hasCodingContext && hasProjectTag) {
+          const tag = args.projectTag.trim();
+          this.service.setCodingContext({
+            sessionKey,
+            codingContext: {
+              projectId: `tag:${tag}`,
+              branch: null,
+              rootPath: `tag:${tag}`,
+              defaultBranch: null
+            }
+          });
+          return { ok: true };
+        }
+        if (!hasCodingContext && !hasProjectTag) {
+          throw new EngramAccessInputError(
+            "set_coding_context requires either codingContext or projectTag"
+          );
+        }
+        const rawCtx = args.codingContext;
+        let codingContext = null;
+        if (rawCtx !== null) {
+          if (typeof rawCtx !== "object" || rawCtx === void 0) {
+            throw new EngramAccessInputError("codingContext must be an object or null");
+          }
+          const obj = rawCtx;
+          const projectId = typeof obj.projectId === "string" ? obj.projectId : "";
+          const rootPath = typeof obj.rootPath === "string" ? obj.rootPath : "";
+          const branch = obj.branch === null ? null : typeof obj.branch === "string" ? obj.branch : void 0;
+          const defaultBranch = obj.defaultBranch === null ? null : typeof obj.defaultBranch === "string" ? obj.defaultBranch : void 0;
+          if (branch === void 0) {
+            throw new EngramAccessInputError("codingContext.branch must be a string or null");
+          }
+          if (defaultBranch === void 0) {
+            throw new EngramAccessInputError("codingContext.defaultBranch must be a string or null");
+          }
+          codingContext = { projectId, branch, rootPath, defaultBranch };
+        }
+        this.service.setCodingContext({ sessionKey, codingContext });
+        return { ok: true };
+      }
+      case "engram.recall_tier_explain":
+        return this.service.recallTierExplain(
+          typeof args.sessionKey === "string" && args.sessionKey.length > 0 ? args.sessionKey : void 0,
+          typeof args.namespace === "string" && args.namespace.length > 0 ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      case "engram.recall_xray": {
+        const query = typeof args.query === "string" ? args.query : "";
+        const sessionKey = typeof args.sessionKey === "string" && args.sessionKey.length > 0 ? args.sessionKey : void 0;
+        const namespace = typeof args.namespace === "string" && args.namespace.length > 0 ? args.namespace : void 0;
+        let budget;
+        if (args.budget !== void 0 && args.budget !== null) {
+          if (typeof args.budget !== "number" && typeof args.budget !== "string") {
+            throw new Error(
+              `engram.recall_xray: budget expects a positive integer; got ${JSON.stringify(args.budget)}`
+            );
+          }
+          const parsed = typeof args.budget === "number" ? args.budget : Number(args.budget);
+          if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+            throw new Error(
+              `engram.recall_xray: budget expects a positive integer; got ${JSON.stringify(args.budget)}`
+            );
+          }
+          budget = parsed;
+        }
+        let disclosure;
+        if ("disclosure" in args && args.disclosure !== void 0 && args.disclosure !== null && args.disclosure !== "") {
+          if (typeof args.disclosure !== "string") {
+            throw new Error(
+              "engram.recall_xray: disclosure must be a string (one of: chunk, section, raw)"
+            );
+          }
+          disclosure = args.disclosure;
+        }
+        return this.service.recallXray({
+          query,
+          sessionKey,
+          namespace,
+          budget,
+          authenticatedPrincipal: effectivePrincipal,
+          ...disclosure !== void 0 ? { disclosure } : {}
+        });
+      }
+      case "engram.action_confidence": {
+        const body = parseMcpRequest("actionConfidence", args);
+        return this.service.actionConfidence(body);
+      }
+      case REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL: {
+        if (typeof args.query !== "string" || args.query.trim().length === 0) {
+          throw new EngramAccessInputError(
+            "chatgpt_memory_inspector requires a non-empty query string"
+          );
+        }
+        if ("sessionKey" in args && args.sessionKey !== void 0 && args.sessionKey !== null && typeof args.sessionKey !== "string") {
+          throw new EngramAccessInputError("sessionKey must be a string");
+        }
+        if ("namespace" in args && args.namespace !== void 0 && args.namespace !== null && typeof args.namespace !== "string") {
+          throw new EngramAccessInputError("namespace must be a string");
+        }
+        let currentContextScopes;
+        if (args.currentContextScopes !== void 0 && args.currentContextScopes !== null) {
+          if (!Array.isArray(args.currentContextScopes) || !args.currentContextScopes.every((scope) => typeof scope === "string")) {
+            throw new EngramAccessInputError(
+              "currentContextScopes must be an array of strings"
+            );
+          }
+          currentContextScopes = args.currentContextScopes;
+        }
+        const input = {
+          query: args.query.trim()
+        };
+        if (typeof args.sessionKey === "string" && args.sessionKey.trim().length > 0) {
+          input.sessionKey = args.sessionKey;
+        }
+        if (typeof args.namespace === "string" && args.namespace.trim().length > 0) {
+          input.namespace = args.namespace;
+        }
+        if (currentContextScopes !== void 0) {
+          input.currentContextScopes = currentContextScopes;
+        }
+        const recallSessionKey = resolveChatGptInspectorRecallSessionKey(
+          input.sessionKey,
+          effectivePrincipal
+        );
+        const xrayResponse = await this.service.recallXray({
+          query: input.query,
+          sessionKey: recallSessionKey,
+          namespace: input.namespace,
+          currentContextScopes: input.currentContextScopes,
+          authenticatedPrincipal: effectivePrincipal,
+          mode: "full",
+          disclosure: "chunk",
+          includeRecall: true
+        });
+        const xray = xrayResponse.snapshotFound === true ? xrayResponse.snapshot ?? null : null;
+        const recall = xrayResponse.recall ?? {
+          query: input.query,
+          namespace: input.namespace ?? xray?.namespace ?? "global",
+          context: "",
+          count: 0,
+          memoryIds: [],
+          results: [],
+          fallbackUsed: false,
+          sourcesUsed: [],
+          disclosure: "chunk"
+        };
+        const actionRequest = buildChatGptMemoryInspectorActionRequest(
+          input,
+          recall,
+          xray
+        );
+        const actionConfidence = await this.service.actionConfidence(actionRequest);
+        return buildChatGptMemoryInspectorResult(
+          input,
+          recall,
+          xray,
+          actionConfidence
+        );
+      }
+      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.capsule_export": {
+        const body = parseMcpRequest("capsuleExport", args);
+        return this.service.capsuleExport({
+          name: body.name,
+          namespace: body.namespace,
+          principal: effectivePrincipal,
+          since: body.since,
+          includeKinds: body.includeKinds,
+          peerIds: body.peerIds,
+          includeTranscripts: body.includeTranscripts,
+          encrypt: body.encrypt
+        });
+      }
+      case "engram.capsule_import": {
+        const body = parseMcpRequest("capsuleImport", args);
+        return this.service.capsuleImport({
+          archivePath: expandTildePath(body.archivePath),
+          namespace: body.namespace,
+          principal: effectivePrincipal,
+          mode: body.mode
+        });
+      }
+      case "engram.capsule_list": {
+        const body = parseMcpRequest("capsuleList", args);
+        return this.service.capsuleList({
+          namespace: body.namespace,
+          principal: effectivePrincipal
+        });
+      }
+      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.procedure_mining_run":
+        return this.service.procedureMiningRun(
+          {
+            namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+            authenticatedPrincipal: effectivePrincipal
+          },
+          effectivePrincipal
+        );
+      case "engram.pattern_reinforcement_run":
+        return this.service.patternReinforcementRun(
+          {
+            namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+            authenticatedPrincipal: effectivePrincipal,
+            force: args.force === true
+          },
+          effectivePrincipal
+        );
+      case "remnic.procedural_stats":
+      case "engram.procedural_stats":
+        return this.service.procedureStats(
+          {
+            namespace: typeof args.namespace === "string" ? args.namespace : void 0
+          },
+          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": {
+        const body = parseMcpRequest("observe", args);
+        return this.service.observe({
+          sessionKey: body.sessionKey,
+          messages: body.messages.map((message) => ({
+            role: message.role,
+            content: message.content,
+            parts: message.parts ?? void 0,
+            rawContent: message.rawContent ?? void 0,
+            sourceFormat: message.sourceFormat ?? void 0
+          })),
+          namespace: body.namespace,
+          authenticatedPrincipal: effectivePrincipal,
+          skipExtraction: body.skipExtraction === true,
+          cwd: body.cwd,
+          projectTag: body.projectTag
+        });
+      }
+      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
+        });
+      case "engram.lcm_compaction_flush": {
+        const body = parseMcpRequest("lcmCompactionFlush", args);
+        return this.service.lcmCompactionFlush({
+          sessionKey: body.sessionKey,
+          namespace: body.namespace,
+          authenticatedPrincipal: effectivePrincipal
+        });
+      }
+      case "engram.lcm_compaction_record": {
+        const body = parseMcpRequest("lcmCompactionRecord", args);
+        return this.service.lcmCompactionRecord({
+          sessionKey: body.sessionKey,
+          namespace: body.namespace,
+          tokensBefore: body.tokensBefore,
+          tokensAfter: body.tokensAfter,
+          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.graph_snapshot": {
+        if (args.limit !== void 0 && typeof args.limit !== "number") {
+          throw new Error("engram.graph_snapshot: limit must be a number");
+        }
+        if (args.since !== void 0 && typeof args.since !== "string") {
+          throw new Error("engram.graph_snapshot: since must be a string");
+        }
+        if (args.focusNodeId !== void 0 && typeof args.focusNodeId !== "string") {
+          throw new Error("engram.graph_snapshot: focusNodeId must be a string");
+        }
+        let categories;
+        if (args.categories !== void 0) {
+          if (!Array.isArray(args.categories)) {
+            throw new Error(
+              "engram.graph_snapshot: categories must be an array of strings"
+            );
+          }
+          categories = args.categories.map((value, index) => {
+            if (typeof value !== "string") {
+              throw new Error(
+                `engram.graph_snapshot: categories[${index}] must be a string`
+              );
+            }
+            return value;
+          });
+        }
+        return this.service.graphSnapshot(
+          {
+            namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+            limit: typeof args.limit === "number" ? args.limit : void 0,
+            since: typeof args.since === "string" ? args.since : void 0,
+            focusNodeId: typeof args.focusNodeId === "string" ? args.focusNodeId : void 0,
+            ...categories !== void 0 ? { categories } : {}
+          },
+          effectivePrincipal
+        );
+      }
+      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.memory_outcome": {
+        const outcome = args.outcome;
+        if (outcome !== "success" && outcome !== "failure") {
+          throw new Error(
+            `engram.memory_outcome: outcome must be "success" or "failure"; got ${JSON.stringify(outcome)}`
+          );
+        }
+        return this.service.memoryOutcome({
+          memoryId: typeof args.memoryId === "string" ? args.memoryId : "",
+          outcome,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          timestamp: typeof args.timestamp === "string" ? args.timestamp : void 0
+        });
+      }
+      case "engram.memory_action_apply":
+        return this.service.memoryActionApply({
+          action: typeof args.action === "string" ? args.action : "",
+          outcome: typeof args.outcome === "string" ? args.outcome : void 0,
+          reason: typeof args.reason === "string" ? args.reason : void 0,
+          memoryId: typeof args.memoryId === "string" ? args.memoryId : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          content: typeof args.content === "string" ? args.content : void 0,
+          category: typeof args.category === "string" ? args.category : void 0,
+          linkTargetId: typeof args.linkTargetId === "string" ? args.linkTargetId : void 0,
+          linkType: typeof args.linkType === "string" ? args.linkType : void 0,
+          linkStrength: typeof args.linkStrength === "number" ? args.linkStrength : void 0,
+          artifactType: typeof args.artifactType === "string" ? args.artifactType : void 0,
+          execute: typeof args.execute === "boolean" ? args.execute : void 0,
+          sourcePrompt: typeof args.sourcePrompt === "string" ? args.sourcePrompt : void 0,
+          dryRun: args.dryRun === true
+        });
+      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
+        });
+      // ── Daily Context Briefing (#370) ───────────────────────────────────
+      case "engram.briefing": {
+        const rawFormat = typeof args.format === "string" ? args.format : void 0;
+        const formatErr = validateBriefingFormat(rawFormat);
+        if (formatErr) throw new Error(formatErr);
+        return this.service.briefing({
+          since: typeof args.since === "string" ? args.since : void 0,
+          focus: typeof args.focus === "string" ? args.focus : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          format: rawFormat,
+          maxFollowups: typeof args.maxFollowups === "number" ? args.maxFollowups : void 0,
+          principal: effectivePrincipal
+        });
+      }
+      // ── Contradiction Review (issue #520) ──────────────────────────────────
+      case "engram.review_list":
+      case "remnic.review_list": {
+        const {
+          isDefaultReviewNamespace,
+          listPairs
+        } = await import("./contradiction-review-ATP4S6IC.js");
+        const VALID_REVIEW_FILTERS = /* @__PURE__ */ new Set(["all", "unresolved", "contradicts", "independent", "duplicates", "needs-user"]);
+        const rawFilter = typeof args.filter === "string" ? args.filter : "unresolved";
+        if (!VALID_REVIEW_FILTERS.has(rawFilter)) {
+          throw new Error(`Invalid filter '${rawFilter}'. Valid: ${[...VALID_REVIEW_FILTERS].join(", ")}`);
+        }
+        const filter = rawFilter;
+        const ns = typeof args.namespace === "string" ? args.namespace : void 0;
+        const limit = typeof args.limit === "number" ? args.limit : 50;
+        const resolved = await this.service.getReadableStorageForNamespace(ns, effectivePrincipal);
+        const reviewNamespace = this.service.configRef.namespacesEnabled ? resolved.namespace : void 0;
+        const includeUnscopedForNamespace = Boolean(
+          reviewNamespace && isDefaultReviewNamespace(this.service.configRef.defaultNamespace, ns, reviewNamespace)
+        );
+        return listPairs(this.service.memoryDir, {
+          filter,
+          namespace: reviewNamespace,
+          includeUnscopedForNamespace,
+          limit
+        });
+      }
+      case "engram.review_resolve":
+      case "remnic.review_resolve": {
+        const pairId = typeof args.pairId === "string" ? args.pairId : "";
+        const verb = typeof args.verb === "string" ? args.verb : "";
+        if (!pairId) throw new Error("pairId is required");
+        if (!verb) throw new Error("verb is required");
+        const { isValidResolutionVerb } = await import("./resolution-B7FNQSSP.js");
+        if (!isValidResolutionVerb(verb)) throw new Error(`Invalid verb: ${verb}. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context`);
+        const { executeResolution } = await import("./resolution-B7FNQSSP.js");
+        return executeResolution(this.service.memoryDir, this.service.storageRef, pairId, verb, {
+          mergedMemoryId: typeof args.mergedMemoryId === "string" ? args.mergedMemoryId : void 0,
+          mergedContent: typeof args.mergedContent === "string" ? args.mergedContent : void 0,
+          storageForNamespace: async (namespace) => {
+            const resolved = await this.service.getWritableStorageForNamespace(namespace, effectivePrincipal);
+            return resolved.storage;
+          }
+        });
+      }
+      case "engram.contradiction_scan_run":
+      case "remnic.contradiction_scan_run": {
+        const { runContradictionScan } = await import("./contradiction-scan-5A4IDZV5.js");
+        return runContradictionScan({
+          storage: this.service.storageRef,
+          config: this.service.configRef,
+          memoryDir: this.service.memoryDir,
+          embeddingLookupFactory: this.service.embeddingLookupFactoryRef,
+          storageForNamespace: (namespace) => this.service.getWritableStorageForNamespace(namespace, effectivePrincipal),
+          localLlm: this.service.localLlmRef,
+          fallbackLlm: this.service.fallbackLlmRef,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0
+        });
+      }
+      case "engram.memory_summarize_hourly":
+      case "remnic.memory_summarize_hourly":
+        return this.service.memorySummarizeHourly();
+      case "engram.conversation_index_update":
+      case "remnic.conversation_index_update": {
+        if ("sessionKey" in args && args.sessionKey !== void 0 && typeof args.sessionKey !== "string") {
+          throw new Error("sessionKey must be a string when provided");
+        }
+        const sessionKey = typeof args.sessionKey === "string" ? args.sessionKey : void 0;
+        return this.service.conversationIndexUpdate({
+          sessionKey,
+          hours: typeof args.hours === "number" && Number.isFinite(args.hours) ? args.hours : void 0,
+          embed: typeof args.embed === "boolean" ? args.embed : void 0
+        });
+      }
+      case "engram.profiling_report":
+      case "remnic.profiling_report": {
+        if ("format" in args && args.format !== void 0 && typeof args.format !== "string") {
+          throw new EngramAccessInputError("format must be a string when provided");
+        }
+        if ("limit" in args && args.limit !== void 0 && typeof args.limit !== "number") {
+          throw new EngramAccessInputError("limit must be a number when provided");
+        }
+        return this.service.profilingReport({
+          format: typeof args.format === "string" ? args.format : void 0,
+          limit: typeof args.limit === "number" ? args.limit : void 0
+        });
+      }
+      case "engram.graph_edge_decay_run":
+      case "remnic.graph_edge_decay_run": {
+        const cfg = this.service.configRef;
+        if (!cfg.graphEdgeDecayEnabled) {
+          return {
+            ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+            disabled: true,
+            reason: "graphEdgeDecayEnabled is false"
+          };
+        }
+        const { runGraphEdgeDecayMaintenanceAcrossNamespaces } = await import("./graph-edge-decay-5DI5GUNL.js");
+        const dryRun = args.dryRun === true;
+        const results = await runGraphEdgeDecayMaintenanceAcrossNamespaces(
+          this.service.memoryDir,
+          {
+            windowMs: cfg.graphEdgeDecayWindowMs,
+            perWindow: cfg.graphEdgeDecayPerWindow,
+            floor: cfg.graphEdgeDecayFloor,
+            visibilityThreshold: cfg.graphEdgeDecayVisibilityThreshold,
+            dryRun,
+            namespacesEnabled: cfg.namespacesEnabled === true,
+            defaultNamespace: cfg.defaultNamespace
+          }
+        );
+        return { results };
+      }
+      case "engram.live_connectors_run":
+      case "remnic.live_connectors_run":
+        return this.service.liveConnectorsRun(
+          {
+            authenticatedPrincipal: effectivePrincipal,
+            force: args.force === true
+          },
+          effectivePrincipal
+        );
+      // ── Peer Registry dispatchers (issue #679 PR 4/5) ─────────────────
+      case "engram.peer_list":
+      case "remnic.peer_list":
+        return this.service.peerList();
+      case "engram.peer_get":
+      case "remnic.peer_get": {
+        const id = typeof args.id === "string" ? args.id : "";
+        if (!id) throw new Error("engram.peer_get: id is required");
+        return this.service.peerGet(id);
+      }
+      case "engram.peer_set":
+      case "remnic.peer_set": {
+        const id = typeof args.id === "string" ? args.id : "";
+        if (!id) throw new Error("engram.peer_set: id is required");
+        if (args.kind !== void 0 && typeof args.kind !== "string") {
+          throw new Error("engram.peer_set: kind must be a string when provided");
+        }
+        if (args.displayName !== void 0 && typeof args.displayName !== "string") {
+          throw new Error("engram.peer_set: displayName must be a string when provided");
+        }
+        if (args.notes !== void 0 && typeof args.notes !== "string") {
+          throw new Error("engram.peer_set: notes must be a string when provided");
+        }
+        return this.service.peerSet({
+          id,
+          kind: typeof args.kind === "string" ? args.kind : void 0,
+          displayName: typeof args.displayName === "string" ? args.displayName : void 0,
+          notes: typeof args.notes === "string" ? args.notes : void 0
+        });
+      }
+      case "engram.peer_delete":
+      case "remnic.peer_delete": {
+        const id = typeof args.id === "string" ? args.id : "";
+        if (!id) throw new Error("engram.peer_delete: id is required");
+        return this.service.peerDelete(id);
+      }
+      case "engram.peer_profile_get":
+      case "remnic.peer_profile_get": {
+        const id = typeof args.id === "string" ? args.id : "";
+        if (!id) throw new Error("engram.peer_profile_get: id is required");
+        return this.service.peerProfileGet(id);
+      }
+      case "engram.peer_forget":
+      case "remnic.peer_forget": {
+        const id = typeof args.id === "string" ? args.id : "";
+        if (!id) throw new Error("engram.peer_forget: id is required");
+        const confirm = typeof args.confirm === "string" ? args.confirm : "";
+        if (confirm !== "yes") {
+          throw new Error(
+            "engram.peer_forget: confirm must be 'yes' to prevent accidental data loss"
+          );
+        }
+        return this.service.peerForget(id, { confirm: "yes" });
+      }
+      // ── Operator Console state (issue #688 PR 2/3) ──────────────────────────
+      case "engram.console_state":
+      case "remnic.console_state":
+        return this.service.consoleState(
+          typeof args.namespace === "string" ? args.namespace : void 0,
+          effectivePrincipal
+        );
+      // ── Dreams telemetry (issue #678 PR 3+4) ──────────────────────────────
+      case "engram.dreams_status":
+      case "remnic.dreams_status": {
+        const { normalizeDreamsStatusWindowHours } = await import("./dreams-ledger-LR2NBAZE.js");
+        let windowHours = 24;
+        try {
+          windowHours = normalizeDreamsStatusWindowHours(args.windowHours);
+        } catch {
+          throw new Error(
+            `engram.dreams_status: windowHours must be a positive integer (e.g. 24). Got: ${String(args.windowHours)}`
+          );
+        }
+        if ("namespace" in args && args.namespace !== void 0 && typeof args.namespace !== "string") {
+          throw new Error("engram.dreams_status: namespace must be a string when provided");
+        }
+        const namespace = typeof args.namespace === "string" ? args.namespace : void 0;
+        return this.service.dreamsStatus({
+          windowHours,
+          namespace,
+          principal: effectivePrincipal
+        });
+      }
+      case "engram.dreams_run":
+      case "remnic.dreams_run": {
+        const VALID_PHASES = ["lightSleep", "rem", "deepSleep"];
+        const phase = typeof args.phase === "string" ? args.phase : "";
+        if (!phase || !VALID_PHASES.includes(phase)) {
+          throw new Error(
+            `engram.dreams_run: phase is required and must be one of: ${VALID_PHASES.join(", ")}`
+          );
+        }
+        if ("dryRun" in args && args.dryRun !== void 0 && typeof args.dryRun !== "boolean") {
+          throw new Error("engram.dreams_run: dryRun must be a boolean when provided");
+        }
+        if ("namespace" in args && args.namespace !== void 0 && typeof args.namespace !== "string") {
+          throw new Error("engram.dreams_run: namespace must be a string when provided");
+        }
+        const namespace = typeof args.namespace === "string" ? args.namespace : void 0;
+        const dryRun = args.dryRun === true;
+        return this.service.dreamsRun({
+          phase,
+          dryRun,
+          namespace,
+          authenticatedPrincipal: effectivePrincipal
+        });
+      }
+      default:
+        throw new Error(`unknown tool: ${name}`);
+    }
+  }
+};
+
+export {
+  EngramMcpServer
+};
+//# sourceMappingURL=chunk-WZYKANL3.js.map