@gmickel/gno 1.40.0 → 1.42.0

package/src/core/memory.ts

@@ -0,0 +1,87 @@
+/**
+ * Transport-neutral memory service: `remember()` and `recall()`.
+ *
+ * Every surface (CLI, MCP, REST, SDK) is a thin adapter over this module.
+ * The service owns the shared write lease for every write path; adapters
+ * never take `.mcp-write.lock` themselves (single acquisition point, no
+ * nesting — a caller that already holds the lease deadlocks/fails fast).
+ *
+ * This file is the facade: the contracts live in `memory-types`, validation,
+ * the context fence, and receipts in `memory-fence`, the write path in
+ * `memory-remember`, and retrieval in `memory-recall`. Import from here.
+ *
+ * @module src/core/memory
+ */
+
+import type {
+  MemoryCandidate,
+  MemoryMatchDiagnostics,
+  MemoryServiceDeps,
+  RecallInput,
+  RecallResult,
+  RememberInput,
+  RememberResult,
+} from "./memory-types";
+
+import { recallFacts } from "./memory-recall";
+import {
+  type CandidateQuery,
+  findMemoryCandidates,
+  rememberFact,
+} from "./memory-remember";
+
+export {
+  MEMORY_CANDIDATE_POOL,
+  MEMORY_EMPTY_RECALL_HINT,
+  MEMORY_LEXICAL_LIKELY_THRESHOLD,
+  MEMORY_RECALL_MAX_FACTS,
+  MEMORY_RECALL_MAX_TOKENS,
+  MEMORY_SEMANTIC_LIKELY_THRESHOLD,
+  MemoryError,
+} from "./memory-types";
+export type {
+  MemoryCandidate,
+  MemoryCandidateMatch,
+  MemoryDecision,
+  MemoryErrorCode,
+  MemoryFact,
+  MemoryIdentity,
+  MemoryMatchDiagnostics,
+  MemoryMatchMode,
+  MemoryRecallReceipt,
+  MemoryServiceDeps,
+  MemorySyncState,
+  RecalledFact,
+  RecallInput,
+  RecallResult,
+  RememberInput,
+  RememberResult,
+} from "./memory-types";
+
+export class MemoryService {
+  private readonly deps: MemoryServiceDeps;
+
+  constructor(deps: MemoryServiceDeps) {
+    this.deps = deps;
+  }
+
+  /**
+   * Candidate pool: BM25 top-16 (any-term) within the scope intersection,
+   * current facts only. Similarity by cosine when semantic is ready, else by
+   * normalized-token Jaccard. Ordered by similarity desc, ties by recordId.
+   */
+  findCandidates(input: CandidateQuery): Promise<{
+    candidates: MemoryCandidate[];
+    matching: MemoryMatchDiagnostics;
+  }> {
+    return findMemoryCandidates(this.deps, input);
+  }
+
+  remember(input: RememberInput): Promise<RememberResult> {
+    return rememberFact(this.deps, input);
+  }
+
+  recall(input: RecallInput): Promise<RecallResult> {
+    return recallFacts(this.deps, input);
+  }
+}

package/src/ingestion/sync.ts

@@ -60,6 +60,7 @@ import {
   parseLinks,
   parseTargetParts,
 } from "../core/links";
+import { extractMemoryScopes } from "../core/memory-record";
 import { normalizeTag, validateTag } from "../core/tags";
 import { defaultChunker } from "./chunker";
 import {
@@ -1074,6 +1075,22 @@ export class SyncService {
           tagCount: extractedTags.length,
         });
 
+        // 13b. Index managed-memory scopes, memory-managed collections only.
+        // A record that passes the memory validator gets scope rows; a
+        // malformed file clears them and therefore drops out of managed
+        // recall while staying searchable.
+        if (collection.memoryManaged === true) {
+          const memoryScopes = extractMemoryScopes(artifact.markdown);
+          const scopesResult = await store.setDocMemoryScopes(
+            docId,
+            memoryScopes
+          );
+          mustOk(scopesResult, "setDocMemoryScopes", {
+            docId,
+            scopeCount: memoryScopes.length,
+          });
+        }
+
         // 14. Extract and store links (wiki and markdown links)
         const excludedRanges = getExcludedRanges(artifact.markdown);
         const lineOffsets = buildLineOffsets(artifact.markdown);

package/src/mcp/AGENTS.md

@@ -6,7 +6,13 @@ GNO's Model Context Protocol server for AI agent integration.
 
 ```
 src/mcp/
-├── server.ts          # MCP server setup, stdio transport
+├── server.ts          # MCP server setup (`gno mcp`)
+├── stdio-serving.ts   # Dual-era stdio entry (2025 initialize / 2026 discover)
+├── http-transport.ts  # Resident /mcp gateway: shared guards, era branch
+├── http-session.ts    # 2025-era stateful sessions
+├── http-modern.ts     # 2026-07-28 sessionless leg + modern request checks
+├── tool-profile.ts    # core|full profile allowlists + registrar
+├── tool-descriptions-core.ts # core-profile description micro-instructions
 ├── tools/             # Tool implementations
 │   ├── index.ts       # Tool registry
 │   ├── search.ts      # gno_search (BM25)

package/src/mcp/CLAUDE.md

@@ -6,7 +6,13 @@ GNO's Model Context Protocol server for AI agent integration.
 
 ```
 src/mcp/
-├── server.ts          # MCP server setup, stdio transport
+├── server.ts          # MCP server setup (`gno mcp`)
+├── stdio-serving.ts   # Dual-era stdio entry (2025 initialize / 2026 discover)
+├── http-transport.ts  # Resident /mcp gateway: shared guards, era branch
+├── http-session.ts    # 2025-era stateful sessions
+├── http-modern.ts     # 2026-07-28 sessionless leg + modern request checks
+├── tool-profile.ts    # core|full profile allowlists + registrar
+├── tool-descriptions-core.ts # core-profile description micro-instructions
 ├── tools/             # Tool implementations
 │   ├── index.ts       # Tool registry
 │   ├── search.ts      # gno_search (BM25)

package/src/mcp/context.ts

@@ -1,6 +1,6 @@
 /** Shared MCP surface and request-scoped runtime context. */
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 // node:async_hooks provides async-local request context; Bun has no separate native equivalent.
 import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -15,6 +15,7 @@ import type { ModelLease } from "../llm/nodeLlamaCpp/lifecycle";
 import type { ResidentStatus } from "../serve/status-model";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { StoreResult } from "../store/types";
+import type { McpToolProfile } from "./tool-profile";
 
 import { MCP_SERVER_NAME, VERSION } from "../app/constants";
 import { createStandaloneResidentStatus } from "../serve/resident-status";
@@ -57,6 +58,17 @@ export interface ToolContextSnapshot {
     caller: EgressCallerContext;
     authorizationEpoch?: { value: string };
   };
+  /**
+   * Opaque per-caller identity the HTTP boundary derived for this request.
+   * Set on both Streamable HTTP legs; the 2026-07-28 sessionless leg has no
+   * session id, so this is what keeps two modern callers apart.
+   */
+  requestIdentity?: string;
+}
+
+export interface RequestScope {
+  egress: NonNullable<ToolContextSnapshot["egress"]>;
+  requestIdentity?: string;
 }
 
 export interface ToolContext {
@@ -70,6 +82,8 @@ export interface ToolContext {
   serverInstanceId: string;
   writeLockPath: string;
   enableWrite: boolean;
+  /** Advertised tool set; `full` when absent. Narrows, never widens, the write gate. */
+  toolProfile?: McpToolProfile;
   isShuttingDown: () => boolean;
   getResidentStatus?: () => ResidentStatus;
   acquireModelLease?: () => ModelLease;
@@ -87,9 +101,12 @@ export interface ToolContext {
   advanceRequestAuthorizationEpoch?: (epoch: string) => void;
   getRequestAuthorizationEpoch?: () => string | undefined;
   getEgressContext?: () => ToolContextSnapshot["egress"];
+  /** Per-caller identity of the current request; absent on stdio. */
+  getRequestIdentity?: () => string | undefined;
   runWithEgressContext?<T>(
     egress: NonNullable<ToolContextSnapshot["egress"]>,
-    operation: () => Promise<T>
+    operation: () => Promise<T>,
+    scope?: Omit<RequestScope, "egress">
   ): Promise<T>;
   runWithSnapshot?<T>(operation: () => Promise<T>): Promise<T>;
 }
@@ -105,6 +122,7 @@ export interface CreateToolContextOptions {
   serverInstanceId: string;
   writeLockPath: string;
   enableWrite: boolean;
+  toolProfile?: McpToolProfile;
   isShuttingDown: () => boolean;
   getResidentStatus?: () => ResidentStatus;
   acquireModelLease?: () => ModelLease;
@@ -153,6 +171,7 @@ export function createToolContext(
     serverInstanceId: options.serverInstanceId,
     writeLockPath: options.writeLockPath,
     enableWrite: options.enableWrite,
+    toolProfile: options.toolProfile,
     isShuttingDown: options.isShuttingDown,
     getResidentStatus:
       options.getResidentStatus ??
@@ -169,23 +188,32 @@ export function createToolContext(
     getRequestAuthorizationEpoch: () =>
       requestSnapshot.getStore()?.egress?.authorizationEpoch?.value,
     getEgressContext: () => requestSnapshot.getStore()?.egress,
+    getRequestIdentity: () => requestSnapshot.getStore()?.requestIdentity,
     runWithEgressContext<T>(
       egress: NonNullable<ToolContextSnapshot["egress"]>,
-      operation: () => Promise<T>
+      operation: () => Promise<T>,
+      scope?: Omit<RequestScope, "egress">
     ): Promise<T> {
       const config = options.getConfig();
       return requestSnapshot.run(
-        { config, collections: config.collections, egress },
+        {
+          config,
+          collections: config.collections,
+          egress,
+          requestIdentity: scope?.requestIdentity,
+        },
         operation
       );
     },
     runWithSnapshot<T>(operation: () => Promise<T>): Promise<T> {
       const config = options.getConfig();
+      const current = requestSnapshot.getStore();
       return requestSnapshot.run(
         {
           config,
           collections: config.collections,
-          egress: requestSnapshot.getStore()?.egress,
+          egress: current?.egress,
+          requestIdentity: current?.requestIdentity,
         },
         operation
       );
@@ -201,10 +229,12 @@ export function createMcpServerSurface(
     version: VERSION,
   }
 ): McpServer {
+  // `listChanged: true` is the advertised 2025-11-25 contract pinned by
+  // test/fixtures/mcp/legacy-2025-11-25.json (SDK v1 always advertised it).
   const server = new McpServer(identity, {
     capabilities: {
-      tools: { listChanged: false },
-      resources: { subscribe: false, listChanged: false },
+      tools: { listChanged: true },
+      resources: { subscribe: false, listChanged: true },
     },
   });
   registerTools(server, context);

package/src/mcp/http-egress.ts

@@ -51,6 +51,8 @@ export const MCP_HTTP_EGRESS_TOOLS = {
   gno_multi_get: "source",
   gno_query: "snippet",
   gno_query_diagnose: "metadata",
+  gno_recall: "source",
+  gno_remember: "source",
   gno_remove_collection: "metadata",
   gno_rename_note: "metadata",
   gno_search: "snippet",

package/src/mcp/http-modern.ts

@@ -0,0 +1,214 @@
+/** 2026-07-28 (sessionless) leg of the resident Streamable HTTP transport. */
+
+import {
+  createMcpHandler,
+  isLegacyRequest,
+  type McpServer,
+  PROTOCOL_VERSION_META_KEY,
+} from "@modelcontextprotocol/server";
+
+import type { ToolContext } from "./context";
+
+export const MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
+export const MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
+/**
+ * The exact protocol revisions GNO speaks. Membership here is the only test a
+ * revision label passes; there is no ordering, so a future-dated or
+ * non-date label (`2027-01-01`, `abc`) is never treated as modern.
+ */
+export const MCP_SUPPORTED_PROTOCOL_REVISIONS: ReadonlySet<string> = new Set([
+  MCP_LEGACY_PROTOCOL_VERSION,
+  MCP_MODERN_PROTOCOL_VERSION,
+]);
+/** Revisions served by the sessionless leg. */
+const MCP_MODERN_PROTOCOL_REVISIONS: ReadonlySet<string> = new Set([
+  MCP_MODERN_PROTOCOL_VERSION,
+]);
+/**
+ * Modern methods the SDK serves as a long-lived stream. GNO wires no change
+ * event source to them, and a stream that never ends would pin a capacity
+ * slot and an admission handle for the life of the connection, so they are
+ * refused before the SDK handler is reached.
+ */
+const MCP_UNSUPPORTED_MODERN_STREAM_METHODS: ReadonlySet<string> = new Set([
+  "subscriptions/listen",
+]);
+const MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+const MCP_SESSION_HEADER = "mcp-session-id";
+/** SEP-2243 `HeaderMismatch`: the standard headers and the body disagree. */
+const HEADER_MISMATCH_ERROR_CODE = -32_020;
+const INVALID_REQUEST_ERROR_CODE = -32_600;
+const METHOD_NOT_FOUND_ERROR_CODE = -32_601;
+const SERVER_ERROR_CODE = -32_000;
+/** The 2026-07-28 HTTP ladder answers a pre-dispatch method-not-found with 404. */
+const METHOD_NOT_FOUND_HTTP_STATUS = 404;
+
+export interface ModernMcpHandler {
+  fetch(request: Request, parsedBody: unknown): Promise<Response>;
+  close(): Promise<void>;
+}
+
+function jsonRpcError(
+  status: number,
+  code: number,
+  message: string,
+  data?: unknown,
+  id: string | number | null = null
+): Response {
+  return Response.json(
+    {
+      jsonrpc: "2.0",
+      error: { code, message, ...(data === undefined ? {} : { data }) },
+      id,
+    },
+    { status }
+  );
+}
+
+function jsonRpcMessages(parsedBody: unknown): unknown[] {
+  return Array.isArray(parsedBody) ? parsedBody : [parsedBody];
+}
+
+function methodOf(message: unknown): string | undefined {
+  if (typeof message !== "object" || message === null) return undefined;
+  const { method } = message as { method?: unknown };
+  return typeof method === "string" ? method : undefined;
+}
+
+function echoableId(message: unknown): string | number | null {
+  if (typeof message !== "object" || message === null) return null;
+  const { id } = message as { id?: unknown };
+  return typeof id === "string" || typeof id === "number" ? id : null;
+}
+
+function carriesEnvelopeClaim(message: unknown): boolean {
+  if (typeof message !== "object" || message === null) return false;
+  const meta = (message as { params?: { _meta?: unknown } }).params?._meta;
+  return (
+    typeof meta === "object" &&
+    meta !== null &&
+    PROTOCOL_VERSION_META_KEY in meta
+  );
+}
+
+function namesModernRevision(request: Request): boolean {
+  const header = request.headers.get(MCP_PROTOCOL_VERSION_HEADER);
+  return header !== null && MCP_MODERN_PROTOCOL_REVISIONS.has(header);
+}
+
+/**
+ * Whether the transport routes this request to the 2026-07-28 sessionless
+ * leg instead of the 2025-era session path.
+ *
+ * The SDK's own classifier decides legacy-ness so the branch can never
+ * disagree with `createMcpHandler`. Only a request that actually claims the
+ * modern era - a per-request `_meta` envelope claim (well-formed or not), or
+ * an `MCP-Protocol-Version` header naming a modern revision - is served
+ * modern; a body the classifier rejects without any such claim keeps the
+ * legacy path's established error answers. Body-less methods (GET, DELETE)
+ * are 2025 session operations and always legacy; the modern era has no
+ * sessions.
+ */
+export async function isModernMcpRequest(
+  request: Request,
+  parsedBody: unknown
+): Promise<boolean> {
+  if (request.method !== "POST") return false;
+  if (await isLegacyRequest(request, parsedBody)) return false;
+  return (
+    jsonRpcMessages(parsedBody).some(carriesEnvelopeClaim) ||
+    namesModernRevision(request)
+  );
+}
+
+/**
+ * Refuse a modern request for a method the SDK would serve as a long-lived
+ * stream (`subscriptions/listen`). The answer is the 2026-07-28 ladder's
+ * pre-dispatch method-not-found (`404`, `-32601`) with the request id echoed,
+ * so the client learns the method is absent here rather than waiting on a
+ * stream that would never carry an event. The check runs before dispatch and
+ * releases nothing itself: the caller finishes the request like any other
+ * rejection, so no capacity slot or admission handle outlives the answer.
+ */
+export function rejectUnsupportedModernStream(
+  parsedBody: unknown
+): Response | undefined {
+  const message = jsonRpcMessages(parsedBody).find((candidate) => {
+    const method = methodOf(candidate);
+    return (
+      method !== undefined && MCP_UNSUPPORTED_MODERN_STREAM_METHODS.has(method)
+    );
+  });
+  if (message === undefined) return undefined;
+  const method = methodOf(message) ?? "";
+  return jsonRpcError(
+    METHOD_NOT_FOUND_HTTP_STATUS,
+    METHOD_NOT_FOUND_ERROR_CODE,
+    `Method not found: ${method} is not served by this endpoint; GNO change events are not wired to subscription streams`,
+    { method },
+    echoableId(message)
+  );
+}
+
+/**
+ * GNO-owned pre-dispatch checks for a modern-classified request.
+ *
+ * - A POST that is not `application/json` is refused with 415, as the
+ *   session transport refuses it, before the SDK's modern leg sees it.
+ * - The 2026-07-28 Streamable HTTP binding requires `MCP-Protocol-Version`
+ *   on every request; a modern envelope without the header is refused, never
+ *   served from the body claim alone.
+ * - Sessions are 2025-era state. A modern request that names one is a
+ *   protocol confusion and is rejected before it can touch another
+ *   identity's session.
+ */
+export function rejectMalformedModernRequest(
+  request: Request
+): Response | undefined {
+  if (!request.headers.get("content-type")?.includes("application/json")) {
+    return jsonRpcError(
+      415,
+      SERVER_ERROR_CODE,
+      "Unsupported Media Type: Content-Type must be application/json"
+    );
+  }
+  if (request.headers.has(MCP_SESSION_HEADER)) {
+    return jsonRpcError(
+      400,
+      INVALID_REQUEST_ERROR_CODE,
+      `Bad Request: Mcp-Session-Id is not valid on a ${MCP_MODERN_PROTOCOL_VERSION} request; sessions are 2025-era only`
+    );
+  }
+  if (!request.headers.has(MCP_PROTOCOL_VERSION_HEADER)) {
+    const body = `the body envelope claims protocol revision ${MCP_MODERN_PROTOCOL_VERSION} but the required MCP-Protocol-Version header is absent`;
+    return jsonRpcError(
+      400,
+      HEADER_MISMATCH_ERROR_CODE,
+      `Bad Request: the request headers and body disagree: ${body}`,
+      { mismatch: { header: "(missing)", body } }
+    );
+  }
+  return undefined;
+}
+
+/**
+ * Sessionless per-request serving for 2026-07-28 clients.
+ *
+ * Strictly modern (`legacy: "reject"`): every 2025-era request is routed to
+ * the stateful session transport before this handler is reached, so a legacy
+ * `initialize` can never negotiate a 2026 era here. The factory builds one
+ * surface per request from the shared runtime context, so profile, write
+ * gate, and egress context are the same objects the session path uses.
+ */
+export function createModernMcpHandler(
+  context: ToolContext,
+  createServer: (context: ToolContext) => McpServer
+): ModernMcpHandler {
+  const handler = createMcpHandler(() => createServer(context), {
+    legacy: "reject",
+  });
+  return {
+    fetch: (request, parsedBody) => handler.fetch(request, { parsedBody }),
+    close: () => handler.close(),
+  };
+}

package/src/mcp/http-security.ts

@@ -11,6 +11,7 @@ import {
   classifyBindDestination,
   classifyDestination,
 } from "../core/destination-classifier";
+import { DEFAULT_MCP_TOOL_PROFILE, type McpToolProfile } from "./tool-profile";
 
 export const DEFAULT_HTTP_GATEWAY_HOST = "127.0.0.1";
 export const DEFAULT_HTTP_GATEWAY_PORT = 3000;
@@ -39,6 +40,7 @@ export interface ResolvedHttpGatewayConfig {
   allowedHosts: readonly string[];
   allowedOrigins: readonly string[];
   enableWrite: boolean;
+  toolProfile: McpToolProfile;
   limits: {
     maxBodyBytes: number;
     maxRequestsPerMinute: number;
@@ -56,6 +58,7 @@ export interface HttpGatewayOverrides {
   allowedHosts?: string[];
   allowedOrigins?: string[];
   enableWrite?: boolean;
+  toolProfile?: McpToolProfile;
 }
 
 export interface AuthorizedHttpMcpRequest {
@@ -178,6 +181,8 @@ export function resolveHttpGatewayConfig(
       config?.allowedOrigins ??
       defaultAllowedOrigins(host, port),
     enableWrite: overrides.enableWrite ?? config?.enableWrite ?? false,
+    toolProfile:
+      overrides.toolProfile ?? config?.toolProfile ?? DEFAULT_MCP_TOOL_PROFILE,
     limits: {
       maxBodyBytes:
         config?.limits?.maxBodyBytes ?? DEFAULT_HTTP_MCP_MAX_BODY_BYTES,

package/src/mcp/http-session.ts

@@ -1,8 +1,9 @@
 /** Isolated stateful MCP server/transport ownership for HTTP sessions. */
 
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import {
+  type McpServer,
+  WebStandardStreamableHTTPServerTransport,
+} from "@modelcontextprotocol/server";
 
 import type { ToolContext } from "./context";