@remnic/core 9.69.37 → 9.69.39

package/src/access-http.test.ts

@@ -4058,6 +4058,84 @@ test("PR #1852: token rotation between authorization and write does not stamp th
   }
 });
 
+test("issue #2829: memory_store category aliases canonicalize with a retained spelling; near-misses 400", async () => {
+  const captured: Array<Record<string, unknown>> = [];
+  const service = {
+    memoryStore: (req: Record<string, unknown>) => {
+      captured.push(req);
+      return Promise.resolve({
+        schemaVersion: 1,
+        operation: "memory_store",
+        namespace: "default",
+        dryRun: false,
+        accepted: true,
+        queued: false,
+        status: "stored",
+      });
+    },
+    suggestionSubmit: (req: Record<string, unknown>) => {
+      captured.push(req);
+      return Promise.resolve({
+        schemaVersion: 1,
+        operation: "suggestion_submit",
+        namespace: "default",
+        dryRun: false,
+        accepted: true,
+        queued: true,
+        status: "queued_for_review",
+      });
+    },
+  } as unknown as EngramAccessService;
+
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  try {
+    const post = (pathname: string, body: unknown) =>
+      fetch(`http://127.0.0.1:${status.port}${pathname}`, {
+        method: "POST",
+        headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+        body: JSON.stringify(body),
+      });
+
+    const aliased = await post("/engram/v1/memories", {
+      content: "alias over http",
+      category: "project_state",
+    });
+    assert.equal(aliased.status, 201);
+    assert.equal(captured[0]?.category, "fact", "HTTP memory_store must canonicalize the alias");
+    assert.equal(captured[0]?.rawCategory, "project_state", "HTTP memory_store must retain the spelling");
+
+    const suggested = await post("/engram/v1/suggestions", {
+      content: "alias over http suggestion",
+      category: "project_update",
+    });
+    assert.equal(suggested.status, 201);
+    assert.equal(captured[1]?.category, "fact");
+    assert.equal(captured[1]?.rawCategory, "project_update", "the suggestions route forwards the retained spelling");
+
+    const nearMiss = await post("/engram/v1/memories", {
+      content: "near miss over http",
+      category: "projection",
+    });
+    assert.equal(nearMiss.status, 400, "a near-miss category must reject");
+    const nearMissBody = (await nearMiss.json()) as {
+      error?: string;
+      details?: Array<{ field: string; message: string }>;
+    };
+    const categoryDetail = nearMissBody.details?.find((detail) => detail.field === "category");
+    assert.ok(categoryDetail, "the 400 must name the category field");
+    assert.match(categoryDetail.message, /one of: fact/, "the 400 must list valid options");
+    assert.equal(captured.length, 2, "the near-miss must not dispatch");
+  } finally {
+    await server.stop();
+  }
+});
+
 test("PR #1852: static operator token has no connector provenance under rotation", async () => {
   // An operator-supplied static token must never acquire connector provenance,
   // even when an entries getter is also configured and the static token
@@ -5003,6 +5081,177 @@ test("HTTP authorization probe verifies requested operation grants without invok
   }
 });
 
+test("HTTP authorization probe fails closed for transformed suggestion/memory schemas (#2866)", async () => {
+  const service = {
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-write-authorization-probe",
+      defaultNamespace: "default",
+    }),
+    memoryStore: () => {
+      throw new Error("authorization probe must not invoke memory_store");
+    },
+    suggestionSubmit: () => {
+      throw new Error("authorization probe must not invoke suggestion_submit");
+    },
+  } as unknown as EngramAccessService;
+  const writeOperations = ["memory_store", "suggestion_submit"] as const;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authTokenEntriesGetter: () => [
+      {
+        token: "scoped-write-token",
+        capabilities: {
+          version: 1,
+          ops: [...writeOperations],
+          namespaces: ["other"],
+        },
+      },
+    ],
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  const probe = (operation: string, namespace?: string) => {
+    const query = new URLSearchParams({ op: operation });
+    if (namespace !== undefined) query.set("namespace", namespace);
+    return fetch(`http://127.0.0.1:${status.port}/engram/v1/authorization?${query}`, {
+      headers: { authorization: "Bearer scoped-write-token" },
+    });
+  };
+  try {
+    for (const operation of writeOperations) {
+      const missing = await probe(operation);
+      assert.equal(
+        missing.status,
+        403,
+        `${operation} probe must deny the missing/default namespace`,
+      );
+      await missing.text();
+
+      const wrong = await probe(operation, "default");
+      assert.equal(
+        wrong.status,
+        403,
+        `${operation} probe must deny a namespace outside the token scope`,
+      );
+      await wrong.text();
+
+      const allowed = await probe(operation, "other");
+      assert.equal(allowed.status, 200, `${operation} probe must allow the scoped namespace`);
+      assert.deepEqual(await allowed.json(), {
+        authorized: true,
+        operations: [operation],
+      });
+    }
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP-MCP tools/call fails closed for memory_store/suggestion_submit aliases (#2866)", async () => {
+  const calls: Array<{ op: string; args: Record<string, unknown> }> = [];
+  const service = {
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-write-authorization-probe",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
+    memoryStore: async (args: Record<string, unknown>) => {
+      calls.push({ op: "memory_store", args });
+      return {
+        schemaVersion: 1,
+        operation: "memory_store",
+        namespace: args.namespace ?? "default",
+        dryRun: true,
+        accepted: true,
+        queued: false,
+        status: "validated",
+      };
+    },
+    suggestionSubmit: async (args: Record<string, unknown>) => {
+      calls.push({ op: "suggestion_submit", args });
+      return {
+        schemaVersion: 1,
+        operation: "suggestion_submit",
+        namespace: args.namespace ?? "default",
+        dryRun: true,
+        accepted: true,
+        queued: false,
+        status: "validated",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authTokenEntriesGetter: () => [
+      {
+        token: "scoped-write-token",
+        capabilities: {
+          version: 1,
+          ops: ["memory_store", "suggestion_submit"],
+          namespaces: ["ns_a"],
+        },
+      },
+    ],
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  const mcpCall = (name: string, args: Record<string, unknown>) =>
+    fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer scoped-write-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name, arguments: args },
+      }),
+    });
+  const aliases = [
+    "engram.memory_store",
+    "remnic.memory_store",
+    "engram.suggestion_submit",
+    "remnic.suggestion_submit",
+  ] as const;
+  try {
+    for (const name of aliases) {
+      const wrong = await mcpCall(name, {
+        content: "aliased write",
+        category: "project_state",
+        namespace: "ns_b",
+        dryRun: true,
+      });
+      assert.equal(wrong.status, 403, `${name} must deny a namespace outside the token scope`);
+      await wrong.text();
+
+      const missing = await mcpCall(name, {
+        content: "aliased write",
+        category: "project_update",
+        dryRun: true,
+      });
+      assert.equal(missing.status, 403, `${name} must deny the missing/default namespace`);
+      await missing.text();
+    }
+    assert.equal(calls.length, 0, "denied MCP writes must not reach the handler");
+
+    const allowed = await mcpCall("engram.memory_store", {
+      content: "aliased write",
+      category: "project",
+      namespace: "ns_a",
+      dryRun: true,
+    });
+    assert.notEqual(allowed.status, 403, "the allowed namespace must proceed past the gate");
+    assert.equal(calls.at(-1)?.op, "memory_store");
+    assert.equal(calls.at(-1)?.args.namespace, "ns_a");
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP authorization probe checks the principal-derived support passport namespace", async () => {
   let namespaceResolutions = 0;
   const service = {

package/src/access-http.ts

@@ -2118,6 +2118,8 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         sourceReason: body.sourceReason,
         cwd: body.cwd,
         projectTag: body.projectTag,
+        // #2829: raw alias spelling retained by the schema transform.
+        ...(body.rawCategory !== undefined ? { rawCategory: body.rawCategory } : {}),
         // Phase 1 provenance: server-resolved connector identity from the
         // bearer token (REST path, mirroring the MCP tools/call dispatch).
         sourceConnector: this.resolveConnector(req),

package/src/access-mcp.test.ts

@@ -307,8 +307,8 @@ test("MCP memory write tools admit project-shaped category aliases (#2780)", asy
     assert.equal(result?.isError, false, `${toolName} must admit project-shaped category aliases`);
     assert.equal(
       received?.category,
-      "project_state",
-      `${toolName} must forward the alias; the write surface coerces it to "fact"`
+      "fact",
+      `${toolName} must dispatch the schema-canonicalized category`
     );
   }
 });

package/src/access-observe-write-category.ts

@@ -0,0 +1,25 @@
+/**
+ * Category-alias split + replay restamp for observe/write (#2829).
+ * Extracted from access-observe-write-surface.ts to stay under the 1200-line cap.
+ *
+ * The wire schema already maps an alias to "fact". `rawCategory` is the
+ * caller's spelling: it must not reach the write candidate or fingerprint,
+ * and a replay must rebuild the note from THIS request's spelling.
+ */
+import {
+  categoryAliasCoercion,
+  reapplyCategoryCoercion,
+  type CategoryAliasCoercion,
+} from "./access-schema.js";
+
+export { reapplyCategoryCoercion };
+
+export function splitCanonicalWriteRequest<T extends { rawCategory?: string }>(
+  request: T,
+): {
+  canonical: Omit<T, "rawCategory">;
+  categoryCoercion: CategoryAliasCoercion | undefined;
+} {
+  const { rawCategory, ...canonical } = request;
+  return { canonical, categoryCoercion: categoryAliasCoercion(rawCategory) };
+}

package/src/access-observe-write-surface.ts

@@ -29,8 +29,8 @@ import {
   type MemoryScopePlan,
   NamespaceNotWritableError,
 } from "./access-service.js";
+import { reapplyCategoryCoercion, splitCanonicalWriteRequest } from "./access-observe-write-category.js";
 import { extractionForceFlush } from "./access-extraction-force-flush.js";
-import { coerceProjectCategoryAlias, reapplyCategoryCoercion } from "./access-schema.js";
 import { ObserveTranscriptPersister, observeTranscriptSessionKey } from "./access-observe-transcript.js";
 import { FileCalendarSource, buildBriefing, parseBriefingFocus, parseBriefingWindow } from "./briefing.js";
 import {
@@ -486,30 +486,30 @@ export class AccessObserveWriteSurface {
     rawRequest: EngramAccessMemoryStoreRequest,
     hooks?: { enforceWriteQuota?: () => void | Promise<void> }
   ): Promise<EngramAccessWriteResponse> {
-    // #2780: the boundary schema admits project-shaped category guesses;
-    // this funnel (MCP/HTTP/CLI all dispatch here) coerces them to the
-    // canonical "fact" once and reports the coercion on the response.
-    const { request, categoryCoercion } = coerceProjectCategoryAlias(rawRequest);
+    const request = rawRequest;
+    const { canonical, categoryCoercion } = splitCanonicalWriteRequest(request);
     let namespace: string;
     try {
-      namespace = await this.deps.resolveCodingScopedWriteNamespace(request);
+      namespace = await this.deps.resolveCodingScopedWriteNamespace(canonical);
     } catch (err) {
       // A dry run is a no-persist validation, and a replay re-submit sets
       // suppressQuarantine so a still-unwritable target propagates instead of
-      // re-parking (issue #1888): never dead-letter either.
+      // re-parking (issue #1888): never dead-letter either. Park the FULL
+      // request (rawCategory included) so quarantine replay can re-report the
+      // alias coercion (Codex review, PR #2826).
       if (request.dryRun !== true && request.suppressQuarantine !== true) {
         await this.parkRejectedWrite(err, "memory_store", request);
       }
       throw err;
     }
-    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    const schemaVersion = canonical.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
     if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
       throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
     }
     const execute = async (): Promise<EngramAccessWriteResponse> => {
-      const candidate = this.deps.validateWriteCandidate(request, namespace);
-      if (request.dryRun === true) {
-        return {
+      const candidate = this.deps.validateWriteCandidate(canonical, namespace);
+      if (canonical.dryRun === true) {
+        return reapplyCategoryCoercion<EngramAccessWriteResponse>({
           schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
           operation: "memory_store",
           namespace,
@@ -517,9 +517,8 @@ export class AccessObserveWriteSurface {
           accepted: true,
           queued: false,
           status: "validated",
-          idempotencyKey: request.idempotencyKey?.trim() || undefined,
-          ...(categoryCoercion ? { categoryCoercion } : {}),
-        };
+          idempotencyKey: canonical.idempotencyKey?.trim() || undefined,
+        }, categoryCoercion);
       }
       const result = await persistExplicitCapture(this.deps.orchestrator, candidate, "memory_store");
       // Seed the session's coding binding ONLY after a real write commits, and
@@ -529,12 +528,12 @@ export class AccessObserveWriteSurface {
       // but never binds the session on a dryRun, replay/conflict, quota
       // rejection, or an explicit-namespace write (which bypasses the overlay),
       // since those don't reach this point or aren't project-scoped (Codex review).
-      await this.deps.attachCodingContextAfterScopedWrite(request);
+      await this.deps.attachCodingContextAfterScopedWrite(canonical);
       // #1645 (review thread yG-): a tombstone-blocked capture is pending_review
       // (no active copy) — report it as queued_for_review so the HTTP/MCP caller
       // doesn't read it as a successfully stored active memory.
       const blocked = result.tombstoneBlocked === true && result.duplicateOf === undefined;
-      const response: EngramAccessWriteResponse = {
+      const response = reapplyCategoryCoercion<EngramAccessWriteResponse>({
         schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
         operation: "memory_store",
         namespace,
@@ -544,9 +543,8 @@ export class AccessObserveWriteSurface {
         status: blocked ? "queued_for_review" : result.duplicateOf ? "duplicate" : "stored",
         memoryId: result.id,
         duplicateOf: result.duplicateOf,
-        idempotencyKey: request.idempotencyKey?.trim() || undefined,
-        ...(categoryCoercion ? { categoryCoercion } : {}),
-      };
+        idempotencyKey: canonical.idempotencyKey?.trim() || undefined,
+      }, categoryCoercion);
       log.info(
         `access-write op=memory_store namespace=${namespace} dryRun=false status=${response.status} memoryId=${response.memoryId ?? "-"} idempotency=${response.idempotencyKey ? "yes" : "no"}`
       );
@@ -554,22 +552,24 @@ export class AccessObserveWriteSurface {
     };
     const response = await this.deps.handleIdempotentWrite({
       operation: "memory_store",
-      idempotencyKey: request.idempotencyKey,
+      idempotencyKey: canonical.idempotencyKey,
       // Shared builder (issue #1989 PR3): byte-parity with the historical
       // inline literal is asserted by access-fingerprint-parity.test.ts.
+      // Fingerprints the CANONICAL category, so `fact` and an alias spelling
+      // under one idempotency key are the same request (#2829).
       requestFingerprint: buildAccessWriteRequestFingerprint({
         schemaVersion,
         namespace,
-        content: request.content,
-        category: request.category,
-        confidence: request.confidence,
-        tags: request.tags,
-        entityRef: request.entityRef,
-        ttl: request.ttl,
-        sourceReason: request.sourceReason,
-        sourceConnector: request.sourceConnector,
+        content: canonical.content,
+        category: canonical.category,
+        confidence: canonical.confidence,
+        tags: canonical.tags,
+        entityRef: canonical.entityRef,
+        ttl: canonical.ttl,
+        sourceReason: canonical.sourceReason,
+        sourceConnector: canonical.sourceConnector,
       }),
-      skip: request.dryRun === true,
+      skip: canonical.dryRun === true,
       beforeExecute: hooks?.enforceWriteQuota,
       execute,
     });
@@ -581,27 +581,29 @@ export class AccessObserveWriteSurface {
     rawRequest: EngramAccessSuggestionSubmitRequest,
     hooks?: { enforceWriteQuota?: () => void | Promise<void> }
   ): Promise<EngramAccessWriteResponse> {
-    // #2780: same alias funnel as memory_store — one shared coercion point.
-    const { request, categoryCoercion } = coerceProjectCategoryAlias(rawRequest);
+    const request = rawRequest;
+    const { canonical, categoryCoercion } = splitCanonicalWriteRequest(request);
     let namespace: string;
     try {
-      namespace = await this.deps.resolveCodingScopedWriteNamespace(request);
+      namespace = await this.deps.resolveCodingScopedWriteNamespace(canonical);
     } catch (err) {
       // A dry run never persists, and a replay re-submit sets suppressQuarantine
       // so a still-unwritable target propagates instead of re-parking (#1888).
+      // Park the FULL request (rawCategory included) so quarantine replay can
+      // re-report the alias coercion.
       if (request.dryRun !== true && request.suppressQuarantine !== true) {
         await this.parkRejectedWrite(err, "suggestion_submit", request);
       }
       throw err;
     }
-    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    const schemaVersion = canonical.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
     if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
       throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
     }
     const execute = async (): Promise<EngramAccessWriteResponse> => {
-      const candidate = this.deps.validateWriteCandidate(request, namespace);
-      if (request.dryRun === true) {
-        return {
+      const candidate = this.deps.validateWriteCandidate(canonical, namespace);
+      if (canonical.dryRun === true) {
+        return reapplyCategoryCoercion<EngramAccessWriteResponse>({
           schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
           operation: "suggestion_submit",
           namespace,
@@ -609,21 +611,20 @@ export class AccessObserveWriteSurface {
           accepted: true,
           queued: true,
           status: "validated",
-          idempotencyKey: request.idempotencyKey?.trim() || undefined,
-          ...(categoryCoercion ? { categoryCoercion } : {}),
-        };
+          idempotencyKey: canonical.idempotencyKey?.trim() || undefined,
+        }, categoryCoercion);
       }
       const result = await queueExplicitCaptureForReview(
         this.deps.orchestrator,
         candidate,
         "suggestion_submit",
-        new Error(request.sourceReason?.trim() || "submitted via engram suggestion_submit")
+        new Error(canonical.sourceReason?.trim() || "submitted via engram suggestion_submit")
       );
       // Seed the session binding only after a real, project-scoped submit commits
       // (mirrors memory_store / recall; skips dryRun, replay, quota-reject, and
       // explicit-namespace writes — Codex review).
-      await this.deps.attachCodingContextAfterScopedWrite(request);
-      const response: EngramAccessWriteResponse = {
+      await this.deps.attachCodingContextAfterScopedWrite(canonical);
+      const response = reapplyCategoryCoercion<EngramAccessWriteResponse>({
         schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
         operation: "suggestion_submit",
         namespace,
@@ -633,37 +634,37 @@ export class AccessObserveWriteSurface {
         status: "queued_for_review",
         memoryId: result.id,
         duplicateOf: result.duplicateOf,
-        idempotencyKey: request.idempotencyKey?.trim() || undefined,
-        ...(categoryCoercion ? { categoryCoercion } : {}),
-      };
+        idempotencyKey: canonical.idempotencyKey?.trim() || undefined,
+      }, categoryCoercion);
       log.info(
         `access-write op=suggestion_submit namespace=${namespace} dryRun=false status=${response.status} memoryId=${response.memoryId ?? "-"} idempotency=${response.idempotencyKey ? "yes" : "no"}`
       );
       return response;
     };
-    const replayed = await this.deps.handleIdempotentWrite({
+    const response = await this.deps.handleIdempotentWrite({
       operation: "suggestion_submit",
-      idempotencyKey: request.idempotencyKey,
+      idempotencyKey: canonical.idempotencyKey,
       // Shared builder (issue #1989 PR3): byte-parity with the historical
       // inline literal is asserted by access-fingerprint-parity.test.ts.
+      // Fingerprints the CANONICAL category (#2829).
       requestFingerprint: buildAccessWriteRequestFingerprint({
         schemaVersion,
         namespace,
-        content: request.content,
-        category: request.category,
-        confidence: request.confidence,
-        tags: request.tags,
-        entityRef: request.entityRef,
-        ttl: request.ttl,
-        sourceReason: request.sourceReason,
-        sourceConnector: request.sourceConnector,
+        content: canonical.content,
+        category: canonical.category,
+        confidence: canonical.confidence,
+        tags: canonical.tags,
+        entityRef: canonical.entityRef,
+        ttl: canonical.ttl,
+        sourceReason: canonical.sourceReason,
+        sourceConnector: canonical.sourceConnector,
       }),
-      skip: request.dryRun === true,
+      skip: canonical.dryRun === true,
       beforeExecute: hooks?.enforceWriteQuota,
       execute,
     });
     // #2780 fix B: rewrite a replayed coercion note from THIS request's raw category.
-    return reapplyCategoryCoercion(replayed, categoryCoercion);
+    return reapplyCategoryCoercion(response, categoryCoercion);
   }
 
   async runObserve(request: EngramAccessObserveRequest): Promise<EngramAccessObserveResponse> {

package/src/access-operations-batch.ts

@@ -15,7 +15,14 @@ import type { DreamsPhase, RecallDisclosure, RecallPlanMode } from "./types.js";
 import type { RemnicChatGptMemoryInspectorInput } from "./mcp-memory-inspector-app.js";
 import { defineOperation } from "./access-boundary.js";
 import { EngramAccessForbiddenError } from "./access-errors.js";
-import { type ObserveRequest, observeRequestSchema, type RecallRequest, recallRequestSchema } from "./access-schema.js";
+import {
+  type ObserveRequest,
+  observeRequestSchema,
+  type RecallRequest,
+  recallRequestSchema,
+  retainedCategoryAlias,
+  suggestionSubmitRequestSchema,
+} from "./access-schema.js";
 import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
 import { enforceNamespaceAllowList, tokenCapabilityStore } from "./access-token-capabilities.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
@@ -227,7 +234,26 @@ defineOperation({ name: "procedure_library_maintenance", description: "Run proce
 
 // === MEMORY/ENTITY/OBSERVE/LCM ===
 defineOperation({ name: "memory_timeline", description: "Memory timeline.", schema: strictSchema({ memoryId: S.str, namespace: S.str, limit: S.num }), handler: async (input, ctx) => ({ result: await ctx.service.memoryTimeline(optStr(input.memoryId) ?? "", optStr(input.namespace), optNum(input.limit) ?? 200, ctx.authenticatedPrincipal) }) });
-defineOperation({ name: "suggestion_submit", description: "Submit suggestion.", schema: strictSchema({ schemaVersion: S.num, idempotencyKey: S.str, dryRun: S.bool, sessionKey: S.str, content: S.str, category: S.str, confidence: S.num, namespace: S.str, tags: S.strArr, entityRef: S.str, ttl: S.str, sourceReason: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.suggestionSubmit({ schemaVersion: optNum(input.schemaVersion), idempotencyKey: optStr(input.idempotencyKey), dryRun: input.dryRun === true, sessionKey: optStr(input.sessionKey), authenticatedPrincipal: ctx.authenticatedPrincipal, ...(ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {}), content: optStr(input.content) ?? "", category: optStr(input.category), confidence: optNum(input.confidence), namespace: optStr(input.namespace), tags: optStrArr(input.tags), entityRef: optStr(input.entityRef), ttl: optStr(input.ttl), sourceReason: optStr(input.sourceReason), cwd: optStr(input.cwd), projectTag: optStr(input.projectTag) }) }) });
+// Issue #2482/#2829: suggestion_submit validates through the canonical
+// suggestionSubmitRequestSchema — the SAME schema the HTTP transport and the
+// MCP wire parse use, category alias transform included. The raw spelling
+// survives on `ctx.rawInput` for the coercion note.
+defineOperation({
+  name: "suggestion_submit",
+  description: "Submit suggestion.",
+  schema: z.preprocess((data) => stripNullsExcept(data, ["codingContext"]), suggestionSubmitRequestSchema),
+  handler: async (input, ctx) => {
+    const rawCategory = retainedCategoryAlias(ctx.rawInput);
+    return {
+      result: await ctx.service.suggestionSubmit({
+        ...input,
+        authenticatedPrincipal: ctx.authenticatedPrincipal,
+        ...(ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {}),
+        ...(rawCategory ? { rawCategory } : {}),
+      }),
+    };
+  },
+});
 defineOperation({ name: "entity_get", description: "Get entity.", schema: strictSchema({ name: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.entityGet(optStr(input.name) ?? "", optStr(input.namespace)) }) });
 defineOperation({ name: "review_queue_list", description: "List review queue.", schema: strictSchema({ runId: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.reviewQueue(optStr(input.runId) ?? "", optStr(input.namespace), ctx.authenticatedPrincipal) }) });
 // Issue #2482: observe validates through the canonical observeRequestSchema

package/src/access-operations.ts

@@ -15,7 +15,7 @@
 import { z } from "zod";
 
 import { defineOperation } from "./access-boundary.js";
-import { memoryStoreRequestSchema, type MemoryStoreRequest } from "./access-schema.js";
+import { memoryStoreRequestSchema, retainedCategoryAlias, type MemoryStoreRequest } from "./access-schema.js";
 import { EngramAccessInputError } from "./access-service.js";
 import { CorrectionContractError } from "./correction/correction-contract.js";
 import { externalWikiSearchOperation } from "./external-wiki-access.js";
@@ -154,16 +154,18 @@ export interface MemoryStoreOutput {
 export const memoryStoreOperation = defineOperation<MemoryStoreInput, MemoryStoreOutput>({
   name: "memory_store",
   description: "Store an explicit memory through the access layer.",
-  // Reuse the existing schema verbatim — the migration is behavior-preserving;
-  // the schema's external contract is NOT changing in this PR (per the issue's
-  // pitfall note).
+  // The canonical wire schema (issue #2482): its category transform already
+  // mapped compat aliases to "fact", so `input.category` is finite here. The
+  // raw spelling survives on `ctx.rawInput` for the coercion note (#2829).
   schema: memoryStoreRequestSchema,
   handler: async (input, ctx) => {
+    const rawCategory = retainedCategoryAlias(ctx.rawInput);
     const result = await ctx.service.memoryStore(
       {
         ...input,
         authenticatedPrincipal: ctx.authenticatedPrincipal,
         ...(ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {}),
+        ...(rawCategory ? { rawCategory } : {}),
       },
       // Forward transport-level hooks (e.g. HTTP's atomic write-quota gate)
       // so the hook still fires inside the service's idempotent-write lock —