@remnic/core 9.69.32 → 9.69.34

package/dist/who-knows.js

@@ -9,35 +9,36 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-EZZV7OQL.js";
-import "./chunk-GVG3JYBI.js";
-import "./chunk-UHVXE24Y.js";
+} from "./chunk-UEZKN6VR.js";
+import "./chunk-ZMKYCFJ7.js";
 import "./chunk-46WM6JX2.js";
+import "./chunk-UHVXE24Y.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-FHQSPTPZ.js";
-import "./chunk-7VJXIDOC.js";
+import "./chunk-6YAIN5XJ.js";
+import "./chunk-4JVQRFZD.js";
+import "./chunk-TNSCIPBQ.js";
 import "./chunk-YQNNHLCG.js";
 import "./chunk-6KTXE6A3.js";
-import "./chunk-PSPABFN2.js";
-import "./chunk-MKWKYHXJ.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-ZNJSBIP4.js";
-import "./chunk-GUMZC2BO.js";
+import "./chunk-BD7JTBYP.js";
+import "./chunk-OB3XMWX5.js";
 import "./chunk-4O6WRBGE.js";
-import "./chunk-LEPOP46W.js";
+import "./chunk-GUMZC2BO.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-TFA6HPOA.js";
+import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
-import "./chunk-ET356KSB.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-SO7SV523.js";
+import "./chunk-PCEYGOSL.js";
+import "./chunk-Q6LCCIZN.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
-import "./chunk-DCJ3YFIC.js";
+import "./chunk-S2ULTQZR.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-H272ZPQ3.js";
+import "./chunk-SHEHQBCG.js";
 import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-5GINB5LC.js";
@@ -49,24 +50,21 @@ import "./chunk-RBOJCG4T.js";
 import "./chunk-R7QY5ZVB.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-DBQWVT2H.js";
+import "./chunk-3CBI2ZSA.js";
 import "./chunk-JXN77SGO.js";
 import "./chunk-ZLQ37WJX.js";
 import "./chunk-IUM3VSHI.js";
-import "./chunk-3QQTXYZ6.js";
-import "./chunk-BT7NVCML.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
-import "./chunk-TLPZ6MKZ.js";
+import "./chunk-YEN4TREG.js";
 import "./chunk-I55KAVET.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-45GF7Y3V.js";
-import "./chunk-RGMVMVMF.js";
-import "./chunk-N7RWREIQ.js";
+import "./chunk-65RENJGB.js";
 import "./chunk-353KGBKY.js";
 import "./chunk-ZIKENA2C.js";
-import "./chunk-VYCOJKSX.js";
 import "./chunk-6Q3ZTEF6.js";
+import "./chunk-RGMVMVMF.js";
 import "./chunk-W5BIQOAJ.js";
 import "./chunk-Z7L72ZHL.js";
 import "./chunk-4O4TKIXQ.js";
@@ -80,20 +78,23 @@ import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-7RJUVTVF.js";
+import "./chunk-PWPIERBM.js";
+import "./chunk-BJMBJZ2Y.js";
+import "./chunk-UKJAGEXH.js";
+import "./chunk-FP2373TW.js";
+import "./chunk-LSLCFCCQ.js";
+import "./chunk-BT7NVCML.js";
+import "./chunk-VYCOJKSX.js";
 import "./chunk-NB3LRY4T.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-FFAZ2XFU.js";
-import "./chunk-EEOUMG3J.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
-import "./chunk-BJMBJZ2Y.js";
-import "./chunk-UKJAGEXH.js";
-import "./chunk-FP2373TW.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VUFL7X3H.js";
 import "./chunk-JUOZ62Y7.js";
-import "./chunk-O75CRYGF.js";
+import "./chunk-ZEFVK7XC.js";
 import "./chunk-6KH5NLQS.js";
 import "./chunk-P2QRMMVQ.js";
 import "./chunk-2Z24E5W2.js";

package/dist/write-envelope.d.ts

@@ -1,8 +1,9 @@
-import { y as MemoryCategory, N as MemorySubject } from './types-YY-eKKU7.js';
+import { u as MemoryCategory, N as MemorySubject } from './types-BGxTvLBO.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './recall-state-view.js';
 import './contradiction-config.js';
 import './graph-path-scoring-config.js';
 import './deep-recall-config.js';
@@ -100,6 +101,7 @@ declare const STRUCTURED_ATTRIBUTE_LIMITS: Readonly<{
     /** Maximum length of one attribute value. */
     maxValueLength: 1024;
 }>;
+declare const MEMORY_CATEGORY_NAMES: string[];
 declare function isMemoryCategory(value: string): value is MemoryCategory;
 declare const sealed: unique symbol;
 /**
@@ -294,4 +296,4 @@ interface ObserveFingerprintParts {
  */
 declare function buildObserveRequestFingerprint(parts: ObserveFingerprintParts): Record<string, unknown>;
 
-export { type AccessWriteFingerprintParts, type ComposeEnvelopeOptions, FINGERPRINT_EXEMPT_FIELDS, FINGERPRINT_SCOPE_FIELDS, type FingerprintScope, type MemoryWriteInput, type ObserveFingerprintParts, STRUCTURED_ATTRIBUTE_LIMITS, type SealedMemoryEnvelope, TAG_LIMITS, WRITE_FINGERPRINT_FIELDS, type WriteContext, buildAccessWriteRequestFingerprint, buildObserveRequestFingerprint, buildWriteIdempotencyPayload, composeMemoryEnvelope, isMemoryCategory, isSealedMemoryEnvelope, sealedWriteToLegacyArgs };
+export { type AccessWriteFingerprintParts, type ComposeEnvelopeOptions, FINGERPRINT_EXEMPT_FIELDS, FINGERPRINT_SCOPE_FIELDS, type FingerprintScope, MEMORY_CATEGORY_NAMES, type MemoryWriteInput, type ObserveFingerprintParts, STRUCTURED_ATTRIBUTE_LIMITS, type SealedMemoryEnvelope, TAG_LIMITS, WRITE_FINGERPRINT_FIELDS, type WriteContext, buildAccessWriteRequestFingerprint, buildObserveRequestFingerprint, buildWriteIdempotencyPayload, composeMemoryEnvelope, isMemoryCategory, isSealedMemoryEnvelope, sealedWriteToLegacyArgs };

package/dist/write-envelope.js

@@ -1,6 +1,7 @@
 import {
   FINGERPRINT_EXEMPT_FIELDS,
   FINGERPRINT_SCOPE_FIELDS,
+  MEMORY_CATEGORY_NAMES,
   STRUCTURED_ATTRIBUTE_LIMITS,
   TAG_LIMITS,
   WRITE_FINGERPRINT_FIELDS,
@@ -11,7 +12,7 @@ import {
   isMemoryCategory,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-3QQTXYZ6.js";
+} from "./chunk-LSLCFCCQ.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-VYCOJKSX.js";
 import "./chunk-NB3LRY4T.js";
@@ -30,6 +31,7 @@ import "./chunk-PZ5AY32C.js";
 export {
   FINGERPRINT_EXEMPT_FIELDS,
   FINGERPRINT_SCOPE_FIELDS,
+  MEMORY_CATEGORY_NAMES,
   STRUCTURED_ATTRIBUTE_LIMITS,
   TAG_LIMITS,
   WRITE_FINGERPRINT_FIELDS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.32",
+  "version": "9.69.34",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -11,6 +11,16 @@
       "remnic-source": "./src/index.ts",
       "import": "./dist/index.js"
     },
+    "./activity/digest": {
+      "types": "./dist/activity/digest.d.ts",
+      "remnic-source": "./src/activity/digest.ts",
+      "import": "./dist/activity/digest.js"
+    },
+    "./activity/digest.js": {
+      "types": "./dist/activity/digest.d.ts",
+      "remnic-source": "./src/activity/digest.ts",
+      "import": "./dist/activity/digest.js"
+    },
     "./maintenance/atomic-file": {
       "types": "./dist/maintenance/atomic-file.d.ts",
       "remnic-source": "./src/maintenance/atomic-file.ts",
@@ -3247,7 +3257,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.32"
+    "@remnic/coding-graph": "^9.69.34"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-category-alias.test.ts

@@ -0,0 +1,216 @@
+/**
+ * #2780: remnic_memory_store category ergonomics.
+ *
+ * Fleet callers repeatedly guess project-shaped categories; the valid
+ * category set contains no project-shaped name. The boundary schema admits
+ * exactly the four spellings telemetry shows (project, project_state,
+ * project-state, project_update); the write-surface funnel coerces them to
+ * the canonical "fact" and the response reports the coercion so callers
+ * learn. Every other spelling — including near-misses like projection or
+ * project_typo — rejects with the full valid list plus a "use fact" hint.
+ * An idempotent replay of an aliased write recomputes the coercion note
+ * from the CURRENT request's spelling while the stored result is reused.
+ *
+ * All fixtures are synthetic — no real user data.
+ */
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { memoryStoreRequestSchema, type MemoryStoreRequest, type SuggestionSubmitRequest } from "./access-schema.js";
+import { EngramAccessService } from "./access-service.js";
+import { Orchestrator } from "./orchestrator.js";
+import type { SealedMemoryEnvelope } from "./write-envelope.js";
+import { MEMORY_CATEGORY_NAMES } from "./write-envelope.js";
+import type { CodingContext, PluginConfig } from "./types.js";
+
+const PROJECT_ALIASES = ["project", "project_state", "project-state", "project_update"] as const;
+function makeService(persisted: { category?: string; writes?: number }, memoryDir?: string): EngramAccessService {
+  const orch = Object.create(Orchestrator.prototype) as Orchestrator;
+  const internals = orch as unknown as {
+    config: PluginConfig;
+    _codingContextBySession: Map<string, CodingContext>;
+  };
+  internals.config = {
+    namespacesEnabled: false,
+    defaultNamespace: "default",
+    memoryDir: memoryDir ?? "/synthetic/remnic-2780",
+  } as unknown as PluginConfig;
+  internals._codingContextBySession = new Map();
+  orch.getStorage = async () =>
+    ({
+      readAllMemories: async () => [],
+      writeSealedMemory: async (envelope: SealedMemoryEnvelope) => {
+        persisted.category = envelope.category;
+        persisted.writes = (persisted.writes ?? 0) + 1;
+        return { id: "mem-2780", tombstoneBlocked: false };
+      },
+      appendMemoryLifecycleEvents: async () => {},
+    }) as never;
+  return new EngramAccessService(orch);
+}
+
+test("project-shaped category aliases store as fact and the response reports the coercion (#2780)", async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), "remnic-2780-"));
+  try {
+    const persisted: { category?: string } = {};
+    const service = makeService(persisted);
+    for (const alias of PROJECT_ALIASES) {
+      const request = memoryStoreRequestSchema.parse({
+        sessionKey: "s-2780",
+        content: "durable synthetic memory content for alias tests",
+        category: alias,
+        confidence: 0.9,
+      });
+      const response = await service.memoryStore(request);
+      assert.equal(response.status, "stored", `${alias} must store, not queue`);
+      assert.equal(response.memoryId, "mem-2780");
+      assert.equal(persisted.category, "fact", `${alias} must persist as the canonical "fact"`);
+      assert.deepEqual(
+        response.categoryCoercion,
+        { from: alias, to: "fact" },
+        `${alias} response must name the original value and the canonical category`,
+      );
+    }
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("dryRun reports the coercion without persisting (#2780)", async () => {
+  const persisted: { category?: string } = {};
+  const service = makeService(persisted);
+  const request = memoryStoreRequestSchema.parse({
+    sessionKey: "s-2780-dry",
+    content: "durable synthetic memory content for alias tests",
+    category: "project_state",
+    dryRun: true,
+  });
+  const response = await service.memoryStore(request);
+  assert.equal(response.status, "validated");
+  assert.deepEqual(response.categoryCoercion, { from: "project_state", to: "fact" });
+  assert.equal(persisted.category, undefined, "dryRun must not persist");
+});
+
+test("valid categories pass through unchanged with no coercion note (#2780)", async () => {
+  const persisted: { category?: string } = {};
+  const service = makeService(persisted);
+  for (const category of MEMORY_CATEGORY_NAMES) {
+    const parsed = memoryStoreRequestSchema.parse({
+      sessionKey: "s-2780-valid",
+      content: "durable synthetic memory content for alias tests",
+      category,
+      dryRun: true,
+    });
+    assert.equal(parsed.category, category);
+    const response = await service.memoryStore(parsed);
+    assert.equal(response.status, "validated");
+    assert.equal(
+      response.categoryCoercion,
+      undefined,
+      `${category} is canonical and must never carry a coercion note`,
+    );
+  }
+});
+
+test("near-miss project spellings reject naming the valid set and the fact hint (#2780 fix A)", () => {
+  // Only the four telemetry-attested spellings coerce; everything else —
+  // including regex-shaped near-misses — must reject with the full list.
+  for (const bad of [
+    "vibe",
+    "Project_State",
+    "project state",
+    "",
+    "projection",
+    "projectile",
+    "project_typo",
+    "projections",
+  ]) {
+    assert.throws(
+      () =>
+        memoryStoreRequestSchema.parse({
+          sessionKey: "s-2780-bad",
+          content: "durable synthetic memory content for alias tests",
+          category: bad,
+          dryRun: true,
+        }),
+      (err: unknown) => {
+        assert.ok(err instanceof Error, `${JSON.stringify(bad)} must reject with an error`);
+        assert.match(err.message, /must be one of: /, "error must name the valid categories");
+        for (const valid of MEMORY_CATEGORY_NAMES) {
+          assert.match(err.message, new RegExp(`\\b${valid}\\b`), `error must list ${valid}`);
+        }
+        assert.match(err.message, /for project state\/facts use/, "error must carry the hint");
+        return true;
+      },
+      `${JSON.stringify(bad)} must be rejected, not coerced`,
+    );
+  }
+});
+
+test("suggestion_submit coerces project-shaped aliases the same way (#2780)", async () => {
+  const persisted: { category?: string } = {};
+  const service = makeService(persisted);
+  const request = memoryStoreRequestSchema.parse({
+    sessionKey: "s-2780-sug",
+    content: "durable synthetic suggestion content for alias tests",
+    category: "project_update",
+    dryRun: true,
+  });
+  const response = await service.suggestionSubmit(request);
+  assert.equal(response.status, "validated");
+  assert.deepEqual(response.categoryCoercion, { from: "project_update", to: "fact" });
+});
+
+test("idempotent replay recomputes the coercion note from the current request's spelling (#2780 fix B)", async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), "remnic-2780-replay-"));
+  try {
+    const persisted: { category?: string; writes?: number } = {};
+    const service = makeService(persisted, dir);
+    const base = {
+      sessionKey: "s-2780-replay",
+      content: "durable synthetic memory content for alias tests",
+      confidence: 0.9,
+      idempotencyKey: "idem-2780",
+    };
+    const first = await service.memoryStore(memoryStoreRequestSchema.parse({ ...base, category: "project_state" }));
+    assert.equal(first.status, "stored");
+    assert.deepEqual(first.categoryCoercion, { from: "project_state", to: "fact" });
+    assert.equal(persisted.writes, 1);
+
+    const second = await service.memoryStore(memoryStoreRequestSchema.parse({ ...base, category: "project-state" }));
+    assert.equal(second.idempotencyReplay, true, "same key + equivalent alias must replay, not re-store");
+    assert.deepEqual(
+      second.categoryCoercion,
+      { from: "project-state", to: "fact" },
+      "replay must name THIS request's spelling, not the stored one",
+    );
+    assert.equal(second.memoryId, first.memoryId, "replay must reuse the stored result id");
+    assert.equal(persisted.writes, 1, "replay must not persist again");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+test("MemoryStoreRequest and SuggestionSubmitRequest category are finite canonical unions (compile-time)", () => {
+  const invalidMemoryStore: MemoryStoreRequest = {
+    content: "durable synthetic content for type test",
+    // @ts-expect-error "projection" near-miss is rejected at compile time
+    category: "projection",
+  };
+  void invalidMemoryStore;
+
+  const invalidSuggestion: SuggestionSubmitRequest = {
+    content: "durable synthetic content for type test",
+    // @ts-expect-error "projection" near-miss is rejected at compile time
+    category: "projection",
+  };
+  void invalidSuggestion;
+
+  const validMemoryStore: MemoryStoreRequest = {
+    content: "durable synthetic content for type test",
+    category: "fact",
+  };
+  assert.equal(validMemoryStore.category, "fact");
+});

package/src/access-mcp.test.ts

@@ -263,6 +263,79 @@ test("MCP memory write tools reject malformed arguments before dispatch", async
   }
 });
 
+test("MCP memory write tools admit project-shaped category aliases (#2780)", async () => {
+  for (const toolName of ["engram.memory_store", "engram.suggestion_submit"]) {
+    let received: Record<string, unknown> | undefined;
+    const service = {
+      ...makeMockService(),
+      memoryStore: async (req: Record<string, unknown>) => {
+        received = req;
+        return {
+          schemaVersion: 1,
+          operation: "memory_store",
+          namespace: "default",
+          dryRun: true,
+          accepted: true,
+          queued: false,
+          status: "validated",
+        };
+      },
+      suggestionSubmit: async (req: Record<string, unknown>) => {
+        received = req;
+        return {
+          schemaVersion: 1,
+          operation: "suggestion_submit",
+          namespace: "default",
+          dryRun: true,
+          accepted: true,
+          queued: false,
+          status: "validated",
+        };
+      },
+    } as unknown as EngramAccessService;
+    const server = new EngramMcpServer(service);
+
+    const response = await server.handleRequest(
+      makeToolRequest(toolName, {
+        content: "valid durable content",
+        category: "project_state",
+        dryRun: true,
+      })
+    );
+    const result = (response as Record<string, unknown> & { result?: { isError?: boolean } }).result;
+
+    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"`
+    );
+  }
+});
+
+test("MCP memory_store invalid category error names valid categories and the fact hint (#2780)", async () => {
+  const server = new EngramMcpServer(makeMockService());
+
+  for (const bad of ["vibe", "projection", "project_typo"]) {
+    const response = await server.handleRequest(
+      makeToolRequest("engram.memory_store", {
+        content: "valid durable content",
+        category: bad,
+        dryRun: true,
+      })
+    );
+    const result = (response as Record<string, unknown> & {
+      result?: { isError?: boolean; content?: Array<{ text?: string }> };
+    }).result;
+
+    assert.equal(result?.isError, true, `${bad} must reject, not coerce`);
+    const text = (result?.content ?? []).map((part) => part.text ?? "").join("\n");
+    assert.match(text, /must be one of: /, "error must name the valid categories");
+    assert.match(text, /reasoning_trace/, "the full valid list must be present");
+    assert.match(text, /for project state\/facts use "fact"/, "error must carry the fact hint");
+  }
+});
+
 test("MCP write tools accept and forward client-injected cwd/projectTag (#1434)", async () => {
   for (const toolName of ["engram.memory_store", "engram.suggestion_submit"]) {
     let received: Record<string, unknown> | undefined;

package/src/access-mcp.ts

@@ -543,10 +543,7 @@ export class EngramMcpServer {
             topK: { type: "number" },
             mode: { type: "string", enum: ["auto", "no_recall", "minimal", "full", "graph_mode"] },
             includeDebug: { type: "boolean" },
-            // Recall disclosure depth (issue #677).  Default `chunk` when
-            // omitted.  Section/raw payload shaping ships in PR 2; this PR
-            // wires the field end-to-end so clients can already pass it
-            // without it being silently dropped.
+            // Disclosure 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: {
@@ -566,8 +563,11 @@ export class EngramMcpServer {
             tagMatch: {
               type: "string",
               enum: ["any", "all"],
-              description:
-                "Tag-filter match mode. 'any' (default) admits results with at least one filter tag; 'all' requires every filter tag.",
+              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"],

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

@@ -30,6 +30,7 @@ import {
   NamespaceNotWritableError,
 } from "./access-service.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 {
@@ -482,9 +483,13 @@ export class AccessObserveWriteSurface {
   }
 
   async memoryStore(
-    request: EngramAccessMemoryStoreRequest,
+    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);
     let namespace: string;
     try {
       namespace = await this.deps.resolveCodingScopedWriteNamespace(request);
@@ -513,6 +518,7 @@ export class AccessObserveWriteSurface {
           queued: false,
           status: "validated",
           idempotencyKey: request.idempotencyKey?.trim() || undefined,
+          ...(categoryCoercion ? { categoryCoercion } : {}),
         };
       }
       const result = await persistExplicitCapture(this.deps.orchestrator, candidate, "memory_store");
@@ -539,13 +545,14 @@ export class AccessObserveWriteSurface {
         memoryId: result.id,
         duplicateOf: result.duplicateOf,
         idempotencyKey: request.idempotencyKey?.trim() || undefined,
+        ...(categoryCoercion ? { categoryCoercion } : {}),
       };
       log.info(
         `access-write op=memory_store namespace=${namespace} dryRun=false status=${response.status} memoryId=${response.memoryId ?? "-"} idempotency=${response.idempotencyKey ? "yes" : "no"}`
       );
       return response;
     };
-    return this.deps.handleIdempotentWrite({
+    const response = await this.deps.handleIdempotentWrite({
       operation: "memory_store",
       idempotencyKey: request.idempotencyKey,
       // Shared builder (issue #1989 PR3): byte-parity with the historical
@@ -566,12 +573,16 @@ export class AccessObserveWriteSurface {
       beforeExecute: hooks?.enforceWriteQuota,
       execute,
     });
+    // #2780 fix B: rewrite a replayed coercion note from THIS request's raw category.
+    return reapplyCategoryCoercion(response, categoryCoercion);
   }
 
   async suggestionSubmit(
-    request: EngramAccessSuggestionSubmitRequest,
+    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);
     let namespace: string;
     try {
       namespace = await this.deps.resolveCodingScopedWriteNamespace(request);
@@ -599,6 +610,7 @@ export class AccessObserveWriteSurface {
           queued: true,
           status: "validated",
           idempotencyKey: request.idempotencyKey?.trim() || undefined,
+          ...(categoryCoercion ? { categoryCoercion } : {}),
         };
       }
       const result = await queueExplicitCaptureForReview(
@@ -622,13 +634,14 @@ export class AccessObserveWriteSurface {
         memoryId: result.id,
         duplicateOf: result.duplicateOf,
         idempotencyKey: request.idempotencyKey?.trim() || undefined,
+        ...(categoryCoercion ? { 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;
     };
-    return this.deps.handleIdempotentWrite({
+    const replayed = await this.deps.handleIdempotentWrite({
       operation: "suggestion_submit",
       idempotencyKey: request.idempotencyKey,
       // Shared builder (issue #1989 PR3): byte-parity with the historical
@@ -649,6 +662,8 @@ export class AccessObserveWriteSurface {
       beforeExecute: hooks?.enforceWriteQuota,
       execute,
     });
+    // #2780 fix B: rewrite a replayed coercion note from THIS request's raw category.
+    return reapplyCategoryCoercion(replayed, categoryCoercion);
   }
 
   async runObserve(request: EngramAccessObserveRequest): Promise<EngramAccessObserveResponse> {