@remnic/core 9.3.729 → 9.3.730

package/src/bitemporal-dedup-backfill.test.ts

@@ -41,7 +41,7 @@ test("#1671: writeMemoryFrontmatter patches invalid_at onto an existing fact tha
   const { storage, cleanup } = await makeStorage("bitemporal-backfill-patch-");
   try {
     // Write a fact WITHOUT bi-temporal bounds (simulates a pre-#1578 copy).
-    const id = await storage.writeMemory("fact", "We use PostgreSQL for the main db.", {
+    const { id: id } = await storage.writeMemory("fact", "We use PostgreSQL for the main db.", {
       confidence: 0.9,
     });
     const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
@@ -95,7 +95,7 @@ test("#1671: backfill does NOT clobber an existing invalid_at on the copy", asyn
   const { storage, cleanup } = await makeStorage("bitemporal-backfill-noclobber-");
   try {
     // The existing copy already has an explicit invalid_at.
-    const id = await storage.writeMemory("fact", "We use MySQL until December.", {
+    const { id: id } = await storage.writeMemory("fact", "We use MySQL until December.", {
       confidence: 0.9,
       invalidAt: "2025-12-01T00:00:00.000Z",
       observedAt: "2025-06-01T00:00:00.000Z",
@@ -126,7 +126,7 @@ test("#1671: re-extraction with resolved invalidAt backfills an old promoted cop
   try {
     // Step 1: write a fact WITHOUT bounds (old promoted copy).
     const content = "The API rate limit is 100 req/min.";
-    const id = await storage.writeMemory("fact", content, {
+    const { id: id } = await storage.writeMemory("fact", content, {
       confidence: 0.9,
     });
 
@@ -184,7 +184,7 @@ test("#1707 thread 2: corrected extracted validFrom overwrites a batch-anchored
     // Old promoted copy: batch-anchored valid_at, no per-fact event-time.
     const content = "We have used Stripe for payments since 2024.";
     const batchAnchor = "2026-06-01T00:00:00.000Z";
-    const id = await storage.writeMemory("fact", content, {
+    const { id } = await storage.writeMemory("fact", content, {
       confidence: 0.9,
       validAt: batchAnchor,
       // No eventTimeSource → batch-anchored (legacy pre-#1670 copy).
@@ -225,7 +225,7 @@ test("#1707 thread 2: identical extracted validFrom is a no-op (equality short-c
     // Copy already carries an extracted per-fact anchor.
     const content = "The migration to MySQL completed in March 2025.";
     const existingValidAt: string = "2025-03-01T00:00:00.000Z";
-    const id = await storage.writeMemory("fact", content, {
+    const { id } = await storage.writeMemory("fact", content, {
       confidence: 0.9,
       validAt: existingValidAt,
       observedAt: "2025-06-01T00:00:00.000Z",
@@ -256,7 +256,7 @@ test("#1707 thread 2: differing extracted validFrom overwrites (authoritative re
     // Copy carries an older (batch-anchored) valid_at.
     const content = "We have used Stripe for payments since 2024.";
     const staleValidAt: string = "2026-06-01T00:00:00.000Z"; // batch anchor
-    const id = await storage.writeMemory("fact", content, {
+    const { id } = await storage.writeMemory("fact", content, {
       confidence: 0.9,
       validAt: staleValidAt,
     });
@@ -300,7 +300,7 @@ test("#1707 thread 2: end-only extracted provenance does NOT block a later start
     // anchor (assumed start).
     const observedAt = "2026-06-01T00:00:00.000Z";
     const content = "The service was maintained through 2026.";
-    const id = await storage.writeMemory("fact", content, {
+    const { id } = await storage.writeMemory("fact", content, {
       confidence: 0.9,
       validAt: observedAt, // valid_at === observedAt (assumed/batch start)
       observedAt,
@@ -381,8 +381,8 @@ test("#1707 thread 1: backfill patches promoted copies across multiple storages
   try {
     const content = "The API rate limit is 100 req/min until June 2025.";
     // Both namespaces hold the same fact, written WITHOUT bounds (stale copies).
-    const sourceId = await sourceStorage.writeMemory("fact", content, { confidence: 0.9 });
-    const promotedId = await promotedStorage.writeMemory("fact", content, { confidence: 0.9 });
+    const { id: sourceId } = await sourceStorage.writeMemory("fact", content, { confidence: 0.9 });
+    const { id: promotedId } = await promotedStorage.writeMemory("fact", content, { confidence: 0.9 });
 
     // Simulate re-extraction that now carries a resolved invalidAt. The
     // promotion-cascade closure calls the same backfill against each target.
@@ -434,7 +434,7 @@ test("#1707 thread 3: backfill never patches a non-fact copy (category guard)",
     const content = "The user prefers dark mode.";
     // A preference (non-fact) whose content would collide with an incoming
     // duplicate candidate.
-    const id = await storage.writeMemory("preference", content, { confidence: 0.9 });
+    const { id } = await storage.writeMemory("preference", content, { confidence: 0.9 });
     const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
     assert.ok(before);
     assert.equal(before!.frontmatter.category, "preference");

package/src/bitemporal-frontmatter.test.ts

@@ -34,7 +34,7 @@ test("round-trip: observedAt + eventTimeSource + valid_at survive write → read
     const storage = new StorageManager(dir);
     await storage.ensureDirectories();
 
-    const id = await storage.writeMemory("fact", "We moved offices in March.", {
+    const { id: id } = await storage.writeMemory("fact", "We moved offices in March.", {
       observedAt: OBSERVED,
       eventTimeSource: "extracted",
       validAt: VALID_FROM,
@@ -67,7 +67,7 @@ test("round-trip: invalid_at + forgottenAt coexist with observedAt/eventTimeSour
     const storage = new StorageManager(dir);
     await storage.ensureDirectories();
 
-    const id = await storage.writeMemory("fact", "Old stack was Node 18.", {
+    const { id: id } = await storage.writeMemory("fact", "Old stack was Node 18.", {
       observedAt: OBSERVED,
       eventTimeSource: "assumed",
       validAt: VALID_FROM,
@@ -108,7 +108,7 @@ test("legacy memory without bi-temporal fields reads cleanly — observedAt/even
     const storage = new StorageManager(dir);
     await storage.ensureDirectories();
 
-    const id = await storage.writeMemory("fact", "Legacy fact pre-dating #1578.");
+    const { id: id } = await storage.writeMemory("fact", "Legacy fact pre-dating #1578.");
 
     const memories = await storage.readAllMemories();
     const written = memories.find((m) => m.frontmatter.id === id);

package/src/capabilities.test.ts

@@ -461,3 +461,188 @@ test("resolveMemoryLifecycleCapabilities matches pre-migration config reads (par
     }
   }
 });
+
+
+// ---------------------------------------------------------------------------
+// IndexingCapabilitySet — gate-parity tests (issue #1523 batch 4).
+//
+// Same invariant as the sets above: every caps field must project from its
+// `<field>Enabled` config flag. All two flags are required booleans on
+// PluginConfig (defaults resolved at the parse boundary), so the projection
+// is a pure passthrough.
+//
+// Parity contract: a caps-resolved run and a config-derived run MUST produce
+// identical boolean values for every gate — on AND off.
+// ---------------------------------------------------------------------------
+
+import {
+  resolveIndexingCapabilities,
+  type IndexingCapabilitySet,
+} from "./capabilities.js";
+
+const INDEXING_FIELD_TO_FLAG: Record<keyof IndexingCapabilitySet, string> = {
+  queryAwareIndexing: "queryAwareIndexingEnabled",
+  conversationIndex: "conversationIndexEnabled",
+};
+
+const INDEXING_FIELDS = Object.keys(INDEXING_FIELD_TO_FLAG) as Array<
+  keyof IndexingCapabilitySet
+>;
+
+test("resolveIndexingCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(INDEXING_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveIndexingCapabilities(config);
+
+  for (const field of INDEXING_FIELDS) {
+    const flag = INDEXING_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], true, `caps.${field} must be true when ${flag}=true`);
+  }
+});
+
+test("resolveIndexingCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(INDEXING_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveIndexingCapabilities(config);
+
+  for (const field of INDEXING_FIELDS) {
+    const flag = INDEXING_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], false, `caps.${field} must be false when ${flag}=false`);
+  }
+});
+
+test("resolveIndexingCapabilities returns a frozen object", () => {
+  const config = parseConfig({});
+  const caps = resolveIndexingCapabilities(config);
+  assert.equal(Object.isFrozen(caps), true);
+});
+
+test("resolveIndexingCapabilities matches pre-migration config reads (parity contract)", () => {
+  const cases: Record<string, Record<string, boolean>> = {
+    "all-off": {
+      queryAwareIndexingEnabled: false,
+      conversationIndexEnabled: false,
+    },
+    "all-on": {
+      queryAwareIndexingEnabled: true,
+      conversationIndexEnabled: true,
+    },
+    "indexing-on-conv-off": {
+      queryAwareIndexingEnabled: true,
+      conversationIndexEnabled: false,
+    },
+    "conv-on-indexing-off": {
+      queryAwareIndexingEnabled: false,
+      conversationIndexEnabled: true,
+    },
+  };
+
+  for (const [label, overrides] of Object.entries(cases)) {
+    const config = parseConfig(overrides);
+    const caps = resolveIndexingCapabilities(config);
+
+    for (const field of INDEXING_FIELDS) {
+      const flag = INDEXING_FIELD_TO_FLAG[field];
+      assert.equal(
+        caps[field],
+        (config as unknown as Record<string, boolean>)[flag],
+        `[${label}] caps.${field} must equal config.${flag}`,
+      );
+    }
+  }
+});
+
+// ---------------------------------------------------------------------------
+// CreationMemoryCapabilitySet — gate-parity tests (issue #1523 batch 4).
+// ---------------------------------------------------------------------------
+
+import {
+  resolveCreationMemoryCapabilities,
+  type CreationMemoryCapabilitySet,
+} from "./capabilities.js";
+
+const CREATION_FIELD_TO_FLAG: Record<keyof CreationMemoryCapabilitySet, string> = {
+  creationMemory: "creationMemoryEnabled",
+  commitmentLedger: "commitmentLedgerEnabled",
+  resumeBundles: "resumeBundlesEnabled",
+  commitmentLifecycle: "commitmentLifecycleEnabled",
+};
+
+const CREATION_FIELDS = Object.keys(CREATION_FIELD_TO_FLAG) as Array<
+  keyof CreationMemoryCapabilitySet
+>;
+
+test("resolveCreationMemoryCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CREATION_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveCreationMemoryCapabilities(config);
+
+  for (const field of CREATION_FIELDS) {
+    const flag = CREATION_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], true, `caps.${field} must be true when ${flag}=true`);
+  }
+});
+
+test("resolveCreationMemoryCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(CREATION_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveCreationMemoryCapabilities(config);
+
+  for (const field of CREATION_FIELDS) {
+    const flag = CREATION_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], false, `caps.${field} must be false when ${flag}=false`);
+  }
+});
+
+test("resolveCreationMemoryCapabilities returns a frozen object", () => {
+  const config = parseConfig({});
+  const caps = resolveCreationMemoryCapabilities(config);
+  assert.equal(Object.isFrozen(caps), true);
+});
+
+test("resolveCreationMemoryCapabilities matches pre-migration config reads (parity contract)", () => {
+  const cases: Record<string, Record<string, boolean>> = {
+    "all-off": {
+      creationMemoryEnabled: false,
+      commitmentLedgerEnabled: false,
+      resumeBundlesEnabled: false,
+      commitmentLifecycleEnabled: false,
+    },
+    "all-on": {
+      creationMemoryEnabled: true,
+      commitmentLedgerEnabled: true,
+      resumeBundlesEnabled: true,
+      commitmentLifecycleEnabled: true,
+    },
+    "creation-on-rest-off": {
+      creationMemoryEnabled: true,
+      commitmentLedgerEnabled: false,
+      resumeBundlesEnabled: false,
+      commitmentLifecycleEnabled: false,
+    },
+    "ledgers-on-rest-off": {
+      creationMemoryEnabled: false,
+      commitmentLedgerEnabled: true,
+      resumeBundlesEnabled: true,
+      commitmentLifecycleEnabled: true,
+    },
+  };
+
+  for (const [label, overrides] of Object.entries(cases)) {
+    const config = parseConfig(overrides);
+    const caps = resolveCreationMemoryCapabilities(config);
+
+    for (const field of CREATION_FIELDS) {
+      const flag = CREATION_FIELD_TO_FLAG[field];
+      assert.equal(
+        caps[field],
+        (config as unknown as Record<string, boolean>)[flag],
+        `[${label}] caps.${field} must equal config.${flag}`,
+      );
+    }
+  }
+});

package/src/capabilities.ts

@@ -294,3 +294,113 @@ export function resolveMemoryLifecycleCapabilities(
     embeddingFallback: config.embeddingFallbackEnabled,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Indexing capability set (issue #1523 batch 4).
+//
+// The flags below gate query-aware indexing (temporal/tag index build +
+// prefilter) and the conversation index (QMD/FAISS backend selection). They
+// are read on the recall path, the extraction/persist path, and the
+// maintenance/invalidation path — so they get their own projection resolved
+// ONCE at each operation entry that reads them.
+//
+// Every field projects from an already-resolved PluginConfig boolean (defaults
+// applied at the parse boundary), so the resolver is a pure projection.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of indexing feature gates (issue #1523 batch 4).
+ *
+ * Resolved once per recall / extraction / maintenance operation and threaded
+ * down. Composition lives ONLY in {@link resolveIndexingCapabilities}.
+ */
+export interface IndexingCapabilitySet {
+  /** `queryAwareIndexingEnabled` — build + use temporal/tag index for recall prefilter. */
+  readonly queryAwareIndexing: boolean;
+  /** `conversationIndexEnabled` — conversation-index backend (QMD / FAISS). */
+  readonly conversationIndex: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveIndexingCapabilities}.
+ */
+export type IndexingConfigProjection = Pick<
+  PluginConfig,
+  "queryAwareIndexingEnabled" | "conversationIndexEnabled"
+>;
+
+/**
+ * Resolve the {@link IndexingCapabilitySet} from parsed config.
+ *
+ * Call this ONCE per recall / extraction / maintenance operation entry and
+ * thread the result down — exactly the pattern {@link resolveCapabilities}
+ * established for recall.
+ */
+export function resolveIndexingCapabilities(
+  config: IndexingConfigProjection,
+): IndexingCapabilitySet {
+  return Object.freeze({
+    queryAwareIndexing: config.queryAwareIndexingEnabled,
+    conversationIndex: config.conversationIndexEnabled,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Creation-memory capability set (issue #1523 batch 4).
+//
+// The flags below gate the creation-memory subsystem: resume-bundle handoff,
+// commitment ledger, commitment lifecycle, and the master creation-memory
+// switch. They are read on the extraction/persist path, the recall
+// enrichment path, and the CLI command surface — so they get their own
+// projection resolved ONCE at each operation entry that reads them.
+//
+// Every field projects from an already-resolved PluginConfig boolean (defaults
+// applied at the parse boundary), so the resolver is a pure projection.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of creation-memory feature gates (issue #1523 batch 4).
+ *
+ * Resolved once per creation-memory operation (CLI command, extraction,
+ * recall enrichment) and threaded down. Composition lives ONLY in
+ * {@link resolveCreationMemoryCapabilities}.
+ */
+export interface CreationMemoryCapabilitySet {
+  /** `creationMemoryEnabled` — master switch for creation-memory subsystem. */
+  readonly creationMemory: boolean;
+  /** `commitmentLedgerEnabled` — commitment-ledger read/write. */
+  readonly commitmentLedger: boolean;
+  /** `resumeBundlesEnabled` — resume-bundle handoff bundles. */
+  readonly resumeBundles: boolean;
+  /** `commitmentLifecycleEnabled` — commitment lifecycle (promotion / decay). */
+  readonly commitmentLifecycle: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveCreationMemoryCapabilities}.
+ */
+export type CreationMemoryConfigProjection = Pick<
+  PluginConfig,
+  | "creationMemoryEnabled"
+  | "commitmentLedgerEnabled"
+  | "resumeBundlesEnabled"
+  | "commitmentLifecycleEnabled"
+>;
+
+/**
+ * Resolve the {@link CreationMemoryCapabilitySet} from parsed config.
+ *
+ * Call this ONCE per creation-memory operation entry and thread the result
+ * down — exactly the pattern {@link resolveCapabilities} established for
+ * recall.
+ */
+export function resolveCreationMemoryCapabilities(
+  config: CreationMemoryConfigProjection,
+): CreationMemoryCapabilitySet {
+  return Object.freeze({
+    creationMemory: config.creationMemoryEnabled,
+    commitmentLedger: config.commitmentLedgerEnabled,
+    resumeBundles: config.resumeBundlesEnabled,
+    commitmentLifecycle: config.commitmentLifecycleEnabled,
+  });
+}

package/src/cli/creation-ledger-commands.ts

@@ -20,6 +20,7 @@ import type { CliCommand } from "../cli.js";
 import type { CommitmentLedgerEntry } from "../commitment-ledger.js";
 import type { WorkProductLedgerEntry } from "../work-product-ledger.js";
 import type { ResumeBundle } from "../resume-bundles.js";
+import { resolveCreationMemoryCapabilities } from "../capabilities.js";
 import {
   runResumeBundleStatusCliCommand,
   runResumeBundleRecordCliCommand,
@@ -48,8 +49,8 @@ cmd
     const status = await runResumeBundleStatusCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       resumeBundleDir: orchestrator.config.resumeBundleDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      resumeBundlesEnabled: resolveCreationMemoryCapabilities(orchestrator.config).resumeBundles,
     });
     console.log(JSON.stringify(status, null, 2));
     console.log("OK");
@@ -84,8 +85,8 @@ cmd
     const filePath = await runResumeBundleRecordCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       resumeBundleDir: orchestrator.config.resumeBundleDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      resumeBundlesEnabled: resolveCreationMemoryCapabilities(orchestrator.config).resumeBundles,
       bundle: {
         schemaVersion: 1,
         bundleId: String(options.bundleId ?? ""),
@@ -127,11 +128,11 @@ cmd
       objectiveStateStoreDir: orchestrator.config.objectiveStateStoreDir,
       workProductLedgerDir: orchestrator.config.workProductLedgerDir,
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      resumeBundlesEnabled: resolveCreationMemoryCapabilities(orchestrator.config).resumeBundles,
       transcriptEnabled: orchestrator.config.transcriptEnabled,
       objectiveStateMemoryEnabled: orchestrator.config.objectiveStateMemoryEnabled,
-      commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
+      commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
       bundleId: String(options.bundleId ?? ""),
       recordedAt: String(options.recordedAt ?? ""),
       sessionKey: String(options.sessionKey ?? ""),
@@ -152,9 +153,9 @@ cmd
     const status = await runCommitmentStatusCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
-      commitmentLifecycleEnabled: orchestrator.config.commitmentLifecycleEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
+      commitmentLifecycleEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLifecycle,
       commitmentStaleDays: orchestrator.config.commitmentStaleDays,
       commitmentDecayDays: orchestrator.config.commitmentDecayDays,
     });
@@ -189,8 +190,8 @@ cmd
     const filePath = await runCommitmentRecordCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
       entry: {
         schemaVersion: 1,
         entryId: String(options.entryId ?? ""),
@@ -227,9 +228,9 @@ cmd
     const entry = await runCommitmentSetStateCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
-      commitmentLifecycleEnabled: orchestrator.config.commitmentLifecycleEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
+      commitmentLifecycleEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLifecycle,
       entryId: String(options.entryId ?? ""),
       nextState: String(options.state ?? "") as CommitmentLedgerEntry["state"],
       changedAt: String(options.changedAt ?? ""),
@@ -247,9 +248,9 @@ cmd
     const result = await runCommitmentLifecycleCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
-      commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
-      commitmentLifecycleEnabled: orchestrator.config.commitmentLifecycleEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
+      commitmentLedgerEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLedger,
+      commitmentLifecycleEnabled: resolveCreationMemoryCapabilities(orchestrator.config).commitmentLifecycle,
       commitmentDecayDays: orchestrator.config.commitmentDecayDays,
       now: typeof options.now === "string" ? options.now : undefined,
     });
@@ -264,7 +265,7 @@ cmd
     const status = await runWorkProductStatusCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       workProductLedgerDir: orchestrator.config.workProductLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
     });
     console.log(JSON.stringify(status, null, 2));
     console.log("OK");
@@ -296,7 +297,7 @@ cmd
     const filePath = await runWorkProductRecordCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       workProductLedgerDir: orchestrator.config.workProductLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
       entry: {
         schemaVersion: 1,
         entryId: String(options.entryId ?? ""),
@@ -334,7 +335,7 @@ cmd
     const results = await runWorkProductRecallSearchCliCommand({
       memoryDir: orchestrator.config.memoryDir,
       workProductLedgerDir: orchestrator.config.workProductLedgerDir,
-      creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+      creationMemoryEnabled: resolveCreationMemoryCapabilities(orchestrator.config).creationMemory,
       workProductRecallEnabled: orchestrator.config.workProductRecallEnabled,
       query,
       maxResults: Number.isFinite(maxResults) ? maxResults : 3,

package/src/coding/architecture-surfaces.test.ts

@@ -117,7 +117,7 @@ function makeStubStorage(initialMemories: MemoryFile[] = []): StubStorage {
         frontmatter: makeFrontmatter({ id, ...(options as Partial<MemoryFrontmatter>) }),
         content,
       });
-      return id;
+      return { id: id, tombstoneBlocked: false };
     },
     async updateMemory(id, newContent) {
       updated.push({ id, content: newContent });
@@ -393,6 +393,30 @@ test("refresh: truncated card carries 'truncated' tag in write options", async (
   assert.ok(written?.frontmatter.tags?.includes("truncated"), "truncated tag present");
 });
 
+test("refresh: tombstone-blocked write surfaces refreshed:false + blocked reason (#1645)", async () => {
+  // findArchitectureCardMemory filters non-active cards, so a blocked prior
+  // card resolves to null and the refresh takes the first-card writeMemory
+  // path. When that write is tombstone-blocked (#1579), the response must
+  // report refreshed:false with a blocked reason — NOT refreshed:true, which
+  // would hide the block from callers/UI.
+  const base = makeStubStorage();
+  const storage: StubStorage = {
+    ...base,
+    async writeMemory(category, content, options) {
+      const result = await base.writeMemory(category, content, options);
+      return { ...result, tombstoneBlocked: true, blockedBy: "tomb-arch-1" };
+    },
+  };
+  const ctx = makeContext({ resolveStorage: async () => storage });
+  const result = await handleCodingArchitecture({ subcommand: "refresh", sessionKey: "s1" }, ctx);
+  assert.equal(result.subcommand, "refresh");
+  if (result.subcommand !== "refresh") return;
+  assert.equal(result.refreshed, false, "a tombstone-blocked write is not refreshed");
+  assert.equal(result.blockedReason, "tombstone-blocked", "blocked reason surfaced");
+  assert.equal(result.blockedBy, "tomb-arch-1", "blocking tombstone id surfaced");
+  assert.ok(result.memoryId, "pending_review memory still persisted with an id");
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // get — truncation derived from content, not from a stale tag (cursor review)
 // ──────────────────────────────────────────────────────────────────────────