@remnic/core 1.1.1 → 1.1.3

package/dist/{chunk-HK3FGIEW.js → chunk-4PLGJRBV.js}

@@ -1,15 +1,21 @@
 import {
   buildCitationGuidance
 } from "./chunk-IQT3XTKW.js";
-import {
-  readEnvVar
-} from "./chunk-MARWOCVP.js";
 import {
   EngramAccessInputError
-} from "./chunk-GKFXUTJ2.js";
+} from "./chunk-DR7MCMPS.js";
+import {
+  expandTildePath
+} from "./chunk-IXEJRKCZ.js";
 import {
   validateBriefingFormat
-} from "./chunk-WVVA7F5A.js";
+} from "./chunk-SS253RXF.js";
+import {
+  readEnvVar
+} from "./chunk-MARWOCVP.js";
+import {
+  validateRequest
+} from "./chunk-RILIVK4O.js";
 
 // src/access-mcp.ts
 import { readFile } from "fs/promises";
@@ -29,6 +35,37 @@ function withToolAliases(tool) {
   if (canonicalName === tool.name) return [canonicalTool];
   return [canonicalTool, tool];
 }
+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;
@@ -59,7 +96,28 @@ var EngramMcpServer = class {
             namespace: { type: "string" },
             topK: { type: "number" },
             mode: { type: "string", enum: ["auto", "no_recall", "minimal", "full", "graph_mode"] },
-            includeDebug: { type: "boolean" }
+            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
@@ -79,7 +137,7 @@ var EngramMcpServer = class {
       },
       {
         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.",
+        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: {
@@ -102,10 +160,14 @@ var EngramMcpServer = class {
                   additionalProperties: false
                 }
               ],
-              description: "The context to attach, or null to clear."
+              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", "codingContext"],
+          required: ["sessionKey"],
           additionalProperties: false
         }
       },
@@ -152,6 +214,11 @@ var EngramMcpServer = class {
               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"],
@@ -172,6 +239,70 @@ var EngramMcpServer = class {
           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.",
@@ -198,6 +329,18 @@ var EngramMcpServer = class {
           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
@@ -330,7 +473,9 @@ var EngramMcpServer = class {
               description: "Conversation messages to observe"
             },
             namespace: { type: "string" },
-            skipExtraction: { type: "boolean" }
+            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
@@ -741,6 +886,30 @@ var EngramMcpServer = class {
           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.",
@@ -859,6 +1028,171 @@ var EngramMcpServer = class {
           },
           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));
   }
@@ -947,8 +1281,14 @@ var EngramMcpServer = class {
     if (method === "tools/call") {
       const params = request.params ?? {};
       const name = typeof params.name === "string" ? params.name : "";
-      const argumentsObject = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {};
       try {
+        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 {
@@ -1108,13 +1448,53 @@ ${body}`;
   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,
           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
+          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);
@@ -1136,6 +1516,26 @@ ${body}`;
         });
       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) {
@@ -1183,12 +1583,22 @@ ${body}`;
           }
           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
+          authenticatedPrincipal: effectivePrincipal,
+          ...disclosure !== void 0 ? { disclosure } : {}
         });
       }
       case "engram.day_summary":
@@ -1197,6 +1607,35 @@ ${body}`;
           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,
@@ -1214,6 +1653,15 @@ ${body}`;
           },
           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(
@@ -1280,14 +1728,23 @@ ${body}`;
           typeof args.namespace === "string" ? args.namespace : void 0,
           effectivePrincipal
         );
-      case "engram.observe":
+      case "engram.observe": {
+        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");
+        }
         return this.service.observe({
           sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : "",
           messages: Array.isArray(args.messages) ? args.messages : [],
           namespace: typeof args.namespace === "string" ? args.namespace : void 0,
           authenticatedPrincipal: effectivePrincipal,
-          skipExtraction: args.skipExtraction === true
+          skipExtraction: args.skipExtraction === true,
+          cwd: typeof args.cwd === "string" ? args.cwd : void 0,
+          projectTag: typeof args.projectTag === "string" ? args.projectTag : void 0
         });
+      }
       case "engram.lcm_search":
         return this.service.lcmSearch({
           query: typeof args.query === "string" ? args.query : "",
@@ -1497,6 +1954,43 @@ ${body}`;
         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 : "",
@@ -1550,7 +2044,7 @@ ${body}`;
       // ── Contradiction Review (issue #520) ──────────────────────────────────
       case "engram.review_list":
       case "remnic.review_list": {
-        const { listPairs } = await import("./contradiction-review-WIUBAR52.js");
+        const { listPairs } = await import("./contradiction-review-5LTTVDQV.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)) {
@@ -1567,14 +2061,14 @@ ${body}`;
         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-QBTDHTG7.js");
+        const { isValidResolutionVerb } = await import("./resolution-YGIBORXI.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-QBTDHTG7.js");
+        const { executeResolution } = await import("./resolution-YGIBORXI.js");
         return executeResolution(this.service.memoryDir, this.service.storageRef, pairId, verb);
       }
       case "engram.contradiction_scan_run":
       case "remnic.contradiction_scan_run": {
-        const { runContradictionScan } = await import("./contradiction-scan-E3GJTI4F.js");
+        const { runContradictionScan } = await import("./contradiction-scan-3Z6YW7YA.js");
         return runContradictionScan({
           storage: this.service.storageRef,
           config: this.service.configRef,
@@ -1585,6 +2079,148 @@ ${body}`;
           namespace: typeof args.namespace === "string" ? args.namespace : 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-PWB63GRE.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}`);
     }
@@ -1594,4 +2230,4 @@ ${body}`;
 export {
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-HK3FGIEW.js.map
+//# sourceMappingURL=chunk-4PLGJRBV.js.map