@remnic/core 1.1.10 → 1.1.12

package/dist/{chunk-Y5KDIOKF.js → chunk-XAMBKFQS.js}

@@ -1,21 +1,29 @@
+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-WGK4VHGP.js";
+} from "./chunk-MNU6ZBWT.js";
+import {
+  validateBriefingFormat
+} from "./chunk-ZVTKDVVM.js";
 import {
   expandTildePath
 } from "./chunk-IXEJRKCZ.js";
-import {
-  validateBriefingFormat
-} from "./chunk-WTFWLUSX.js";
 import {
   readEnvVar
 } from "./chunk-MARWOCVP.js";
 import {
   validateRequest
-} from "./chunk-A4ACKWIW.js";
+} from "./chunk-U5JMRGKX.js";
 
 // src/access-mcp.ts
 import { readFile } from "fs/promises";
@@ -35,6 +43,11 @@ function withToolAliases(tool) {
   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",
@@ -84,6 +97,31 @@ var EngramMcpServer = class {
     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",
@@ -225,6 +263,158 @@ var EngramMcpServer = class {
           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.",
@@ -469,7 +659,7 @@ var EngramMcpServer = class {
                   content: { type: "string" },
                   sourceFormat: {
                     type: "string",
-                    enum: ["openai", "anthropic", "openclaw", "lossless-claw", "remnic"]
+                    enum: ["openai", "anthropic", "openclaw", "pi", "lossless-claw", "remnic"]
                   },
                   rawContent: {
                     description: "Optional native provider content blocks for structured message-part capture."
@@ -538,6 +728,34 @@ var EngramMcpServer = class {
           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",
@@ -1322,6 +1540,8 @@ var EngramMcpServer = class {
   buffer = Buffer.alloc(0);
   flushTask = null;
   tools;
+  resources;
+  resourceTextByUri;
   authenticatedPrincipal;
   /**
    * MCP client info keyed by server-assigned session ID. On each `initialize`
@@ -1382,7 +1602,8 @@ var EngramMcpServer = class {
         result: {
           protocolVersion: MCP_PROTOCOL_VERSION,
           capabilities: {
-            tools: {}
+            tools: {},
+            resources: {}
           },
           serverInfo: {
             name: "remnic",
@@ -1400,6 +1621,64 @@ var EngramMcpServer = class {
         }
       };
     }
+    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 : "";
@@ -1607,6 +1886,7 @@ ${body}`;
         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,
@@ -1723,6 +2003,82 @@ ${body}`;
           ...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 : "",
@@ -1876,6 +2232,24 @@ ${body}`;
           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({
@@ -2210,7 +2584,7 @@ ${body}`;
       }
       case "engram.contradiction_scan_run":
       case "remnic.contradiction_scan_run": {
-        const { runContradictionScan } = await import("./contradiction-scan-3Z6YW7YA.js");
+        const { runContradictionScan } = await import("./contradiction-scan-QTXAMBUA.js");
         return runContradictionScan({
           storage: this.service.storageRef,
           config: this.service.configRef,
@@ -2400,4 +2774,4 @@ ${body}`;
 export {
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-Y5KDIOKF.js.map
+//# sourceMappingURL=chunk-XAMBKFQS.js.map