@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-FROKVQQY.js

@@ -1,3997 +0,0 @@
-import {
-  RECALL_NAVIGATION_MCP_TOOLS
-} from "./chunk-TE6S7KDF.js";
-import {
-  MEMORY_BROWSE_MCP_TOOLS
-} from "./chunk-EIB4FJVR.js";
-import {
-  MCP_READ_ONLY_TOOL_SUFFIXES
-} from "./chunk-FPB5LQWW.js";
-import {
-  EXTERNAL_WIKI_MCP_TOOLS
-} from "./chunk-A5KNZSNA.js";
-import {
-  DEEP_RECALL_MCP_TOOLS
-} from "./chunk-HUSTM6PU.js";
-import {
-  buildCitationGuidance
-} from "./chunk-D24OXEPB.js";
-import {
-  REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
-  REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL,
-  REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_HTML,
-  REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI
-} from "./chunk-E4RMZGRS.js";
-import {
-  sharedContextMcpTools
-} from "./chunk-JATHBCAV.js";
-import {
-  CANONICAL_MCP_PREFIX,
-  LEGACY_MCP_PREFIX,
-  toCanonicalToolName,
-  toLegacyToolName,
-  toolNameSuffix,
-  withToolAliases
-} from "./chunk-ZQUVBZI4.js";
-import {
-  MCP_ADMIN_OPS_MIGRATED_OPERATIONS,
-  MCP_ADMIN_OPS_TOOLS,
-  MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED
-} from "./chunk-AB3A7EFH.js";
-import {
-  applyToolOutputSchemas
-} from "./chunk-YEIKOBOW.js";
-import {
-  getOperation
-} from "./chunk-ZBYVR5W4.js";
-import {
-  WHO_KNOWS_MCP_TOOLS
-} from "./chunk-43IQRLEF.js";
-import {
-  PROMOTION_CANDIDATES_MCP_TOOLS
-} from "./chunk-VYCOJKSX.js";
-import {
-  validateRequest
-} from "./chunk-YIIW2OH2.js";
-import {
-  SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
-} from "./chunk-PWPIERBM.js";
-import {
-  assertOperationAllowed,
-  capabilityAllowsOp,
-  enforceNamespaceAllowList,
-  tokenCapabilityStore
-} from "./chunk-MZWSOLMT.js";
-import {
-  readEnvVar
-} from "./chunk-P2QRMMVQ.js";
-import {
-  EngramAccessInputError
-} from "./chunk-2Z24E5W2.js";
-import {
-  abortError,
-  isAbortError
-} from "./chunk-BTTPKDIL.js";
-
-// src/access-mcp.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-
-// src/chat/chat-system-prompt.ts
-function buildChatSystemPrompt(opts) {
-  const lines = [
-    "You are Remnic Chat \u2014 a conversational memory inspector and corrector.",
-    "You help the user understand, explore, and fix what Remnic remembers.",
-    "",
-    "## Core rules",
-    "",
-    "1. GROUND EVERY ASSERTION. When you state what Remnic remembers, you MUST",
-    "   cite the memory id or handle, include the source quote, and the date.",
-    "   If no tool result in this turn supports the claim, say",
-    '   "I found nothing" instead of guessing.',
-    "",
-    "2. NO MUTATION WITHOUT CONFIRMATION. You may propose a correction plan",
-    "   (correction_plan), but you must NEVER apply it (correction_apply) until",
-    "   the user explicitly confirms in the conversation.",
-    "",
-    "3. RENDER PLANS AS DIFFS. When you surface a correction plan, render it",
-    "   as the diff preview the plan returns \u2014 before/after, affected memory",
-    "   ids, and the supersession reason.",
-    "",
-    "4. BE HONEST ABOUT LIMITS. If a tool returns no results, say so. If you",
-    "   are unsure, say so. Never fabricate memory content.",
-    "",
-    "5. RESPECT SCOPE. You operate within the caller's namespace and principal.",
-    "   Do not attempt to access memories outside the caller's scope."
-  ];
-  if (opts.correctionAvailable) {
-    lines.push(
-      "",
-      "## Mutation protocol",
-      "",
-      "When the user asks to change or forget memories:",
-      "1. Call correction_plan to generate a diff preview.",
-      "2. Present the diff to the user and ask them to reply 'apply' to confirm.",
-      "3. Only after explicit confirmation, call correction_apply.",
-      "",
-      "For bulk/destructive requests ('forget everything about X'), always go",
-      "through correction_plan first \u2014 there is no direct-delete tool."
-    );
-  } else {
-    lines.push(
-      "",
-      "## Mutation status",
-      "",
-      "Correction (mutation) tools are not yet available in this build.",
-      "You can inspect and search memories but cannot apply corrections.",
-      "When the user asks to change memories, explain that correction tools",
-      "require the Correction Contract (#1580) which is pending."
-    );
-  }
-  return lines.join("\n");
-}
-
-// src/chat/chat-tools.ts
-var MUTATING_TOOLS = /* @__PURE__ */ new Set([
-  "correction_apply",
-  "memory_promote"
-]);
-var MEMORY_SEARCH_SCHEMA = {
-  type: "function",
-  function: {
-    name: "memory_search",
-    description: "Semantic search across stored memories. Returns matching memory paths, scores, and snippets. Use this to find what Remnic remembers about a topic.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "The search query." },
-        maxResults: { type: "number", description: "Maximum results (default 8)." }
-      },
-      required: ["query"],
-      additionalProperties: false
-    }
-  }
-};
-var MEMORY_GET_SCHEMA = {
-  type: "function",
-  function: {
-    name: "memory_get",
-    description: "Fetch a single memory by its id. Returns the full memory content, category, tags, and source attribution.",
-    parameters: {
-      type: "object",
-      properties: {
-        memoryId: { type: "string", description: "The memory id to fetch." }
-      },
-      required: ["memoryId"],
-      additionalProperties: false
-    }
-  }
-};
-var MEMORY_TIMELINE_SCHEMA = {
-  type: "function",
-  function: {
-    name: "memory_timeline",
-    description: "Read the lifecycle timeline of a single memory \u2014 creation, updates, consolidations, and tier transitions.",
-    parameters: {
-      type: "object",
-      properties: {
-        memoryId: { type: "string", description: "The memory id." },
-        limit: { type: "number", description: "Maximum rows (default 200)." }
-      },
-      required: ["memoryId"],
-      additionalProperties: false
-    }
-  }
-};
-var RECALL_EXPLAIN_SCHEMA = {
-  type: "function",
-  function: {
-    name: "recall_explain",
-    description: "Explain why Remnic would recall certain memories for a given query. Returns tier scoring and matching details. Use this to answer 'why did you remember this?'",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Optional query to explain recall for. When omitted, explains the most recent recall." }
-      },
-      required: [],
-      additionalProperties: false
-    }
-  }
-};
-var ENTITY_GET_SCHEMA = {
-  type: "function",
-  function: {
-    name: "entity_get",
-    description: "Fetch the compiled entity record for a named entity (person, project, tool, etc.). Returns traits, timeline, and associated memories.",
-    parameters: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Entity name." }
-      },
-      required: ["name"],
-      additionalProperties: false
-    }
-  }
-};
-var STATS_SCHEMA = {
-  type: "function",
-  function: {
-    name: "stats",
-    description: "Return aggregate memory statistics \u2014 memory count, entity count, profile summary, and open questions. Use this for high-level 'what do you know?' questions.",
-    parameters: {
-      type: "object",
-      properties: {},
-      additionalProperties: false
-    }
-  }
-};
-var CORRECTION_PLAN_SCHEMA = {
-  type: "function",
-  function: {
-    name: "correction_plan",
-    description: "Generate a correction plan (diff preview) for a requested memory change. This does NOT apply the change \u2014 it previews what would happen. The user must confirm before correction_apply runs.",
-    parameters: {
-      type: "object",
-      properties: {
-        request: {
-          type: "string",
-          description: "Natural-language description of the correction, e.g. 'we finished the MySQL migration in March' or 'forget the outdated database credentials'."
-        }
-      },
-      required: ["request"],
-      additionalProperties: false
-    }
-  }
-};
-var CORRECTION_APPLY_SCHEMA = {
-  type: "function",
-  function: {
-    name: "correction_apply",
-    description: "Apply a previously generated correction plan. The engine intercepts this call and requires explicit user confirmation before it executes.",
-    parameters: {
-      type: "object",
-      properties: {
-        planId: { type: "string", description: "The plan id from correction_plan." }
-      },
-      required: ["planId"],
-      additionalProperties: false
-    }
-  }
-};
-var MEMORY_PROMOTE_SCHEMA = {
-  type: "function",
-  function: {
-    name: "memory_promote",
-    description: "Promote a memory's tier (e.g. from cold to hot). The engine requires user confirmation before executing.",
-    parameters: {
-      type: "object",
-      properties: {
-        memoryId: { type: "string", description: "The memory id to promote." }
-      },
-      required: ["memoryId"],
-      additionalProperties: false
-    }
-  }
-};
-var REVIEW_LIST_SCHEMA = {
-  type: "function",
-  function: {
-    name: "review_list",
-    description: "List items in the contradiction/quality review queue. Returns pairs of potentially conflicting memories awaiting resolution.",
-    parameters: {
-      type: "object",
-      properties: {
-        runId: { type: "string", description: "Optional governance run id." }
-      },
-      additionalProperties: false
-    }
-  }
-};
-var SCOPE_INSPECT_SCHEMA = {
-  type: "function",
-  function: {
-    name: "scope_inspect",
-    description: "Inspect the current scope/namespace resolution \u2014 which namespace the chat session operates in and how it was resolved.",
-    parameters: {
-      type: "object",
-      properties: {},
-      additionalProperties: false
-    }
-  }
-};
-var READONLY_SCHEMAS = [
-  MEMORY_SEARCH_SCHEMA,
-  MEMORY_GET_SCHEMA,
-  MEMORY_TIMELINE_SCHEMA,
-  RECALL_EXPLAIN_SCHEMA,
-  ENTITY_GET_SCHEMA,
-  STATS_SCHEMA,
-  REVIEW_LIST_SCHEMA
-];
-function buildChatToolSchemas(opts) {
-  const tools = [...READONLY_SCHEMAS];
-  if (opts.correctionAvailable) {
-    tools.push(CORRECTION_PLAN_SCHEMA, CORRECTION_APPLY_SCHEMA, MEMORY_PROMOTE_SCHEMA);
-  }
-  if (opts.scopeInspectAvailable) {
-    tools.push(SCOPE_INSPECT_SCHEMA);
-  }
-  return tools;
-}
-
-// src/chat/chat-engine.ts
-var CONFIRMATION_KEYWORDS = {
-  yes: true,
-  y: true,
-  apply: true,
-  confirm: true,
-  "\u306F\u3044": true,
-  // Japanese
-  "s\xED": true,
-  // Spanish
-  ja: true,
-  // German/Dutch
-  "\u0646\u0639\u0645": true
-  // Arabic
-};
-function isConfirmationMessage(text) {
-  return CONFIRMATION_KEYWORDS[text.trim().toLowerCase()] === true;
-}
-var ChatEngine = class {
-  llm;
-  executor;
-  maxToolCallsPerTurn;
-  model;
-  correctionAvailable;
-  scopeInspectAvailable;
-  systemPrompt;
-  toolSchemas;
-  allowedToolNames;
-  constructor(opts) {
-    this.llm = opts.llm;
-    this.executor = opts.executor;
-    this.maxToolCallsPerTurn = opts.maxToolCallsPerTurn;
-    this.model = opts.model;
-    this.correctionAvailable = opts.correctionAvailable;
-    this.scopeInspectAvailable = opts.scopeInspectAvailable;
-    this.systemPrompt = buildChatSystemPrompt({
-      correctionAvailable: opts.correctionAvailable
-    });
-    this.toolSchemas = buildChatToolSchemas({
-      correctionAvailable: opts.correctionAvailable,
-      scopeInspectAvailable: opts.scopeInspectAvailable
-    });
-    this.allowedToolNames = new Set(this.toolSchemas.map((t) => t.function.name));
-  }
-  /**
-   * Process a single user message.  The session state is mutated in place
-   * (confirmedPlanIds, pendingPlanId) — the caller persists the transcript.
-   */
-  async processMessage(userMessage, session) {
-    if (isConfirmationMessage(userMessage) && this.correctionAvailable) {
-      if (session.pendingPlanId) {
-        const planId = session.pendingPlanId;
-        session.confirmedPlanIds.add(planId);
-        session.pendingPlanId = void 0;
-        try {
-          const applyResult = await this.executor.correctionApply(planId);
-          session.confirmedPlanIds.delete(planId);
-          return {
-            reply: `Correction applied.
-
-${applyResult}`,
-            chatSessionId: session.id,
-            ...session.pendingPromotionId ? {} : {}
-          };
-        } catch (err) {
-          session.confirmedPlanIds.delete(planId);
-          session.pendingPlanId = planId;
-          const msg = err instanceof Error ? err.message : String(err);
-          return {
-            reply: "[error] Failed to apply the correction. Please try again or re-request the plan.",
-            chatSessionId: session.id,
-            error: msg
-          };
-        }
-      }
-      if (session.pendingPromotionId) {
-        const memoryId = session.pendingPromotionId;
-        session.pendingPromotionId = void 0;
-        try {
-          const promoteResult = await this.executor.memoryPromote(memoryId);
-          return {
-            reply: `Memory promoted.
-
-${promoteResult}`,
-            chatSessionId: session.id
-          };
-        } catch (err) {
-          session.pendingPromotionId = memoryId;
-          const msg = err instanceof Error ? err.message : String(err);
-          return {
-            reply: "[error] Failed to promote the memory. Please try again.",
-            chatSessionId: session.id,
-            error: msg
-          };
-        }
-      }
-    }
-    const recentEntries = session.transcript.slice(-21).filter((e) => e.role !== "system" || e.seq !== 0).filter((e) => !(e.role === "system" && /^[a-z_]+:/.test(e.content))).filter((e, _i, arr) => {
-      if (e.role === "user" && e.content === userMessage) {
-        const lastUser = [...arr].reverse().find((x) => x.role === "user");
-        return e !== lastUser;
-      }
-      return true;
-    });
-    const conversation = [
-      { role: "system", content: this.systemPrompt },
-      ...recentEntries.map((e) => ({
-        role: e.role,
-        content: e.content,
-        ...e.toolCallId ? { toolCallId: e.toolCallId } : {}
-      })),
-      { role: "user", content: userMessage }
-    ];
-    let toolCallCount = 0;
-    const skippedTools = [];
-    let pendingPlan;
-    for (; ; ) {
-      let response;
-      try {
-        response = await this.llm.complete(conversation, {
-          tools: this.toolSchemas,
-          ...this.model ? { model: this.model } : {}
-        });
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          reply: "[error] The model request failed. Check your model configuration and retry.",
-          chatSessionId: session.id,
-          error: msg
-        };
-      }
-      if (!response) {
-        return {
-          reply: "[error] No LLM model is available. Configure a local or cloud model to use Remnic Chat.",
-          chatSessionId: session.id,
-          error: "no_llm_available"
-        };
-      }
-      if (response.toolCalls.length === 0) {
-        let reply = response.content;
-        if (toolCallCount === 0 && looksLikeMemoryAssertion(reply)) {
-          reply += "\n\n\u26A0\uFE0F The above assertion was not grounded in a tool result this turn. Please verify with memory_search or memory_get.";
-        }
-        return {
-          reply,
-          chatSessionId: session.id,
-          ...pendingPlan ? { pendingPlan } : {},
-          ...skippedTools.length > 0 ? { skippedTools } : {}
-        };
-      }
-      conversation.push({ role: "assistant", content: response.content });
-      for (const tc of response.toolCalls) {
-        if (toolCallCount >= this.maxToolCallsPerTurn) {
-          skippedTools.push(tc.name);
-          continue;
-        }
-        toolCallCount++;
-        if (!this.allowedToolNames.has(tc.name)) {
-          conversation.push({
-            role: "tool",
-            content: JSON.stringify({ error: `Tool '${tc.name}' is not available in this configuration.` }),
-            toolCallId: tc.id
-          });
-          continue;
-        }
-        if (MUTATING_TOOLS.has(tc.name)) {
-          if (tc.name === "correction_apply") {
-            const planId = typeof tc.arguments.planId === "string" ? tc.arguments.planId : "";
-            if (!session.confirmedPlanIds.has(planId)) {
-              try {
-                const plan = await this.executor.correctionPlan(
-                  `retrieve plan ${planId}`
-                );
-                pendingPlan = { planId, preview: plan.preview };
-                session.pendingPlanId = planId;
-                conversation.push({
-                  role: "tool",
-                  content: JSON.stringify({
-                    intercepted: true,
-                    message: "This mutation requires confirmation. The plan preview has been shown to the user."
-                  }),
-                  toolCallId: tc.id
-                });
-                return {
-                  reply: formatPlanPreview(plan.preview),
-                  chatSessionId: session.id,
-                  pendingPlan
-                };
-              } catch {
-                conversation.push({
-                  role: "tool",
-                  content: JSON.stringify({ error: "Plan not found or expired." }),
-                  toolCallId: tc.id
-                });
-                continue;
-              }
-            }
-            session.confirmedPlanIds.delete(planId);
-          }
-        }
-        if (tc.name === "memory_promote" && this.correctionAvailable) {
-          const memoryId = typeof tc.arguments.memoryId === "string" ? tc.arguments.memoryId : "";
-          session.pendingPromotionId = memoryId;
-          conversation.push({
-            role: "tool",
-            content: JSON.stringify({
-              intercepted: true,
-              message: `Memory promotion requires confirmation. Reply 'apply' to promote memory '${memoryId}'.`
-            }),
-            toolCallId: tc.id
-          });
-          return {
-            reply: `I want to promote memory \`${memoryId}\`. Reply **apply** to confirm this promotion, or **cancel** to discard it.`,
-            chatSessionId: session.id
-          };
-        }
-        let result;
-        try {
-          result = await this.executeTool(tc.name, tc.arguments, session);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          result = { content: JSON.stringify({ error: msg }) };
-        }
-        conversation.push({
-          role: "tool",
-          content: result.content,
-          toolCallId: tc.id
-        });
-        if (tc.name === "correction_plan" && this.correctionAvailable) {
-          try {
-            const parsed = JSON.parse(result.content);
-            if (parsed.planId && parsed.preview) {
-              pendingPlan = { planId: parsed.planId, preview: parsed.preview };
-              session.pendingPlanId = parsed.planId;
-            }
-          } catch {
-          }
-        }
-      }
-      if (skippedTools.length > 0) {
-        conversation.push({
-          role: "user",
-          content: `[system] Tool budget exhausted (${this.maxToolCallsPerTurn} calls). ${skippedTools.length} tool(s) were skipped: ${skippedTools.join(", ")}. Please summarize what you found.`
-        });
-        let summaryResponse;
-        try {
-          summaryResponse = await this.llm.complete(conversation, {
-            tools: [],
-            // No more tools — force a text reply.
-            ...this.model ? { model: this.model } : {}
-          });
-        } catch {
-          summaryResponse = null;
-        }
-        const summaryText = summaryResponse?.content ?? "I reached my tool-call budget. Here is what I found so far, but some queries were skipped.";
-        return {
-          reply: summaryText,
-          chatSessionId: session.id,
-          ...pendingPlan ? { pendingPlan } : {},
-          skippedTools
-        };
-      }
-    }
-  }
-  /**
-   * Execute a single tool by name, delegating to the executor.
-   */
-  async executeTool(name, args, _session) {
-    switch (name) {
-      case "memory_search": {
-        const query = typeof args.query === "string" ? args.query : "";
-        const maxResults = typeof args.maxResults === "number" ? args.maxResults : void 0;
-        return { content: await this.executor.memorySearch(query, maxResults) };
-      }
-      case "memory_get": {
-        const memoryId = typeof args.memoryId === "string" ? args.memoryId : "";
-        return { content: await this.executor.memoryGet(memoryId) };
-      }
-      case "memory_timeline": {
-        const memoryId = typeof args.memoryId === "string" ? args.memoryId : "";
-        const limit = typeof args.limit === "number" ? args.limit : void 0;
-        return { content: await this.executor.memoryTimeline(memoryId, limit) };
-      }
-      case "recall_explain": {
-        const query = typeof args.query === "string" ? args.query : "";
-        return { content: await this.executor.recallExplain(query) };
-      }
-      case "entity_get": {
-        const entityName = typeof args.name === "string" ? args.name : "";
-        return { content: await this.executor.entityGet(entityName) };
-      }
-      case "stats": {
-        return { content: await this.executor.stats() };
-      }
-      case "correction_plan": {
-        const request = typeof args.request === "string" ? args.request : "";
-        const plan = await this.executor.correctionPlan(request);
-        return { content: JSON.stringify(plan) };
-      }
-      case "correction_apply": {
-        const planId = typeof args.planId === "string" ? args.planId : "";
-        return { content: await this.executor.correctionApply(planId) };
-      }
-      case "memory_promote": {
-        const memoryId = typeof args.memoryId === "string" ? args.memoryId : "";
-        return { content: await this.executor.memoryPromote(memoryId) };
-      }
-      case "review_list": {
-        const runId = typeof args.runId === "string" ? args.runId : void 0;
-        return { content: await this.executor.reviewList(runId) };
-      }
-      case "scope_inspect": {
-        return { content: await this.executor.scopeInspect() };
-      }
-      default:
-        return { content: JSON.stringify({ error: `Unknown tool: ${name}` }) };
-    }
-  }
-};
-function looksLikeMemoryAssertion(text) {
-  const lower = text.toLowerCase();
-  const assertionPhrases = [
-    "you remember",
-    "i remember",
-    "according to my memory",
-    "your memory",
-    "stored memory",
-    "remnic remembers",
-    "remnic knows"
-  ];
-  const hasAssertion = assertionPhrases.some((p) => lower.includes(p));
-  const hasCitation = lower.includes("[id:") || lower.includes("memory id") || lower.includes("source:");
-  return hasAssertion && !hasCitation;
-}
-function formatPlanPreview(preview) {
-  return [
-    "Here is the correction plan I generated:",
-    "",
-    "```diff",
-    preview,
-    "```",
-    "",
-    "Reply **apply** to confirm and apply this correction.",
-    "Reply **cancel** to discard it."
-  ].join("\n");
-}
-
-// src/chat/chat-llm.ts
-function createProductionChatLlmAdapter(client) {
-  return {
-    async complete(messages, options) {
-      const toolInstruction = formatToolInstruction(options.tools);
-      const mapped = messages.map((m) => {
-        if (m.role === "system") {
-          return { role: m.role, content: m.content + "\n\n" + toolInstruction };
-        }
-        if (m.role === "tool") {
-          const tag = m.toolCallId ? `[tool:${m.toolCallId}]` : "[tool]";
-          return { role: "user", content: `${tag} ${m.content}` };
-        }
-        return { role: m.role, content: m.content };
-      });
-      const result = await client.chatCompletion(mapped, {
-        ...options.model ? { model: options.model } : {},
-        ...options.signal ? { signal: options.signal } : {}
-      });
-      if (!result) return null;
-      const toolCalls = parseToolCalls(result.content);
-      return {
-        content: stripToolCallJson(result.content, toolCalls),
-        toolCalls
-      };
-    }
-  };
-}
-function formatToolInstruction(tools) {
-  if (tools.length === 0) return "";
-  const lines = [
-    "## Available tools",
-    "",
-    "You may call the following tools by emitting a JSON block on its own line:",
-    "```json",
-    '{"tool": "<name>", "arguments": { ... }}',
-    "```",
-    "",
-    "Call one tool at a time. After receiving the tool result, continue your",
-    "reasoning or emit another tool call. When you have a final answer, reply",
-    "with text only (no tool-call JSON).",
-    "",
-    "Tools:"
-  ];
-  for (const t of tools) {
-    const params = JSON.stringify(t.function.parameters);
-    lines.push(`- ${t.function.name}: ${t.function.description}`);
-    lines.push(`  Parameters: ${params}`);
-  }
-  return lines.join("\n");
-}
-function parseToolCalls(content) {
-  const calls = [];
-  const patterns = [
-    /```json\s*\n([\s\S]*?)\n```/g,
-    /```\s*\n([\s\S]*?)\n```/g
-  ];
-  const candidates = [];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      candidates.push(match[1]);
-    }
-  }
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("{") && trimmed.includes('"tool"')) {
-      candidates.push(trimmed);
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    try {
-      const parsed = JSON.parse(candidate);
-      if (typeof parsed.tool === "string" && parsed.tool.length > 0) {
-        const args = parsed.arguments ?? {};
-        const key = parsed.tool + ":" + JSON.stringify(args);
-        if (seen.has(key)) continue;
-        seen.add(key);
-        calls.push({
-          id: `call_${calls.length + 1}`,
-          name: parsed.tool,
-          arguments: args
-        });
-      }
-    } catch {
-    }
-  }
-  return calls;
-}
-function stripToolCallJson(content, toolCalls) {
-  if (toolCalls.length === 0) return content;
-  let result = content;
-  result = result.replace(/```json\s*\n[\s\S]*?\n```/g, "");
-  result = result.replace(/```\s*\n[\s\S]*?\n```/g, "");
-  result = result.split("\n").filter((line) => {
-    const trimmed = line.trim();
-    return !(trimmed.startsWith("{") && trimmed.includes('"tool"'));
-  }).join("\n");
-  return result.trim();
-}
-
-// src/chat/chat-executor.ts
-function createChatExecutor(bindings) {
-  const { service, principal, namespace, sessionKey } = bindings;
-  return {
-    async memorySearch(query, maxResults) {
-      const result = await service.memorySearch({
-        query,
-        ...namespace ? { namespace } : {},
-        ...maxResults !== void 0 ? { maxResults } : {},
-        ...principal ? { principal } : {}
-      });
-      return JSON.stringify(result);
-    },
-    async memoryGet(memoryId) {
-      const result = await service.memoryGet(memoryId, namespace, principal, sessionKey);
-      return JSON.stringify(result);
-    },
-    async memoryTimeline(memoryId, limit) {
-      const result = await service.memoryTimeline(memoryId, namespace, limit ?? 200, principal);
-      return JSON.stringify(result);
-    },
-    async recallExplain(query) {
-      const result = await service.recallExplain({
-        ...sessionKey ? { sessionKey } : {},
-        ...namespace ? { namespace } : {},
-        ...principal ? { authenticatedPrincipal: principal } : {},
-        ...query ? { query } : {}
-      });
-      return JSON.stringify(result);
-    },
-    async entityGet(name) {
-      const result = await service.entityGet(name, namespace);
-      return JSON.stringify(result);
-    },
-    async stats() {
-      const [profile, entities, questions] = await Promise.all([
-        service.memoryProfile(namespace, principal),
-        service.memoryEntitiesList(namespace, principal),
-        service.memoryQuestions(namespace, principal)
-      ]);
-      return JSON.stringify({ profile, entities, questions });
-    },
-    async reviewList(runId) {
-      const result = await service.reviewQueue(runId, namespace, principal);
-      return JSON.stringify(result);
-    },
-    async scopeInspect() {
-      return JSON.stringify({
-        namespace: namespace ?? "default",
-        principal: principal ?? "default",
-        sessionKey: sessionKey ?? void 0
-      });
-    },
-    // ── Correction tools — stubbed until #1580 merges ──────────────────
-    // When the Correction Contract lands, replace these stubs with calls to
-    // the correction module's plan/apply interface.  The engine, CLI, and
-    // MCP tool all consume this interface, so the stub-to-real swap is a
-    // single-file change here.
-    async correctionPlan(request) {
-      return {
-        planId: `stub-${Date.now()}`,
-        preview: `[Correction Contract (#1580) not yet available]
-
-Requested correction: "${request}"
-
-The plan/apply pipeline is pending. Inspection tools are fully functional.`
-      };
-    },
-    async correctionApply(planId) {
-      return JSON.stringify({
-        applied: false,
-        planId,
-        reason: "Correction Contract (#1580) not yet available. No mutation was applied."
-      });
-    },
-    async memoryPromote(memoryId) {
-      try {
-        const serviceWithPromote = service;
-        if (typeof serviceWithPromote.memoryPromote === "function") {
-          const result = await serviceWithPromote.memoryPromote(memoryId, namespace, principal);
-          return JSON.stringify(result);
-        }
-      } catch {
-      }
-      return JSON.stringify({
-        promoted: false,
-        memoryId,
-        reason: "Memory promotion is not available in this build."
-      });
-    }
-  };
-}
-
-// src/chat/chat-session.ts
-import { mkdir, readFile, appendFile, readdir, stat, unlink, open } from "fs/promises";
-import { constants as fsConstants } from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-var CHAT_DIR_NAME = "state/chat";
-function chatSessionDir(memoryDir) {
-  return join(memoryDir, CHAT_DIR_NAME);
-}
-function isSafeChatSessionId(chatSessionId) {
-  return /^[A-Za-z0-9]{8,128}$/.test(chatSessionId.replace(/-/g, ""));
-}
-function chatSessionFile(memoryDir, chatSessionId) {
-  if (!isSafeChatSessionId(chatSessionId)) {
-    throw new Error("Invalid chat session id");
-  }
-  return join(chatSessionDir(memoryDir), `${chatSessionId}.jsonl`);
-}
-var lastTranscriptSeq = 0;
-function nextTranscriptSeq() {
-  const now = Date.now();
-  lastTranscriptSeq = now > lastTranscriptSeq ? now : lastTranscriptSeq + 1;
-  return lastTranscriptSeq;
-}
-async function createChatSession(memoryDir, opts) {
-  const id = randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const state = {
-    id,
-    principal: opts.principal,
-    sessionKey: opts.sessionKey,
-    namespace: opts.namespace,
-    transcript: [],
-    confirmedPlanIds: /* @__PURE__ */ new Set(),
-    createdAt: now
-  };
-  await mkdir(chatSessionDir(memoryDir), { recursive: true });
-  await appendFile(
-    chatSessionFile(memoryDir, id),
-    JSON.stringify({
-      seq: 0,
-      ts: now,
-      role: "system",
-      content: `Chat session created. Principal: ${opts.principal ?? "default"}. Namespace: ${opts.namespace ?? "default"}. work_task: Excluded from memory extraction`,
-      // Structured binding fields so loadChatSession doesn't need to regex-parse
-      // prose (robust against dotted principals like alice@example.com).
-      ...opts.principal ? { principal: opts.principal } : {},
-      ...opts.namespace ? { namespace: opts.namespace } : {},
-      ...opts.sessionKey ? { sessionKey: opts.sessionKey } : {}
-    }) + "\n",
-    "utf8"
-  );
-  return state;
-}
-async function loadChatSession(memoryDir, chatSessionId) {
-  let raw;
-  try {
-    raw = await readFile(chatSessionFile(memoryDir, chatSessionId), "utf8");
-  } catch {
-    return null;
-  }
-  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-  const transcript = [];
-  let principal;
-  let sessionKey;
-  let namespace;
-  let createdAt = "";
-  let pendingPlanId;
-  let pendingPromotionId;
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-      transcript.push(entry);
-      if (entry.role === "system" && entry.seq === 0) {
-        const metaPrincipal = typeof entry.principal === "string" ? entry.principal : void 0;
-        const metaNamespace = typeof entry.namespace === "string" ? entry.namespace : void 0;
-        const metaSessionKey = typeof entry.sessionKey === "string" ? entry.sessionKey : void 0;
-        if (metaPrincipal) principal = metaPrincipal;
-        else {
-          const pMatch = entry.content.match(/Principal: (.+?)\.\s/);
-          if (pMatch) principal = pMatch[1]?.trim() === "default" ? void 0 : pMatch[1]?.trim();
-        }
-        if (metaNamespace) namespace = metaNamespace;
-        else {
-          const nsMatch = entry.content.match(/Namespace: (.+?)\.\s/);
-          if (nsMatch) namespace = nsMatch[1]?.trim() === "default" ? void 0 : nsMatch[1]?.trim();
-        }
-        if (metaSessionKey) sessionKey = metaSessionKey;
-        createdAt = entry.ts;
-      }
-      if (entry.role === "system") {
-        const pm = entry.content.match(/^pending_plan:(.+)$/);
-        if (pm) pendingPlanId = pm[1];
-        const pp = entry.content.match(/^pending_promotion:(.+)$/);
-        if (pp) pendingPromotionId = pp[1];
-        const resolved = entry.content.match(/^(plan_applied|plan_cancelled|promotion_applied|promotion_cancelled):/);
-        if (resolved) {
-          if (entry.content.startsWith("plan_")) {
-            pendingPlanId = void 0;
-          }
-          if (entry.content.startsWith("promotion_")) {
-            pendingPromotionId = void 0;
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  for (const e of transcript) {
-    if (typeof e.seq === "number" && e.seq + 1 > lastTranscriptSeq) {
-      lastTranscriptSeq = e.seq + 1;
-    }
-  }
-  return {
-    id: chatSessionId,
-    principal,
-    sessionKey,
-    namespace,
-    transcript,
-    confirmedPlanIds: /* @__PURE__ */ new Set(),
-    ...pendingPlanId ? { pendingPlanId } : {},
-    ...pendingPromotionId ? { pendingPromotionId } : {},
-    createdAt
-  };
-}
-async function enforceChatSessionNamespace(service, chatSessionId) {
-  const session = await loadChatSession(service.memoryDir, chatSessionId);
-  if (!session) return;
-  enforceNamespaceAllowList(tokenCapabilityStore.getStore(), session.namespace, service.configRef?.defaultNamespace);
-}
-async function appendTranscriptEntry(memoryDir, chatSessionId, entry) {
-  const filePath = chatSessionFile(memoryDir, chatSessionId);
-  const full = {
-    ...entry,
-    seq: nextTranscriptSeq(),
-    ts: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  let fh;
-  try {
-    fh = await open(filePath, fsConstants.O_APPEND | fsConstants.O_WRONLY);
-  } catch (err) {
-    if (err instanceof Error && err.code === "ENOENT") {
-      throw new Error("chat_session_expired");
-    }
-    throw err;
-  }
-  try {
-    await fh.appendFile(JSON.stringify(full) + "\n", "utf8");
-  } finally {
-    await fh.close();
-  }
-  try {
-    await stat(filePath);
-  } catch (err) {
-    if (err instanceof Error && err.code === "ENOENT") {
-      throw new Error("chat_session_expired");
-    }
-    throw err;
-  }
-  notifyTranscriptListeners(memoryDir, chatSessionId, full);
-  return full;
-}
-var transcriptListeners = /* @__PURE__ */ new Map();
-function transcriptListenerKey(memoryDir, chatSessionId) {
-  return `${memoryDir}\0${chatSessionId}`;
-}
-function notifyTranscriptListeners(memoryDir, chatSessionId, entry) {
-  const set = transcriptListeners.get(transcriptListenerKey(memoryDir, chatSessionId));
-  if (!set) return;
-  for (const fn of set) {
-    try {
-      fn(entry);
-    } catch {
-    }
-  }
-}
-function subscribeChatTranscript(memoryDir, chatSessionId, listener) {
-  const key = transcriptListenerKey(memoryDir, chatSessionId);
-  let set = transcriptListeners.get(key);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    transcriptListeners.set(key, set);
-  }
-  set.add(listener);
-  return () => {
-    const current = transcriptListeners.get(key);
-    if (!current) return;
-    current.delete(listener);
-    if (current.size === 0) {
-      transcriptListeners.delete(key);
-    }
-  };
-}
-async function markPendingPlan(memoryDir, chatSessionId, planId) {
-  await appendTranscriptEntry(memoryDir, chatSessionId, {
-    role: "system",
-    content: `pending_plan:${planId}`
-  });
-}
-async function markPendingPromotion(memoryDir, chatSessionId, memoryId) {
-  await appendTranscriptEntry(memoryDir, chatSessionId, {
-    role: "system",
-    content: `pending_promotion:${memoryId}`
-  });
-}
-async function markPlanResolved(memoryDir, chatSessionId, planId) {
-  await appendTranscriptEntry(memoryDir, chatSessionId, {
-    role: "system",
-    content: `plan_applied:${planId}`
-  });
-}
-async function markPromotionResolved(memoryDir, chatSessionId, memoryId) {
-  await appendTranscriptEntry(memoryDir, chatSessionId, {
-    role: "system",
-    content: `promotion_applied:${memoryId}`
-  });
-}
-async function cleanupExpiredChatSessions(memoryDir, ttlHours) {
-  const dir = chatSessionDir(memoryDir);
-  let files;
-  try {
-    files = await readdir(dir);
-  } catch {
-    return 0;
-  }
-  const now = Date.now();
-  let removed = 0;
-  for (const file of files) {
-    if (!file.endsWith(".jsonl")) continue;
-    try {
-      const filePath = join(dir, file);
-      const st = await stat(filePath);
-      const ageHours = (now - st.mtimeMs) / (1e3 * 60 * 60);
-      if (ttlHours <= 0 || ageHours >= ttlHours) {
-        if (ttlHours > 0) {
-          const fresh = await stat(filePath);
-          const freshAge = (Date.now() - fresh.mtimeMs) / (1e3 * 60 * 60);
-          if (freshAge < ttlHours) continue;
-        }
-        await unlink(filePath);
-        removed++;
-      }
-    } catch {
-    }
-  }
-  return removed;
-}
-function sessionBelongsToPrincipal(session, principal) {
-  if (!session.principal) return true;
-  return session.principal === principal;
-}
-
-// src/chat/chat-factory.ts
-function createChatEngine(opts) {
-  const llmClient = opts.fallbackLlm ?? opts.localLlm;
-  if (!llmClient) return null;
-  const adapter = createProductionChatLlmAdapter(llmClient);
-  const executor = createChatExecutor({
-    service: opts.service,
-    principal: opts.principal,
-    namespace: opts.namespace,
-    sessionKey: opts.sessionKey
-  });
-  return new ChatEngine({
-    llm: adapter,
-    executor,
-    maxToolCallsPerTurn: opts.config.maxToolCallsPerTurn,
-    ...opts.config.model ? { model: opts.config.model } : {},
-    correctionAvailable: false,
-    scopeInspectAvailable: false
-  });
-}
-async function processChatMessage(opts) {
-  if (!opts.config?.enabled) {
-    throw new Error("chat_disabled");
-  }
-  if (!opts.service.fallbackLlmRef && !opts.service.localLlmRef) {
-    throw new Error("no_llm_available");
-  }
-  let session;
-  if (opts.chatSessionId) {
-    session = await loadChatSession(opts.memoryDir, opts.chatSessionId);
-    if (!session) throw new Error("chat_session_not_found");
-    if (!sessionBelongsToPrincipal(session, opts.principal)) {
-      throw new Error("access_denied");
-    }
-  } else {
-    session = await createChatSession(opts.memoryDir, {
-      principal: opts.principal,
-      ...opts.namespace ? { namespace: opts.namespace } : {},
-      ...opts.sessionKey ? { sessionKey: opts.sessionKey } : {}
-    });
-  }
-  const engine = createChatEngine({
-    service: opts.service,
-    config: opts.config,
-    fallbackLlm: opts.service.fallbackLlmRef,
-    localLlm: opts.service.localLlmRef,
-    principal: opts.principal,
-    ...session.namespace ? { namespace: session.namespace } : {},
-    ...session.sessionKey ? { sessionKey: session.sessionKey } : {}
-  });
-  if (!engine) {
-    throw new Error("engine_unavailable");
-  }
-  await appendTranscriptEntry(opts.memoryDir, session.id, {
-    role: "user",
-    content: opts.message
-  });
-  const priorPendingPlanId = session.pendingPlanId;
-  const priorPendingPromotionId = session.pendingPromotionId;
-  const result = await engine.processMessage(opts.message, session);
-  await appendTranscriptEntry(opts.memoryDir, session.id, {
-    role: "assistant",
-    content: result.reply
-  });
-  if (result.pendingPlan?.planId) {
-    await markPendingPlan(opts.memoryDir, session.id, result.pendingPlan.planId);
-  } else if (session.pendingPromotionId && !priorPendingPromotionId) {
-    await markPendingPromotion(opts.memoryDir, session.id, session.pendingPromotionId);
-  } else if (priorPendingPlanId && !session.pendingPlanId) {
-    await markPlanResolved(opts.memoryDir, session.id, priorPendingPlanId);
-  } else if (priorPendingPromotionId && !session.pendingPromotionId) {
-    await markPromotionResolved(opts.memoryDir, session.id, priorPendingPromotionId);
-  }
-  return result;
-}
-
-// src/meetings/mcp-tools.ts
-var MEETINGS_MCP_TOOLS = [
-  {
-    name: "engram.meetings_list",
-    description: "List stored meeting records (issue #1900), across all days or one day. Returns per-day meeting summaries; empty when meetings.enabled is off.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        date: {
-          type: "string",
-          description: "Optional day to list (YYYY-MM-DD). Omit for all days."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.meetings_get",
-    description: "Return one stored meeting record's markdown by id (mtg-YYYY-MM-DD-<hash>). Absent when not found or meetings.enabled is off.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        id: {
-          type: "string",
-          description: "Meeting id (mtg-YYYY-MM-DD-<hash>). Required."
-        }
-      },
-      required: ["id"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.meetings_build",
-    description: "Detect + fuse + store a day's meetings from ingested audio + screen activity. No-op (enabled:false) when meetings.enabled is off.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        date: {
-          type: "string",
-          description: "Day to build (YYYY-MM-DD). Required."
-        }
-      },
-      required: ["date"],
-      additionalProperties: false
-    }
-  }
-];
-
-// src/wearables/mcp-tools.ts
-var WEARABLES_MCP_TOOLS = [
-  {
-    name: "engram.wearables_status",
-    description: "Status of wearable transcript sources (Limitless / Bee / Omi): configured sources, connector availability, last sync, stored transcript days.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.wearables_sync",
-    description: "Pull, clean, and store wearable transcripts for one source or all enabled sources; optionally creates trust-gated memories per the source's memoryMode.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        source: {
-          type: "string",
-          description: "Source id (e.g. limitless, bee, omi). Omit to sync every enabled source."
-        },
-        date: {
-          type: "string",
-          description: "Sync exactly this day (YYYY-MM-DD). Overrides days."
-        },
-        days: {
-          type: "integer",
-          minimum: 1,
-          maximum: 90,
-          description: "Lookback window in days ending today (default 2)."
-        },
-        forceMemories: {
-          type: "boolean",
-          description: "Re-run memory extraction even for unchanged days."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.transcript_day",
-    description: "Return the full stored wearable transcript(s) for a day, across all sources or one source, with cross-source overlap hints.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        date: {
-          type: "string",
-          description: "Day to read (YYYY-MM-DD). Required."
-        },
-        source: {
-          type: "string",
-          description: "Optional source id to scope to (e.g. limitless)."
-        }
-      },
-      required: ["date"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.transcript_search",
-    description: "Search stored wearable transcripts. Results carry source + date so callers can pull the full day via engram.transcript_day.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        query: {
-          type: "string",
-          description: "Search query. Required; non-empty."
-        },
-        source: {
-          type: "string",
-          description: "Optional source id filter."
-        },
-        from: {
-          type: "string",
-          description: "Optional inclusive start date (YYYY-MM-DD)."
-        },
-        to: {
-          type: "string",
-          description: "Optional inclusive end date (YYYY-MM-DD)."
-        },
-        limit: {
-          type: "integer",
-          minimum: 1,
-          maximum: 50,
-          description: "Maximum results (default 10)."
-        }
-      },
-      required: ["query"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.transcript_memories",
-    description: "List memories created from wearable transcripts, filterable by source and/or day. Includes pending_review candidates awaiting approval.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
-        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
-        source: {
-          type: "string",
-          description: "Optional source id filter (e.g. limitless)."
-        },
-        date: {
-          type: "string",
-          description: "Optional transcript day filter (YYYY-MM-DD)."
-        },
-        limit: {
-          type: "integer",
-          minimum: 1,
-          maximum: 200,
-          description: "Maximum results (default 50)."
-        }
-      },
-      additionalProperties: false
-    }
-  }
-];
-
-// src/location/mcp-tools.ts
-var LOCATION_MCP_TOOLS = [
-  {
-    name: "engram.location_status",
-    description: "Location sync status: master gate, timezone, per-source provider registration, last sync, and recent stored day counts. Never returns secrets, addresses, coordinates, or place labels.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.location_check",
-    description: "Probe every enabled location provider (auth/connectivity). Reports ok/detail per source; a disabled master gate or source reports a skip reason, never an error.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.location_sync",
-    description: "Sync local-day place observations from every enabled location provider (default: location.syncDays ending yesterday). Same shared runner as the CLI and HTTP surfaces; a forced sync never bypasses the enabled gates or validation. Returns per-day, per-source synced/skipped/failed results.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        date: {
-          type: "string",
-          description: "Optional exclusive-window end day (YYYY-MM-DD, inclusive); defaults to yesterday in location.timezone."
-        },
-        days: {
-          type: "integer",
-          minimum: 1,
-          maximum: 90,
-          description: "Optional window size (1..90); defaults to location.syncDays."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.location_backfill",
-    description: "Sync an explicit historical day range (inclusive, capped at 90 days) for every enabled location provider, then re-tag overlapping memories with provider-owned location metadata (issue #2046; requires location.tagging.backfillEnabled). dryRun reports the memory changes without persisting anything \u2014 no day files, no memory patches. Never makes an unbounded scan and never calls the LLM.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        from: { type: "string", description: "Range start day (YYYY-MM-DD)." },
-        to: { type: "string", description: "Range end day (YYYY-MM-DD, inclusive)." },
-        dryRun: { type: "boolean", description: "Report only; persist nothing." }
-      },
-      required: ["from", "to"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.location_day",
-    description: "Return one stored location day (place segments per source). Coordinates appear only when location.retainCoordinates is enabled; an unstored day returns found:false.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        date: { type: "string", description: "Day to read (YYYY-MM-DD)." }
-      },
-      required: ["date"],
-      additionalProperties: false
-    }
-  }
-];
-
-// src/standup/mcp-tools.ts
-var STANDUP_MCP_TOOLS = [
-  {
-    name: "engram.standup",
-    description: "Deterministic standup brief: yesterday highlights, today priorities, blockers, and an activity grid. Pass date as YYYY-MM-DD; default is today UTC.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        date: { type: "string", description: "Standup day (YYYY-MM-DD). Defaults to today UTC." }
-      },
-      additionalProperties: false
-    }
-  }
-];
-
-// src/support-passport/mcp-tools.ts
-var CARD_CATEGORIES = [
-  "communication",
-  "environment",
-  "transitions",
-  "sensory",
-  "regulation",
-  "interests",
-  "other"
-];
-var cardTextProperties = {
-  title: { type: "string", minLength: 1, maxLength: 80 },
-  statement: { type: "string", minLength: 1, maxLength: 500 },
-  category: { type: "string", enum: CARD_CATEGORIES },
-  reviewBy: { type: "string", format: "date-time" }
-};
-var cardRevisionProperties = {
-  cardId: { type: "string", minLength: 1, maxLength: 128 },
-  expectedRevision: { type: "string", pattern: "^[a-f0-9]{64}$" }
-};
-var cardMutationProperties = {
-  ...cardRevisionProperties,
-  reasonCode: { type: "string", minLength: 1, maxLength: 64, pattern: "^[a-z0-9-]+$" }
-};
-var sourceMemoryIdProperty = {
-  type: "string",
-  minLength: 1,
-  maxLength: SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
-};
-var SUPPORT_PASSPORT_MCP_MIGRATED_OPERATIONS = {
-  "engram.support_passport_memory_preview": "support_passport_memory_preview",
-  "engram.support_passport_cards_list": "support_passport_cards_list",
-  "engram.support_passport_draft_create": "support_passport_draft_create",
-  "engram.support_passport_drafts_generate": "support_passport_drafts_generate",
-  "engram.support_passport_card_replace": "support_passport_card_replace",
-  "engram.support_passport_card_approve": "support_passport_card_approve",
-  "engram.support_passport_card_reject": "support_passport_card_reject",
-  "engram.support_passport_card_withdraw": "support_passport_card_withdraw",
-  "engram.support_passport_grant_create": "support_passport_grant_create",
-  "engram.support_passport_grants_list": "support_passport_grants_list",
-  "engram.support_passport_grant_revoke": "support_passport_grant_revoke"
-};
-var SUPPORT_PASSPORT_MCP_TOOLS = [
-  {
-    name: "engram.support_passport_memory_preview",
-    description: "Preview one memory and get the exact revision required for model drafting consent.",
-    inputSchema: {
-      type: "object",
-      properties: { memoryId: sourceMemoryIdProperty },
-      required: ["memoryId"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.support_passport_cards_list",
-    description: "List your support cards.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false }
-  },
-  {
-    name: "engram.support_passport_draft_create",
-    description: "Create one support card draft for your review.",
-    inputSchema: {
-      type: "object",
-      properties: cardTextProperties,
-      required: ["title", "statement", "category", "reviewBy"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.support_passport_drafts_generate",
-    description: "Draft support cards from only the memories you select and consent to send to your configured model.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sourceMemoryIds: {
-          type: "array",
-          minItems: 1,
-          maxItems: 20,
-          uniqueItems: true,
-          items: sourceMemoryIdProperty
-        },
-        sourceMemoryRevisions: {
-          type: "array",
-          minItems: 1,
-          maxItems: 20,
-          uniqueItems: true,
-          items: {
-            type: "object",
-            properties: {
-              memoryId: sourceMemoryIdProperty,
-              revision: { type: "string", pattern: "^[a-f0-9]{64}$" }
-            },
-            required: ["memoryId", "revision"],
-            additionalProperties: false
-          }
-        },
-        consent: { const: true }
-      },
-      required: ["sourceMemoryIds", "sourceMemoryRevisions", "consent"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.support_passport_card_replace",
-    description: "Create a replacement draft for one support card.",
-    inputSchema: {
-      type: "object",
-      properties: { ...cardTextProperties, ...cardRevisionProperties },
-      required: ["cardId", "title", "statement", "category", "reviewBy", "expectedRevision"],
-      additionalProperties: false
-    }
-  },
-  ...["approve", "reject", "withdraw"].map(
-    (action) => ({
-      name: `engram.support_passport_card_${action}`,
-      description: `${action === "withdraw" ? "Withdraw" : action === "approve" ? "Approve" : "Reject"} one support card as its owner.`,
-      inputSchema: {
-        type: "object",
-        properties: cardMutationProperties,
-        required: ["cardId", "expectedRevision", "reasonCode"],
-        additionalProperties: false
-      }
-    })
-  ),
-  {
-    name: "engram.support_passport_grant_create",
-    description: "Create one timed share link for selected approved support cards.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cardIds: {
-          type: "array",
-          minItems: 1,
-          maxItems: 8,
-          uniqueItems: true,
-          items: { type: "string", minLength: 1, maxLength: 128 }
-        },
-        cardRevisions: {
-          type: "array",
-          minItems: 1,
-          maxItems: 8,
-          uniqueItems: true,
-          items: {
-            type: "object",
-            properties: {
-              cardId: { type: "string", minLength: 1, maxLength: 128 },
-              revision: { type: "string", pattern: "^[a-f0-9]{64}$" }
-            },
-            required: ["cardId", "revision"],
-            additionalProperties: false
-          }
-        },
-        expiresAt: { type: "string", format: "date-time" },
-        durationMs: { type: "integer", minimum: 3e5, maximum: 6048e5 }
-      },
-      required: ["cardIds", "cardRevisions"],
-      oneOf: [{ required: ["expiresAt"] }, { required: ["durationMs"] }],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "engram.support_passport_grants_list",
-    description: "List your support passport share links without secrets.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false }
-  },
-  {
-    name: "engram.support_passport_grant_revoke",
-    description: "Stop one support passport share link.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        grantId: { type: "string", minLength: 1, maxLength: 128 },
-        expectedVersion: { type: "integer", minimum: 1 }
-      },
-      required: ["grantId", "expectedVersion"],
-      additionalProperties: false
-    }
-  }
-];
-
-// src/access-mcp.ts
-function throwMcpAbort(signal, message) {
-  if (!signal?.aborted) return;
-  if (isAbortError(signal.reason)) throw signal.reason;
-  throw abortError(message);
-}
-var MCP_SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
-var MCP_DEFAULT_PROTOCOL_VERSION = MCP_SUPPORTED_PROTOCOL_VERSIONS[0] ?? "2025-06-18";
-function isReadOnlyToolName(name) {
-  const suffix = toolNameSuffix(name);
-  return suffix !== null && MCP_READ_ONLY_TOOL_SUFFIXES[suffix] === true;
-}
-var MCP_MIGRATED_OPERATIONS = {
-  "engram.memory_get": "memory_get",
-  "engram.memory_search": "memory_search",
-  "engram.external_wiki_search": "external_wiki_search",
-  "engram.memory_store": "memory_store",
-  "engram.coding_decision": "coding_decision",
-  "engram.coding_architecture": "coding_architecture",
-  // codegraph parity tools (issue #1554) — each maps to its boundary op.
-  "engram.codegraph_index": "codegraph_index",
-  "engram.codegraph_list_projects": "codegraph_list_projects",
-  "engram.codegraph_delete_project": "codegraph_delete_project",
-  "engram.codegraph_index_status": "codegraph_index_status",
-  "engram.codegraph_search_graph": "codegraph_search_graph",
-  "engram.codegraph_trace_path": "codegraph_trace_path",
-  "engram.codegraph_detect_changes": "codegraph_detect_changes",
-  "engram.codegraph_query_graph": "codegraph_query_graph",
-  "engram.codegraph_get_schema": "codegraph_get_schema",
-  "engram.codegraph_get_snippet": "codegraph_get_snippet",
-  "engram.codegraph_get_architecture": "codegraph_get_architecture",
-  "engram.codegraph_search_code": "codegraph_search_code",
-  "engram.codegraph_manage_adr": "codegraph_manage_adr",
-  "engram.codegraph_ingest_traces": "codegraph_ingest_traces",
-  "engram.coding_delta": "coding_delta",
-  // Correction Contract (issue #1580) — one plan/apply pipeline.
-  "engram.memory_correct_plan": "memory_correct_plan",
-  "engram.memory_correct_apply": "memory_correct_apply",
-  // Fully migrated through the strict-schema boundary (#1668).
-  "engram.recall": "recall",
-  "engram.recall_explain": "recall_explain",
-  "engram.set_coding_context": "set_coding_context",
-  "engram.recall_tier_explain": "recall_tier_explain",
-  "engram.recall_xray": "recall_xray",
-  "engram.who_knows": "who_knows",
-  "engram.promotion_candidates": "promotion_candidates",
-  "engram.wearables_status": "wearables_status",
-  "engram.wearables_sync": "wearables_sync",
-  "engram.location_status": "location_status",
-  "engram.location_check": "location_check",
-  "engram.location_sync": "location_sync",
-  "engram.location_backfill": "location_backfill",
-  "engram.location_day": "location_day",
-  "engram.transcript_day": "transcript_day",
-  "engram.transcript_search": "transcript_search",
-  "engram.transcript_memories": "transcript_memories",
-  "engram.meetings_list": "meetings_list",
-  "engram.meetings_get": "meetings_get",
-  "engram.meetings_build": "meetings_build",
-  "engram.standup": "standup",
-  "engram.action_confidence": "action_confidence",
-  "engram.chatgpt_memory_inspector": "chatgpt_memory_inspector",
-  "engram.day_summary": "day_summary",
-  "engram.capsule_export": "capsule_export",
-  "engram.capsule_import": "capsule_import",
-  "engram.capsule_list": "capsule_list",
-  "engram.memory_governance_run": "memory_governance_run",
-  "engram.entity_synthesis_run": "entity_synthesis_run",
-  "engram.procedure_mining_run": "procedure_mining_run",
-  "engram.pattern_reinforcement_run": "pattern_reinforcement_run",
-  "engram.procedural_stats": "procedural_stats",
-  "engram.procedure_library_maintenance": "procedure_library_maintenance",
-  "engram.memory_timeline": "memory_timeline",
-  "engram.suggestion_submit": "suggestion_submit",
-  "engram.entity_get": "entity_get",
-  "engram.review_queue_list": "review_queue_list",
-  "engram.observe": "observe",
-  "engram.lcm_search": "lcm_search",
-  "engram.lcm_compaction_flush": "lcm_compaction_flush",
-  "engram.extraction_force_flush": "extraction_force_flush",
-  "engram.lcm_compaction_record": "lcm_compaction_record",
-  "engram.continuity_audit_generate": "continuity_audit_generate",
-  "engram.continuity_incident_open": "continuity_incident_open",
-  "engram.continuity_incident_close": "continuity_incident_close",
-  "engram.continuity_incident_list": "continuity_incident_list",
-  "engram.continuity_loop_add_or_update": "continuity_loop_add_or_update",
-  "engram.continuity_loop_review": "continuity_loop_review",
-  "engram.identity_anchor_get": "identity_anchor_get",
-  "engram.identity_anchor_update": "identity_anchor_update",
-  "engram.memory_identity": "memory_identity",
-  "engram.work_task": "work_task",
-  "engram.work_project": "work_project",
-  "engram.work_board": "work_board",
-  "engram.shared_context_write_output": "shared_context_write_output",
-  "engram.shared_feedback_record": "shared_feedback_record",
-  "engram.shared_priorities_append": "shared_priorities_append",
-  "engram.shared_context_cross_signals_run": "shared_context_cross_signals_run",
-  "engram.shared_context_curate_daily": "shared_context_curate_daily",
-  "engram.compounding_weekly_synthesize": "compounding_weekly_synthesize",
-  "engram.compounding_promote_candidate": "compounding_promote_candidate",
-  "engram.compression_guidelines_optimize": "compression_guidelines_optimize",
-  "engram.compression_guidelines_activate": "compression_guidelines_activate",
-  "engram.memory_profile": "memory_profile",
-  "engram.memory_entities_list": "memory_entities_list",
-  "engram.memory_questions": "memory_questions",
-  "engram.memory_last_recall": "memory_last_recall",
-  "engram.memory_intent_debug": "memory_intent_debug",
-  "engram.memory_qmd_debug": "memory_qmd_debug",
-  "engram.memory_graph_explain": "memory_graph_explain",
-  "engram.graph_snapshot": "graph_snapshot",
-  "engram.memory_feedback": "memory_feedback",
-  "engram.memory_promote": "memory_promote",
-  "engram.memory_outcome": "memory_outcome",
-  "engram.memory_action_apply": "memory_action_apply",
-  "engram.context_checkpoint": "context_checkpoint",
-  "engram.briefing": "briefing",
-  "engram.review_list": "review_list",
-  "engram.review_resolve": "review_resolve",
-  "engram.contradiction_scan_run": "contradiction_scan_run",
-  "engram.memory_summarize_hourly": "memory_summarize_hourly",
-  "engram.conversation_index_update": "conversation_index_update",
-  "engram.profiling_report": "profiling_report",
-  "engram.graph_edge_decay_run": "graph_edge_decay_run",
-  "engram.live_connectors_run": "live_connectors_run",
-  "engram.peer_list": "peer_list",
-  "engram.peer_get": "peer_get",
-  "engram.peer_set": "peer_set",
-  "engram.peer_delete": "peer_delete",
-  "engram.peer_profile_get": "peer_profile_get",
-  "engram.peer_forget": "peer_forget",
-  "engram.console_state": "console_state",
-  "engram.dreams_status": "dreams_status",
-  "engram.dreams_run": "dreams_run",
-  ...SUPPORT_PASSPORT_MCP_MIGRATED_OPERATIONS,
-  ...MCP_ADMIN_OPS_MIGRATED_OPERATIONS,
-  "engram.deep_recall": "deep_recall",
-  "engram.memory_expand": "memory_expand",
-  "engram.memory_traverse": "memory_traverse",
-  "engram.memory_ls": "memory_ls",
-  "engram.memory_tree": "memory_tree",
-  "engram.memory_find": "memory_find",
-  "engram.memory_chat": "chat_message"
-};
-var STRICT_MCP_SCHEMA_KEYS = {
-  daySummary: ["memories", "includeLocation", "sessionKey", "namespace", "timeZone", "cwd", "projectTag"],
-  memoryStore: [
-    "schemaVersion",
-    "idempotencyKey",
-    "dryRun",
-    "sessionKey",
-    "content",
-    "category",
-    "confidence",
-    "namespace",
-    "tags",
-    "entityRef",
-    "ttl",
-    "sourceReason",
-    "cwd",
-    "projectTag"
-  ],
-  suggestionSubmit: [
-    "schemaVersion",
-    "idempotencyKey",
-    "dryRun",
-    "sessionKey",
-    "content",
-    "category",
-    "confidence",
-    "namespace",
-    "tags",
-    "entityRef",
-    "ttl",
-    "sourceReason",
-    "cwd",
-    "projectTag"
-  ],
-  capsuleExport: [
-    "name",
-    "namespace",
-    "since",
-    "includeKinds",
-    "peerIds",
-    "includeTranscripts",
-    "encrypt",
-    "cwd",
-    "projectTag"
-  ],
-  capsuleImport: ["archivePath", "namespace", "mode", "passphrase", "cwd", "projectTag"],
-  capsuleList: ["namespace", "sessionKey", "cwd", "projectTag"]
-};
-var MCP_WIRE_SCHEMAS = {
-  memory_store: "memoryStore",
-  suggestion_submit: "suggestionSubmit",
-  action_confidence: "actionConfidence",
-  day_summary: "daySummary",
-  capsule_export: "capsuleExport",
-  capsule_import: "capsuleImport",
-  capsule_list: "capsuleList",
-  observe: "observe",
-  recall: "recall",
-  lcm_compaction_flush: "lcmCompactionFlush",
-  extraction_force_flush: "extractionForceFlush",
-  lcm_compaction_record: "lcmCompactionRecord"
-};
-var MCP_GIT_CONTEXT_SCHEMA_PROPS_SCOPED = {
-  cwd: {
-    type: "string",
-    description: "Optional working directory. When no explicit namespace is given, resolves the project namespace this write is stored in (mirrors recall/observe)."
-  },
-  projectTag: {
-    type: "string",
-    description: "Optional project tag for non-git project scoping. When no explicit namespace is given, routes this write to the tagged project 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
-  );
-}
-function getObjectProperties(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-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 readFile2(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.emitLegacyTools = options.emitLegacyTools !== false;
-    this.codingDecisionVisible = options.codingDecisionVisible === true;
-    this.architectureCardVisible = options.architectureCardVisible === true;
-    this.codegraphVisible = options.codegraphVisible === true;
-    this.sessionDeltaVisible = options.sessionDeltaVisible === true;
-    this.correctionVisible = options.correctionVisible !== false;
-    this.chatVisible = options.chatVisible === true;
-    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" },
-            // Disclosure depth (issue #677); default `chunk` when omitted.
-            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. 'acme-webshop')."
-            },
-            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) or 'all'."
-            },
-            stateView: {
-              type: "boolean",
-              description: "Opt in to state-aware recall views (issue #1952); ORs with the recallStateViews config flag."
-            }
-          },
-          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. 'acme-webshop'). 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
-        }
-      },
-      ...WEARABLES_MCP_TOOLS,
-      ...MEETINGS_MCP_TOOLS,
-      ...WHO_KNOWS_MCP_TOOLS,
-      ...PROMOTION_CANDIDATES_MCP_TOOLS,
-      ...LOCATION_MCP_TOOLS,
-      ...STANDUP_MCP_TOOLS,
-      ...DEEP_RECALL_MCP_TOOLS,
-      ...service.recallNavigationEnabled !== false ? RECALL_NAVIGATION_MCP_TOOLS : [],
-      ...MEMORY_BROWSE_MCP_TOOLS,
-      ...service.supportPassportEnabled ? SUPPORT_PASSPORT_MCP_TOOLS : [],
-      {
-        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."
-            },
-            allowUnverifiedPreview: {
-              type: "boolean",
-              description: "If true, the inspector may show recalled preview text when X-ray provenance is missing or unavailable. Explicitly blocked memories remain redacted."
-            }
-          },
-          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" },
-            timeZone: { type: "string" },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED
-          },
-          required: [],
-          additionalProperties: false
-        }
-      },
-      ...MCP_ADMIN_OPS_TOOLS,
-      {
-        name: "engram.memory_get",
-        description: "Fetch one Remnic memory by id.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            memoryId: { type: "string" },
-            namespace: { type: "string" },
-            // Issue #1582 — when memoryId is a `[m:xxxx]` handle, sessionKey
-            // scopes resolution to this session's recent recall history.
-            // Advertising it here lets the transport inject its session key
-            // (toolAcceptsArgument) so MCP callers can cite handles (codex review).
-            sessionKey: { 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" },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_SCOPED
-          },
-          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" },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_SCOPED
-          },
-          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"
-            },
-            idempotencyKey: {
-              type: "string",
-              description: "Optional idempotency key (issue #1649). Deduplicates a retried observe POST server-side so the batch is ingested once even when the HTTP response is lost. Reusing the key with a different payload is rejected."
-            },
-            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. 'acme-webshop')."
-            }
-          },
-          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" },
-            sessionPrefix: { type: "string", description: "Optional session prefix 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" },
-            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
-            projectTag: { type: "string", description: "Project tag for non-git project scoping." }
-          },
-          required: ["sessionKey"],
-          additionalProperties: false
-        }
-      },
-      {
-        name: "engram.extraction_force_flush",
-        description: "Force-drain a session extraction buffer before a lifecycle boundary.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sessionKey: { type: "string", description: "Conversation session identifier" },
-            namespace: { type: "string" },
-            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
-            projectTag: { type: "string", description: "Project tag for non-git project scoping." },
-            deadlineMs: { type: "number", minimum: 0 }
-          },
-          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 tools (extracted; access-mcp.ts is at its ratchet
-      // ceiling — issue #2920) ─────────────────────────────────────────
-      ...sharedContextMcpTools,
-      {
-        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
-        }
-      },
-      ...EXTERNAL_WIKI_MCP_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. With namespaces enabled, omitted, base, and 'global' searches stay scoped to readable namespaces; namespace-derived collections require matching namespace access."
-            },
-            mode: { type: "string", enum: ["search", "hybrid", "bm25", "vector"], description: "Ranking mode; omitted uses the backend default. Not supported with 'collection' on a flat corpus." }
-          },
-          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" },
-              includeLocation: { type: "boolean", description: "Opt-in: append matched location place names (location gates apply)." },
-              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, this.emitLegacyTools));
-    if (this.codingDecisionVisible) {
-      const codingDecisionTools = withToolAliases(
-        {
-          name: "engram.coding_decision",
-          description: "List, get, record, or supersede decision records in the session's coding namespace (issue #1548 Track A). Subcommands: list, get, record, supersede.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              subcommand: {
-                type: "string",
-                enum: ["list", "get", "record", "supersede"],
-                description: "Which decision-record operation to run."
-              },
-              sessionKey: {
-                type: "string",
-                description: "Session identifier whose coding context scopes the operation."
-              },
-              namespace: {
-                type: "string",
-                description: "Optional explicit namespace (overrides coding-context overlay)."
-              },
-              id: { type: "string", description: "Decision record id (required for get and supersede)." },
-              title: { type: "string", description: "Decision title (required for record and supersede)." },
-              status: {
-                type: "string",
-                enum: ["proposed", "accepted", "superseded", "rejected"],
-                description: "Decision status (record only; defaults to proposed)."
-              },
-              context: { type: "string", description: "Context/background for the decision." },
-              decision: { type: "string", description: "The decision itself (required for record and supersede)." },
-              consequences: { type: "string", description: "Consequences of the decision." },
-              entityRefs: {
-                type: "array",
-                items: { type: "string" },
-                description: "Entity references the decision relates to."
-              },
-              supersedesId: {
-                type: "string",
-                description: "Id of the record this decision supersedes (supersede only)."
-              }
-            },
-            required: ["subcommand"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      this.tools = [...this.tools, ...codingDecisionTools];
-    }
-    if (this.architectureCardVisible) {
-      const architectureTools = withToolAliases(
-        {
-          name: "engram.coding_architecture",
-          description: "Get or refresh the architecture card for the session's coding namespace (issue #1548 Track A PR 3). Subcommands: get, refresh.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              subcommand: {
-                type: "string",
-                enum: ["get", "refresh"],
-                description: "Which architecture-card operation to run."
-              },
-              sessionKey: {
-                type: "string",
-                description: "Session identifier whose coding context scopes the operation."
-              },
-              namespace: {
-                type: "string",
-                description: "Optional explicit namespace (overrides coding-context overlay)."
-              }
-            },
-            required: ["subcommand"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      this.tools = [...this.tools, ...architectureTools];
-    }
-    if (this.codegraphVisible) {
-      const codegraphToolDefs = [
-        { suffix: "index", description: "Index a repository into the code graph.", required: ["repoRoot"] },
-        { suffix: "list_projects", description: "List code graph projects for the principal." },
-        {
-          suffix: "delete_project",
-          description: "Delete a code graph project (requires confirm: true).",
-          required: ["confirm"]
-        },
-        { suffix: "index_status", description: "Get the indexing status for a project." },
-        { suffix: "search_graph", description: "Search the code graph for symbols.", required: ["query"] },
-        {
-          suffix: "trace_path",
-          description: "Trace call/dependency paths from a starting symbol.",
-          required: ["start"]
-        },
-        { suffix: "detect_changes", description: "Detect changed symbols since a git ref.", required: ["head"] },
-        {
-          suffix: "query_graph",
-          description: "Run a structured query against the code graph.",
-          required: ["structuredQuery"]
-        },
-        { suffix: "get_schema", description: "Get the code graph schema statistics." },
-        { suffix: "get_snippet", description: "Get a source code snippet for a symbol.", required: ["qualifiedName"] },
-        { suffix: "get_architecture", description: "Get the composed architecture card + graph stats." },
-        {
-          suffix: "search_code",
-          description: "Search the code graph for code (functions, classes, methods).",
-          required: ["query"]
-        },
-        {
-          suffix: "manage_adr",
-          description: "Manage ADRs via Track A decision records (list, get, record, supersede).",
-          required: ["subcommand"]
-        },
-        {
-          suffix: "ingest_traces",
-          description: "Ingest call-site traces to upgrade edge confidence.",
-          required: ["traces"]
-        }
-      ];
-      for (const def of codegraphToolDefs) {
-        const tools = withToolAliases(
-          {
-            name: `engram.codegraph_${def.suffix}`,
-            description: def.description,
-            inputSchema: {
-              type: "object",
-              properties: {
-                sessionKey: {
-                  type: "string",
-                  description: "Session identifier whose coding context scopes the operation."
-                },
-                project: { type: "string", description: "Explicit project id (defaults to session coding context)." },
-                principal: { type: "string", description: "Authenticated principal override." },
-                query: { type: "string" },
-                limit: { type: "number" },
-                start: { type: "string" },
-                direction: { type: "string", enum: ["inbound", "outbound", "both"] },
-                depth: { type: "number" },
-                qualifiedName: { type: "string" },
-                path: { type: "string" },
-                structuredQuery: { type: "object" },
-                head: { type: "string" },
-                repoRoot: { type: "string" },
-                mode: { type: "string", enum: ["auto", "full", "incremental"] },
-                confirm: { type: "boolean" },
-                subcommand: { type: "string", enum: ["list", "get", "record", "supersede"] },
-                id: { type: "string" },
-                title: { type: "string" },
-                status: { type: "string", enum: ["proposed", "accepted", "superseded", "rejected"] },
-                context: { type: "string" },
-                decision: { type: "string" },
-                consequences: { type: "string" },
-                entityRefs: { type: "array", items: { type: "string" } },
-                supersedesId: { type: "string" },
-                traces: { type: "array", items: { type: "object" } }
-              },
-              required: def.required ?? [],
-              additionalProperties: false
-            }
-          },
-          this.emitLegacyTools
-        );
-        this.tools = [...this.tools, ...tools];
-      }
-    }
-    if (this.sessionDeltaVisible) {
-      const deltaTools = withToolAliases(
-        {
-          name: "engram.coding_delta",
-          description: "Get the session delta (commits + touched files since last seen) for the session's coding namespace (issue #1548 Track A PR 4). Subcommand: get.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              subcommand: {
-                type: "string",
-                enum: ["get"],
-                description: "Which delta operation to run."
-              },
-              sessionKey: {
-                type: "string",
-                description: "Session identifier whose coding context scopes the operation."
-              },
-              namespace: {
-                type: "string",
-                description: "Optional explicit namespace (overrides coding-context overlay)."
-              }
-            },
-            required: ["subcommand"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      this.tools = [...this.tools, ...deltaTools];
-    }
-    if (this.correctionVisible) {
-      const planTool = withToolAliases(
-        {
-          name: "engram.memory_correct_plan",
-          description: "Plan a memory correction from a plain-language statement (issue #1580). Returns a CorrectionPlan with a diff preview; apply via memory_correct_apply.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              text: {
-                type: "string",
-                description: 'The natural-language correction (e.g. "we migrated to MySQL in March").'
-              },
-              targetIds: {
-                type: "array",
-                items: { type: "string" },
-                description: "Optional explicit target memory ids. When omitted, the planner searches."
-              },
-              sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
-              namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." }
-            },
-            required: ["text"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      const applyTool = withToolAliases(
-        {
-          name: "engram.memory_correct_apply",
-          description: "Apply a planned memory correction by planId (issue #1580). Requires confirm: true when correction.applyRequiresConfirm is on (default).",
-          inputSchema: {
-            type: "object",
-            properties: {
-              planId: { type: "string", description: "The plan id returned by memory_correct_plan." },
-              confirm: { type: "boolean", description: "Must be true to apply (safety guard, rule 48)." },
-              sessionKey: { type: "string", description: "Session identifier for namespace resolution." },
-              namespace: { type: "string", description: "Optional explicit namespace (validated by policy)." }
-            },
-            required: ["planId"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      this.tools = [...this.tools, ...planTool, ...applyTool];
-    }
-    if (this.chatVisible) {
-      const chatTools = withToolAliases(
-        {
-          name: "engram.memory_chat",
-          description: "Conversational memory inspection and correction (issue #1583). Send a message to chat about what Remnic remembers, inspect memories, or request corrections. Returns {reply, chatSessionId, pendingPlan?}.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              message: {
-                type: "string",
-                description: "The user's message \u2014 a question about memories, a correction request, or a confirmation (yes/apply) to proceed with a pending plan."
-              },
-              chatSessionId: {
-                type: "string",
-                description: "Optional existing chat session id to resume. Omit to start a new session."
-              }
-            },
-            required: ["message"],
-            additionalProperties: false
-          }
-        },
-        this.emitLegacyTools
-      );
-      this.tools = [...this.tools, ...chatTools];
-    }
-    this.tools = this.tools.map(
-      (tool) => isReadOnlyToolName(tool.name) && tool.annotations?.readOnlyHint !== true ? { ...tool, annotations: { ...tool.annotations ?? {}, readOnlyHint: true } } : tool
-    );
-    this.tools = applyToolOutputSchemas(this.tools, CANONICAL_MCP_PREFIX, LEGACY_MCP_PREFIX);
-  }
-  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;
-  /**
-   * Whether to advertise legacy `engram.*` tool aliases alongside the canonical
-   * `remnic.*` names (issue #1427). Defaults to true for backward compatibility;
-   * set false to halve the advertised `tools/list` surface.
-   */
-  emitLegacyTools;
-  /**
-   * Whether the `coding_decision` tool should appear in `tools/list`. Gated on
-   * `codingKnowledge.enabled && codingKnowledge.decisionRecords` (issue #1548
-   * Track A PR 2, rule 39). When false the tools array is byte-identical to
-   * pre-feature.
-   */
-  codingDecisionVisible;
-  /**
-   * Whether the `coding_architecture` tool should appear in `tools/list`.
-   * Gated on `codingKnowledge.enabled && codingKnowledge.architectureCard`
-   * (issue #1548 Track A PR 3, rule 39).
-   */
-  architectureCardVisible;
-  /**
-   * Whether the 14 codegraph parity tools should appear in `tools/list`
-   * (issue #1554). Config-only -- runtime availability is checked at call
-   * time. When false the tools array is byte-identical to pre-feature.
-   */
-  codegraphVisible;
-  sessionDeltaVisible;
-  /**
-   * Whether the two correction tools (memory_correct_plan / memory_correct_apply)
-   * should appear in `tools/list` (issue #1580). Gated on `correction.enabled`
-   * (default true — plan is read-only; safe on). When false the tools array is
-   * byte-identical to pre-feature.
-   */
-  correctionVisible;
-  /**
-   * Whether the `memory_chat` tool should appear in `tools/list` (issue
-   * #1583). Gated on `chat.enabled`. When false the tools array is
-   * byte-identical to pre-feature (rule 39).
-   */
-  chatVisible;
-  /** 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 ?? {};
-      if (typeof params.protocolVersion !== "string" || params.protocolVersion.length === 0) {
-        return {
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32602,
-            message: `initialize requires params.protocolVersion (string); supported versions: ${MCP_SUPPORTED_PROTOCOL_VERSIONS.join(", ")}`
-          }
-        };
-      }
-      const rawClientInfo = params.clientInfo;
-      const newSessionId = randomUUID2();
-      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_SUPPORTED_PROTOCOL_VERSIONS.includes(params.protocolVersion) ? params.protocolVersion : MCP_DEFAULT_PROTOCOL_VERSION,
-          capabilities: {
-            tools: {},
-            resources: {}
-          },
-          serverInfo: {
-            name: "remnic",
-            version
-          }
-        }
-      };
-    }
-    if (method === "tools/list") {
-      const caps = tokenCapabilityStore.getStore();
-      const tools = caps?.ops === void 0 ? this.tools : this.tools.filter((t) => capabilityAllowsOp(caps, MCP_MIGRATED_OPERATIONS[toLegacyToolName(t.name)] ?? ""));
-      return { jsonrpc: "2.0", id, result: { 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;
-        }
-        if (!("namespace" in argumentsObject) && options?.namespaceOverride && this.toolAcceptsArgument(name, "namespace")) {
-          argumentsObject = { ...argumentsObject, namespace: options.namespaceOverride };
-        }
-        const skipSessionKeyOverride = toLegacyToolName(name) === "engram.lcm_search" && typeof argumentsObject.sessionPrefix === "string" && argumentsObject.sessionPrefix.length > 0;
-        if (!("sessionKey" in argumentsObject) && !skipSessionKeyOverride && options?.sessionKeyOverride && this.toolAcceptsArgument(name, "sessionKey")) {
-          argumentsObject = { ...argumentsObject, sessionKey: options.sessionKeyOverride };
-        }
-        const effectivePrincipal = options?.principalOverride ?? this.authenticatedPrincipal;
-        const mcpScope = {
-          ...options?.namespaceOverride ? { namespace: options.namespaceOverride } : {},
-          ...options?.sessionKeyOverride ? { sessionKey: options.sessionKeyOverride } : {}
-        };
-        throwMcpAbort(options?.abortSignal, "MCP request aborted before operation start");
-        const result = await this.callTool(
-          name,
-          argumentsObject,
-          effectivePrincipal,
-          options?.sessionId,
-          mcpScope,
-          options?.enforceWriteQuota,
-          options?.recordWriteCommit,
-          options?.sourceConnector,
-          options?.abortSignal
-        );
-        if (isReadOnlyToolName(name)) {
-          throwMcpAbort(options?.abortSignal, "MCP request aborted before response");
-        }
-        const structuredContent = result;
-        return {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            content: [{ type: "text", text: JSON.stringify(result ?? null, null, 2) }],
-            ...structuredContent == null ? {} : { structuredContent },
-            isError: false
-          }
-        };
-      } catch (err) {
-        if (isAbortError(err)) throw 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 = Number.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);
-  }
-  toolAcceptsArgument(name, key) {
-    const target = toCanonicalToolName(name);
-    const tool = this.tools.find((entry) => toCanonicalToolName(entry.name) === target);
-    const inputSchema = getObjectProperties(tool?.inputSchema);
-    const properties = getObjectProperties(inputSchema?.properties);
-    if (properties && Object.prototype.hasOwnProperty.call(properties, key)) {
-      return true;
-    }
-    return inputSchema?.additionalProperties === true;
-  }
-  /**
-   * Whether a tool accepts a `namespace` argument — i.e. it is a
-   * namespace-scoped operation whose effective namespace MUST be gated by the
-   * per-token allow-list. Exposed (public) so the HTTP MCP transport can run
-   * the SAME effective-namespace enforcement the REST surface runs, without
-   * duplicating the tool-schema introspection (issue #1850). Namespace-
-   * agnostic tools (peer/wearables/etc.) return false and stay ungated,
-   * matching the REST surface where those routes never call resolveNamespace.
-   */
-  toolAcceptsNamespace(name) {
-    return this.toolAcceptsArgument(name, "namespace");
-  }
-  /**
-   * 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, scope, enforceWriteQuota, recordWriteCommit, sourceConnector, abortSignal) {
-    const migrated = MCP_MIGRATED_OPERATIONS[toLegacyToolName(name)];
-    if (!migrated) {
-      throw new Error(`unknown tool: ${name}`);
-    }
-    const op = getOperation(migrated);
-    if (!op) {
-      throw new EngramAccessInputError(`access-boundary: operation not registered: ${migrated}`);
-    }
-    let envelope;
-    const wireSchema = MCP_WIRE_SCHEMAS[migrated];
-    if (wireSchema) {
-      envelope = parseMcpRequest(wireSchema, args);
-    } else if (migrated.startsWith("codegraph_")) {
-      envelope = { ...args, tool: migrated.slice("codegraph_".length) };
-    } else if (migrated === "chat_message") {
-      assertOperationAllowed(tokenCapabilityStore.getStore(), migrated);
-      const message = typeof args.message === "string" ? args.message : "";
-      if (!message) throw new EngramAccessInputError("message is required");
-      const chatSessionId = typeof args.chatSessionId === "string" ? args.chatSessionId : void 0;
-      if (chatSessionId) {
-        await enforceChatSessionNamespace(this.service, chatSessionId);
-      } else {
-        enforceNamespaceAllowList(
-          tokenCapabilityStore.getStore(),
-          scope?.namespace,
-          this.service.configRef?.defaultNamespace
-        );
-      }
-      const chatResult = await processChatMessage({
-        service: this.service,
-        config: this.service.configRef?.chat,
-        memoryDir: this.service.memoryDir,
-        message,
-        ...chatSessionId ? { chatSessionId } : {},
-        ...effectivePrincipal ? { principal: effectivePrincipal } : {},
-        ...scope?.namespace ? { namespace: scope.namespace } : {},
-        ...scope?.sessionKey ? { sessionKey: scope.sessionKey } : {}
-      });
-      if (chatResult && typeof chatResult === "object" && "error" in chatResult) {
-        const { error: _stripped, ...wireResult } = chatResult;
-        return wireResult;
-      }
-      return chatResult;
-    } else {
-      envelope = args;
-    }
-    if (migrated === "recall") {
-      const result = await op.run(envelope, {
-        service: this.service,
-        authenticatedPrincipal: effectivePrincipal,
-        ...sourceConnector ? { sourceConnector } : {},
-        ...abortSignal ? { abortSignal } : {}
-      });
-      throwMcpAbort(abortSignal, "MCP recall aborted before postprocessing");
-      const response = result.result;
-      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;
-    }
-    const output = await op.run(envelope, {
-      service: this.service,
-      authenticatedPrincipal: effectivePrincipal,
-      ...enforceWriteQuota || recordWriteCommit ? { hooks: { ...enforceWriteQuota ? { enforceWriteQuota } : {}, ...recordWriteCommit ? { recordWriteCommit } : {} } } : {},
-      ...sourceConnector ? { sourceConnector } : {},
-      ...abortSignal ? { abortSignal } : {}
-    });
-    return output.result;
-  }
-};
-
-export {
-  createChatSession,
-  loadChatSession,
-  enforceChatSessionNamespace,
-  subscribeChatTranscript,
-  cleanupExpiredChatSessions,
-  sessionBelongsToPrincipal,
-  processChatMessage,
-  MCP_SUPPORTED_PROTOCOL_VERSIONS,
-  MCP_MIGRATED_OPERATIONS,
-  EngramMcpServer
-};
-//# sourceMappingURL=chunk-FROKVQQY.js.map