@remnic/core 9.3.728 → 9.3.730

package/src/search/factory.ts

@@ -10,6 +10,7 @@ import { EmbedHelper } from "./embed-helper.js";
 import { QmdClient, type QmdClientOptions } from "../qmd.js";
 import { log } from "../logger.js";
 import { FaissConversationIndexAdapter } from "../conversation-index/faiss-adapter.js";
+import { resolveIndexingCapabilities } from "../capabilities.js";
 import {
   createConversationIndexBackend,
   type ConversationIndexBackend,
@@ -135,7 +136,7 @@ export function createSearchBackend(config: PluginConfig): SearchBackend {
  * Returns undefined if conversation index is not enabled or not using qmd backend.
  */
 export function createConversationSearchBackend(config: PluginConfig): SearchBackend | undefined {
-  if (!config.conversationIndexEnabled || config.conversationIndexBackend !== "qmd") {
+  if (!resolveIndexingCapabilities(config).conversationIndex || config.conversationIndexBackend !== "qmd") {
     return undefined;
   }
 
@@ -169,7 +170,7 @@ export function createConversationIndexRuntime(
 ): ConversationIndexRuntime {
   const qmd = createConversationSearchBackend(config) as ConversationQmdRuntime | undefined;
   let faiss: FaissConversationIndexAdapter | undefined;
-  if (config.conversationIndexEnabled && config.conversationIndexBackend === "faiss") {
+  if (resolveIndexingCapabilities(config).conversationIndex && config.conversationIndexBackend === "faiss") {
     try {
       faiss = new FaissConversationIndexAdapter({
           memoryDir: config.memoryDir,
@@ -189,7 +190,7 @@ export function createConversationIndexRuntime(
   }
 
   const backend = createConversationIndexBackend({
-    enabled: config.conversationIndexEnabled,
+    enabled: resolveIndexingCapabilities(config).conversationIndex,
     backend: config.conversationIndexBackend,
     getQmd: () => overrides?.getQmd?.() ?? qmd,
     getFaiss: () => overrides?.getFaiss?.() ?? faiss,

package/src/semantic-rule-promotion.ts

@@ -630,7 +630,7 @@ export async function promoteSemanticRuleFromMemory(options: {
     }
 
     await lock.beforePromotedRuleWrite();
-    const id = await storage.writeMemory("rule", content, {
+    const { id: id } = await storage.writeMemory("rule", content, {
       confidence,
       tags: candidateBase.tags,
       source: "semantic-rule-promotion",

package/src/source-attribution-roundtrip.test.ts

@@ -41,7 +41,7 @@ test("round-trip: citation-enriched fact content survives writeMemory → readAl
 
     assert.ok(hasCitation(enriched), "attachCitation must emit a marker");
 
-    const id = await storage.writeMemory("fact", enriched, {
+    const { id: id } = await storage.writeMemory("fact", enriched, {
       confidence: 0.8,
       tags: ["test"],
     });
@@ -76,7 +76,7 @@ test("legacy fact memories without a citation marker still read cleanly", async
     await storage.ensureDirectories();
 
     const legacyBody = "Legacy fact without inline provenance.";
-    const id = await storage.writeMemory("fact", legacyBody, {
+    const { id: id } = await storage.writeMemory("fact", legacyBody, {
       confidence: 0.8,
       tags: ["legacy"],
     });

package/src/storage-contract/atomicity.test.ts

@@ -82,7 +82,7 @@ test("atomicity: StorageManager.updateMemory preserves the original on overwrite
   const { makeStorage } = await import("./harness.js");
   const { storage, cleanup } = await makeStorage();
   try {
-    const id = await storage.writeMemory("fact", "version one");
+    const { id: id } = await storage.writeMemory("fact", "version one");
     const before = await storage.getMemoryById(id);
     assert.ok(before);
     assert.equal(before!.content, "version one");

package/src/storage-contract/cache-coherence.test.ts

@@ -24,7 +24,7 @@ test("cache-coherence: write via instance A, read via fresh instance B → B see
     const smA = new StorageManager(dir);
     await smA.ensureDirectories();
 
-    const id = await smA.writeMemory("fact", "written by A");
+    const { id: id } = await smA.writeMemory("fact", "written by A");
 
     // Fresh instance over the same dir
     const smB = new StorageManager(dir);
@@ -47,7 +47,7 @@ test("cache-coherence: delete via instance A is reflected in fresh instance B",
     resetStaticCaches();
     const smA = new StorageManager(dir);
     await smA.ensureDirectories();
-    const id = await smA.writeMemory("fact", "to be deleted");
+    const { id: id } = await smA.writeMemory("fact", "to be deleted");
 
     // Confirm B sees it
     const smB = new StorageManager(dir);

package/src/storage-contract/content-hash.test.ts

@@ -87,7 +87,7 @@ test("content-hash: the frontmatter contentHash matches computeHash of the raw c
   const { storage, cleanup } = await makeStorage();
   try {
     const rawFact = "deterministic hash check";
-    const id = await storage.writeMemory("fact", rawFact);
+    const { id: id } = await storage.writeMemory("fact", rawFact);
     const memory = await storage.getMemoryById(id);
     assert.ok(memory);
     assert.ok(memory!.frontmatter.contentHash, "frontmatter must carry a contentHash for facts");

package/src/storage-contract/namespace-routing.test.ts

@@ -69,7 +69,7 @@ test("namespace-routing: writes in one namespace are invisible to another (isola
   const { router, cleanup } = await makeNamespaceRouter();
   try {
     const sm1 = await router.storageFor("team-alpha");
-    const id = await sm1.writeMemory("fact", "alpha-only fact");
+    const { id: id } = await sm1.writeMemory("fact", "alpha-only fact");
 
     const sm2 = await router.storageFor("team-beta");
     const found = await sm2.getMemoryById(id);

package/src/storage-contract/round-trip.test.ts

@@ -38,7 +38,7 @@ const ROUND_TRIP_CATEGORIES = ALL_CATEGORY_KEYS.filter(
 test("round-trip: writeMemory returns a stable id and persists to the category dir", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const id = await storage.writeMemory("fact", "The sky is blue", {
+    const { id: id } = await storage.writeMemory("fact", "The sky is blue", {
       tags: ["contract"],
     });
     assert.equal(typeof id, "string");
@@ -58,7 +58,7 @@ test("round-trip: readAllMemories returns written memories from every category d
   try {
     const written: string[] = [];
     for (const category of ROUND_TRIP_CATEGORIES) {
-      const id = await storage.writeMemory(
+      const { id: id } = await storage.writeMemory(
         category,
         `content for ${category}`,
         { confidence: 0.9 },
@@ -81,7 +81,7 @@ for (const category of ROUND_TRIP_CATEGORIES) {
     const { storage, cleanup } = await makeStorage();
     try {
       const content = `fact body for category ${category}`;
-      const id = await storage.writeMemory(category, content, {
+      const { id: id } = await storage.writeMemory(category, content, {
         tags: ["round-trip"],
       });
 

package/src/storage.ts

@@ -2244,6 +2244,19 @@ function isValidBufferSurpriseEvent(value: unknown): value is BufferSurpriseEven
   return true;
 }
 
+/** Result of {@link StorageManager.writeMemory} (issue #1645). Carries the
+ * persisted id PLUS the non-resurrection tombstone-block outcome (#1579) so
+ * post-write callers can observe it — NEVER a silent no-op (rule 34). */
+export interface MemoryWriteResult {
+  /** The persisted memory id. */
+  id: string;
+  /** True when the #1579 tombstone chokepoint downgraded this write to
+   * `pending_review` + `blockedBy`. Callers gate active post-write work on this. */
+  tombstoneBlocked: boolean;
+  /** The tombstone id that blocked the write, when `tombstoneBlocked`. */
+  blockedBy?: string;
+}
+
 export class StorageManager {
   private knowledgeIndexCache: { result: string; builtAt: number } | null = null;
   private static readonly KNOWLEDGE_INDEX_CACHE_TTL_MS = 600_000; // 10 minutes (entity mutations invalidate)
@@ -3625,7 +3638,7 @@ export class StorageManager {
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
     } = {},
-  ): Promise<string> {
+  ): Promise<MemoryWriteResult> {
     await this.ensureDirectories();
     const now = new Date();
     const today = now.toISOString().slice(0, 10);
@@ -3835,7 +3848,7 @@ export class StorageManager {
       }
     }
     log.debug(`wrote memory ${id} to ${filePath}`);
-    return id;
+    return { id, tombstoneBlocked, ...(fm.blockedBy ? { blockedBy: fm.blockedBy } : {}) };
   }
 
   async hasFactContentHash(content: string): Promise<boolean> {
@@ -7359,6 +7372,13 @@ export class StorageManager {
       validAt?: string;
       /** Lifecycle status (issue #1576): pending_review chunks stay out of active recall. */
       status?: import("./types.js").MemoryStatus;
+      /**
+       * Tombstone block provenance (issue #1645): when the parent fact was
+       * tombstone-blocked, propagate the tombstone id onto each chunk so an
+       * independently-surfaced chunk (memory_get/x-ray/doctor) reveals the block
+       * and the chunk stays pending_review, never an active resurrection.
+       */
+      blockedBy?: string;
       /** Faithfulness gate verdict (issue #1576), propagated from the parent fact. */
       faithfulness?: import("./types.js").FaithfulnessFrontmatter;
       /** Claim-level provenance spans (issue #1575 PR 2), propagated from the parent fact so a chunk surfaced independently (memory_get/x-ray) preserves them (chatgpt-codex-connector thread Ocvmo). */
@@ -7406,6 +7426,7 @@ export class StorageManager {
       observedAt: chunkObservedAt,
       eventTimeSource: options.eventTimeSource,
       ...(options.status ? { status: options.status } : {}),
+      ...(options.blockedBy ? { blockedBy: options.blockedBy } : {}),
       ...(options.faithfulness ? { faithfulness: options.faithfulness } : {}),
       ...(options.sources ? { sources: options.sources } : {}),
       ...(options.provenance ? { provenance: options.provenance } : {}),

package/src/temporal-supersession.test.ts

@@ -46,13 +46,14 @@ async function writeFact(
   entityRef: string,
   attrs: Record<string, string>,
 ): Promise<string> {
-  return storage.writeMemory("fact", content, {
+  const { id } = await storage.writeMemory("fact", content, {
     entityRef,
     structuredAttributes: attrs,
     source: "test",
     confidence: 0.9,
     tags: [],
   });
+  return id;
 }
 
 async function readFrontmatterById(
@@ -328,7 +329,7 @@ test("applyTemporalSupersession: retires child chunks with superseded parent", a
   try {
     const oldValidAt = "2026-01-01T00:00:00.000Z";
     const newValidAt = "2026-02-01T00:00:00.000Z";
-    const oldParent = await storage.writeMemory(
+    const { id: oldParent } = await storage.writeMemory(
       "fact",
       "project X is based in Austin. ".repeat(40),
       {
@@ -355,7 +356,7 @@ test("applyTemporalSupersession: retires child chunks with superseded parent", a
       },
     );
 
-    const newParent = await storage.writeMemory(
+    const { id: newParent } = await storage.writeMemory(
       "fact",
       "project X relocated to NYC",
       {
@@ -396,7 +397,7 @@ test("applyTemporalSupersession: retires child chunks with superseded parent", a
 test("applyTemporalSupersession: no structured attributes is a no-op", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const oldFact = await storage.writeMemory(
+    const { id: oldFact } = await storage.writeMemory(
       "fact",
       "project X is based in Austin",
       {
@@ -407,7 +408,7 @@ test("applyTemporalSupersession: no structured attributes is a no-op", async ()
       },
     );
     await new Promise((resolve) => setTimeout(resolve, 5));
-    const newFact = await storage.writeMemory(
+    const { id: newFact } = await storage.writeMemory(
       "fact",
       "project X uses vim",
       {
@@ -2419,7 +2420,7 @@ test("StorageManager: writing same enriched content twice does not create duplic
     const attrs = { city: "Denver" };
 
     // First write.
-    const id1 = await storage.writeMemory("fact", rawContent, {
+    const { id: id1 } = await storage.writeMemory("fact", rawContent, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrs,
       source: "test",
@@ -2491,7 +2492,7 @@ test("StorageManager: hash-dedup catch fall-through — write proceeds when look
 
     // Simulate the fall-through path: when lookup fails the orchestrator falls
     // through to writeMemory.  Write the fact directly as the orchestrator would.
-    const id = await storage.writeMemory("fact", rawContent, {
+    const { id: id } = await storage.writeMemory("fact", rawContent, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrs,
       source: "test",
@@ -2546,14 +2547,14 @@ test("StorageManager: enriched-hash matching selects correct candidate when two
     const enrichedB = `${rawContent}\n[Attributes: ${Object.entries(attrsB).map(([k, v]) => `${k}: ${v}`).join("; ")}]`;
 
     // Write both facts.
-    const idA = await storage.writeMemory("fact", rawContent, {
+    const { id: idA } = await storage.writeMemory("fact", rawContent, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrsA,
       source: "test",
       confidence: 0.9,
       tags: [],
     });
-    const idB = await storage.writeMemory("fact", rawContent, {
+    const { id: idB } = await storage.writeMemory("fact", rawContent, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrsB,
       source: "test",
@@ -2663,7 +2664,7 @@ test("normalizeAttributePairs: writeMemory hash-dedup stable across key orders",
     const attrsFwd = { city: "Seattle", country: "USA" };
     const attrsRev = { country: "USA", city: "Seattle" }; // reversed
 
-    const id1 = await storage.writeMemory("fact", content, {
+    const { id: id1 } = await storage.writeMemory("fact", content, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrsFwd,
       source: "test",
@@ -2728,7 +2729,7 @@ test("normalizeAttributePairs + sanitizeMemoryContent: normalizedIncoming uses s
     const cleanContent = "Alice lives in Seattle";
     const attrs = { city: "Seattle", state: "WA" };
 
-    const id1 = await storage.writeMemory("fact", cleanContent, {
+    const { id: id1 } = await storage.writeMemory("fact", cleanContent, {
       entityRef: TEST_ENTITY,
       structuredAttributes: attrs,
       source: "test",

package/src/temporal-validity.test.ts

@@ -66,7 +66,7 @@ test("storage: valid_at / invalid_at round-trip exactly when set", async () => {
   try {
     const validAt = "2025-01-01T00:00:00.000Z";
     const invalidAt = "2026-01-01T00:00:00.000Z";
-    const id = await storage.writeMemory("fact", "project X is based in Austin", {
+    const { id: id } = await storage.writeMemory("fact", "project X is based in Austin", {
       entityRef: TEST_ENTITY,
       structuredAttributes: { city: "Austin" },
       source: "test",
@@ -95,7 +95,7 @@ test("storage: valid_at / invalid_at round-trip exactly when set", async () => {
 test("storage: writeMemory persists explicit validAt as valid_at", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const id = await storage.writeMemory(
+    const { id: id } = await storage.writeMemory(
       "fact",
       "project X launched from the source transcript",
       {
@@ -135,7 +135,7 @@ test("storage: writeMemory rejects invalid validAt values", async () => {
 test("storage: legacy memories without valid_at parse as undefined (no backfill)", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const id = await storage.writeMemory("fact", "legacy memory", {
+    const { id: id } = await storage.writeMemory("fact", "legacy memory", {
       entityRef: TEST_ENTITY,
       source: "test",
       confidence: 0.9,
@@ -176,7 +176,7 @@ test("effectiveValidAt: whitespace-only valid_at falls back to created", () => {
 test("supersession: new fact propagates valid_at to old fact's invalid_at", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const oldId = await storage.writeMemory(
+    const { id: oldId } = await storage.writeMemory(
       "fact",
       "project X is based in Austin",
       {
@@ -188,7 +188,7 @@ test("supersession: new fact propagates valid_at to old fact's invalid_at", asyn
       },
     );
     await new Promise((r) => setTimeout(r, 5));
-    const newId = await storage.writeMemory(
+    const { id: newId } = await storage.writeMemory(
       "fact",
       "project X relocated to NYC",
       {
@@ -242,7 +242,7 @@ test("supersession: older source-valid replay fact does not supersede newer sour
     const newerValidAt = "2025-01-02T00:00:00.000Z";
     const olderValidAt = "2025-01-01T00:00:00.000Z";
 
-    const newerId = await storage.writeMemory(
+    const { id: newerId } = await storage.writeMemory(
       "fact",
       "project X moved to NYC",
       {
@@ -255,7 +255,7 @@ test("supersession: older source-valid replay fact does not supersede newer sour
       },
     );
     await new Promise((r) => setTimeout(r, 5));
-    const olderId = await storage.writeMemory(
+    const { id: olderId } = await storage.writeMemory(
       "fact",
       "project X was previously based in Austin",
       {
@@ -292,7 +292,7 @@ test("supersession: older source-valid replay fact does not supersede newer sour
 test("supersession: when superseder has no valid_at, falls back to persisted created", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const oldId = await storage.writeMemory(
+    const { id: oldId } = await storage.writeMemory(
       "fact",
       "project X is based in Austin",
       {
@@ -304,7 +304,7 @@ test("supersession: when superseder has no valid_at, falls back to persisted cre
       },
     );
     await new Promise((r) => setTimeout(r, 5));
-    const newId = await storage.writeMemory(
+    const { id: newId } = await storage.writeMemory(
       "fact",
       "project X relocated to NYC",
       {
@@ -341,7 +341,7 @@ test("supersession: when superseder has no valid_at, falls back to persisted cre
 test("supersession: existing invalid_at is preserved (idempotent)", async () => {
   const { storage, cleanup } = await makeStorage();
   try {
-    const oldId = await storage.writeMemory("fact", "old fact", {
+    const { id: oldId } = await storage.writeMemory("fact", "old fact", {
       entityRef: TEST_ENTITY,
       structuredAttributes: { city: "Austin" },
       source: "test",
@@ -359,7 +359,7 @@ test("supersession: existing invalid_at is preserved (idempotent)", async () =>
     });
 
     await new Promise((r) => setTimeout(r, 5));
-    const newId = await storage.writeMemory("fact", "new fact", {
+    const { id: newId } = await storage.writeMemory("fact", "new fact", {
       entityRef: TEST_ENTITY,
       structuredAttributes: { city: "NYC" },
       source: "test",

package/src/wearables/cli.test.ts

@@ -52,6 +52,7 @@ function stubService(overrides: Partial<Record<keyof WearablesService, unknown>>
         transcriptsWritten: ["2026-06-11"],
         memoriesCreated: 2,
         memoriesSkipped: 4,
+        memoriesBlocked: 0,
         nativeMemoriesImported: 0,
         warnings: ["something minor"],
       },
@@ -114,6 +115,35 @@ test("status renders sources and respects --json", async () => {
   assert.equal(parsed.enabled, true);
 });
 
+test("sync renders a memories blocked line when writes are tombstone-blocked (#1645)", async () => {
+  const { io, out } = makeIo();
+  const service = stubService({
+    sync: async () => [
+      {
+        source: "limitless",
+        days: ["2026-06-11"],
+        conversations: 1,
+        segmentsKept: 4,
+        segmentsDropped: 0,
+        redactions: 0,
+        correctionsApplied: 0,
+        transcriptsWritten: ["2026-06-11"],
+        memoriesCreated: 0,
+        memoriesPromoted: 0,
+        memoriesDemoted: 0,
+        memoriesSkipped: 0,
+        memoriesBlocked: 2,
+        nativeMemoriesImported: 0,
+        warnings: [],
+      },
+    ],
+  });
+  assert.equal(await runWearablesCliCommand(service, ["sync"], io), 0);
+  const text = out.join("");
+  assert.match(text, /memories blocked:\s+2/);
+  assert.doesNotMatch(text, /memories created:\s+[1-9]/, "no blocked write counted as created");
+});
+
 test("sync renders the summary including warnings", async () => {
   const { io, out } = makeIo();
   assert.equal(await runWearablesCliCommand(stubService(), ["sync"], io), 0);

package/src/wearables/cli.ts

@@ -131,6 +131,9 @@ function renderSyncSummary(summary: WearableSyncSummary): string {
   if (summary.memoriesDemoted > 0) {
     lines.push(`  memories demoted:       ${summary.memoriesDemoted}`);
   }
+  if (summary.memoriesBlocked > 0) {
+    lines.push(`  memories blocked:       ${summary.memoriesBlocked}`);
+  }
   if (summary.nativeMemoriesImported > 0) {
     lines.push(`  native memories queued: ${summary.nativeMemoriesImported}`);
   }

package/src/wearables/memory-gen.test.ts

@@ -79,7 +79,7 @@ function makeWriter(existingHashes: string[] = []): {
     writer: {
       async writeMemory(category, content, options) {
         writes.push({ category, content, options: options as Record<string, unknown> });
-        return `id-${writes.length}`;
+        return { id: `id-${writes.length}`, tombstoneBlocked: false };
       },
       async hasFactContentHash(content) {
         return existing.has(content);
@@ -755,3 +755,59 @@ test("native memories always import as pending_review and respect prior imports"
   assert.equal(writes[0].options.source, "wearable:bee:native");
   assert.deepEqual(result.importedIds.sort(), ["n1", "n2", "n3"]);
 });
+
+
+test("#1645: a tombstone-blocked wearable write counts as blocked, not created", async () => {
+  // The writer returns tombstoneBlocked: true — the #1579 chokepoint downgraded
+  // the write to pending_review (no active copy). The day-write loop must count
+  // it as blocked, NOT created, so the sync summary and callers don't report
+  // blocked content as successfully created active memories.
+  const writes: Array<{ category: string; content: string; options: Record<string, unknown> }> = [];
+  const writer: WearableMemoryWriter = {
+    async writeMemory(category, content, options) {
+      writes.push({ category, content, options: options as Record<string, unknown> });
+      return { id: `id-${writes.length}`, tombstoneBlocked: true, blockedBy: "tomb-1" };
+    },
+    async hasFactContentHash() {
+      return false;
+    },
+  };
+  const result = await generateWearableMemories(
+    "limitless",
+    "2026-06-10",
+    [LONG_CONVERSATION],
+    settings(),
+    REGISTRY,
+    {
+      extract: extractionReturning([
+        { category: "decision", content: "Launch moved to September 12.", confidence: 0.9, tags: ["launch"] },
+      ]),
+      writer,
+    },
+  );
+  assert.equal(writes.length, 1, "the write still happens (pending_review row)");
+  assert.equal(result.created, 0, "blocked write must NOT count as created");
+  assert.equal(result.tombstoneBlocked, 1, "blocked write counted separately");
+});
+
+
+test("#1645: a tombstone-blocked native import counts as blocked, not imported", async () => {
+  const writer: WearableMemoryWriter = {
+    async writeMemory() {
+      return { id: "blocked-native-1", tombstoneBlocked: true, blockedBy: "tomb-1" };
+    },
+    async hasFactContentHash() {
+      return false;
+    },
+  };
+  const result = await importNativeMemories(
+    "bee",
+    [{ id: "n1", content: "A native fact that matches a tombstone.", createdIso: "2026-06-10T10:00:00Z" }],
+    new Set(),
+    settings({ importNativeMemories: "review" }),
+    { extract: extractionReturning([]), writer },
+  );
+  assert.equal(result.imported, 0, "blocked native import must NOT count as imported");
+  assert.equal(result.tombstoneBlocked, 1, "blocked native import counted separately");
+  assert.deepEqual(result.importedIds, ["n1"], "provider id still recorded to prevent duplicate re-import");
+});

package/src/wearables/memory-gen.ts

@@ -28,6 +28,7 @@
  */
 
 import { scoreImportance } from "../importance.js";
+import type { MemoryWriteResult } from "../storage.js";
 import type { JudgeBatchResult, JudgeCandidate } from "../extraction-judge.js";
 import { getVerdictKind } from "../extraction-judge.js";
 import { describeErrorForOperator } from "./errors.js";
@@ -82,7 +83,7 @@ export interface WearableMemoryWriter {
       status?: MemoryStatus;
       memoryKind?: "episode" | "note" | "box" | "dream" | "procedural";
     },
-  ): Promise<string>;
+  ): Promise<MemoryWriteResult>;
   hasFactContentHash(content: string): Promise<boolean>;
   /**
    * Locate an earlier wearable write of the same content (any status).
@@ -131,6 +132,12 @@ export interface WearableMemoryGenDeps {
 
 export interface WearableMemoryGenResult {
   created: number;
+  /**
+   * Writes the #1579 tombstone chokepoint downgraded to pending_review (no
+   * active copy). Surfaced distinctly from `created` so sync summaries and
+   * callers don't count blocked content as successfully created (#1645).
+   */
+  tombstoneBlocked: number;
   /** Earlier borderline writes promoted to active by new evidence. */
   promoted: number;
   /** Earlier pending writes retired by a fresh judge-reject verdict. */
@@ -309,6 +316,7 @@ export async function generateWearableMemories(
 ): Promise<WearableMemoryGenResult> {
   const result: WearableMemoryGenResult = {
     created: 0,
+    tombstoneBlocked: 0,
     promoted: 0,
     demoted: 0,
     skipped: 0,
@@ -565,7 +573,7 @@ export async function generateWearableMemories(
         wearableDayTag(date),
       ]),
     ];
-    await deps.writer.writeMemory(candidate.fact.category, candidate.fact.content, {
+    const writeResult = await deps.writer.writeMemory(candidate.fact.category, candidate.fact.content, {
       confidence:
         settings.memoryMode === "smart"
           ? trustById.get(index)?.trust
@@ -584,7 +592,14 @@ export async function generateWearableMemories(
       contentHashSource: candidate.fact.content,
       status,
     });
-    result.created += 1;
+    // #1645: a tombstone-blocked wearable write lands pending_review (no active
+    // copy) — count it as blocked, NOT created, so the sync summary and callers
+    // don't report blocked content as successfully created active memories.
+    if (writeResult.tombstoneBlocked) {
+      result.tombstoneBlocked += 1;
+    } else {
+      result.created += 1;
+    }
   }
   return result;
 }
@@ -654,8 +669,9 @@ export async function importNativeMemories(
   alreadyImportedIds: ReadonlySet<string>,
   settings: WearableSourceSettings,
   deps: WearableMemoryGenDeps,
-): Promise<{ imported: number; importedIds: string[]; warnings: string[] }> {
+): Promise<{ imported: number; tombstoneBlocked: number; importedIds: string[]; warnings: string[] }> {
   let imported = 0;
+  let tombstoneBlocked = 0;
   const importedIds: string[] = [];
   const warnings: string[] = [];
   const seenContent = new Set<string>();
@@ -743,7 +759,7 @@ export async function importNativeMemories(
           : {}),
       };
     }
-    await deps.writer.writeMemory("fact", content, {
+    const nativeWriteResult = await deps.writer.writeMemory("fact", content, {
       confidence,
       tags: [
         ...new Set([
@@ -764,8 +780,16 @@ export async function importNativeMemories(
       contentHashSource: content,
       status,
     });
-    imported += 1;
+    // #1645: a tombstone-blocked native import lands pending_review (no active
+    // copy) — count it as blocked, NOT imported. Still record the provider id in
+    // importedIds so the next sync doesn't re-import and duplicate the pending
+    // row; the block is permanent for this content.
+    if (nativeWriteResult.tombstoneBlocked) {
+      tombstoneBlocked += 1;
+    } else {
+      imported += 1;
+    }
     importedIds.push(memory.id);
   }
-  return { imported, importedIds, warnings };
+  return { imported, tombstoneBlocked, importedIds, warnings };
 }