@remnic/core 10.0.67 → 10.0.69

package/dist/{chunk-LFYEQK45.js → chunk-DDBB55L2.js}

@@ -5042,221 +5042,6 @@ async function persistUnderFactDedupWindow(storageDir, recheck, write) {
   );
 }
 
-// src/orchestration/extraction-injection-gate.ts
-function serializeInjectionScreenCandidate(candidate) {
-  const body = candidate.category === "procedure" ? buildProcedurePersistBody(candidate.content, candidate.procedureSteps) : candidate.content;
-  const attrs = Object.fromEntries(
-    Object.entries(candidate.structuredAttributes ?? {}).flatMap(([key, value]) => {
-      if (typeof value === "string") return [[key, value]];
-      if (typeof value === "number" || typeof value === "boolean") return [[key, String(value)]];
-      return [];
-    })
-  );
-  return Object.keys(attrs).length > 0 ? `${body}
-[Attributes: ${normalizeAttributePairs(attrs)}]` : body;
-}
-function evaluateInjectionScreen(candidate, enabled, profile = "default") {
-  if (!enabled) return { tags: [] };
-  const content = typeof candidate === "string" ? candidate : serializeInjectionScreenCandidate(candidate);
-  const result = screenCandidateFact(content, profile);
-  return {
-    status: result.quarantine === true ? "pending_review" : void 0,
-    tags: result.quarantine === true ? result.findings.map((finding) => `injection-screen:${finding.rule}`) : []
-  };
-}
-function withholdScreenedStrings(values, enabled, profile = "default") {
-  const kept = [];
-  const withheldRules = [];
-  for (const value of values) {
-    if (typeof value !== "string") continue;
-    if (!enabled) {
-      kept.push(value);
-      continue;
-    }
-    const screened = screenCandidateFact(value, profile);
-    if (screened.quarantine) {
-      withheldRules.push(...screened.findings.map((finding) => `injection-screen:${finding.rule}`));
-    } else {
-      kept.push(value);
-    }
-  }
-  return { kept, withheldRules };
-}
-function screenEntityForIndex(entity, enabled, profile = "default") {
-  const record = entity;
-  const name = record?.name;
-  const type = record?.type;
-  if (typeof name !== "string" || !name.trim() || typeof type !== "string" || !type.trim()) return null;
-  const nameScreen = withholdScreenedStrings([name], enabled, profile);
-  const factScreen = withholdScreenedStrings(Array.isArray(record?.facts) ? record.facts : [], enabled, profile);
-  const rawSections = Array.isArray(record?.structuredSections) ? record.structuredSections : void 0;
-  const sectionScreens = enabled && rawSections ? rawSections.map((section) => ({ section, screen: withholdScreenedStrings(section?.facts ?? [], true, profile) })) : void 0;
-  return {
-    name,
-    type,
-    source: typeof record?.source === "string" ? record.source : "extraction",
-    facts: factScreen.kept,
-    ...sectionScreens ? {
-      structuredSections: sectionScreens.map(({ section, screen }) => {
-        let nextFactIndex = 0;
-        const factOrigins = screen.kept.map((fact) => {
-          const factIndex = section.facts.indexOf(fact, nextFactIndex);
-          nextFactIndex = factIndex + 1;
-          const origin = section.factOrigins?.[factIndex];
-          return origin === void 0 ? void 0 : parseOriginClass(origin);
-        });
-        return {
-          ...section,
-          facts: screen.kept,
-          ...factOrigins.some((origin) => origin !== void 0) ? { factOrigins } : {}
-        };
-      })
-    } : rawSections ? { structuredSections: rawSections } : {},
-    withheldRules: [
-      ...nameScreen.withheldRules,
-      ...factScreen.withheldRules,
-      ...(sectionScreens ?? []).flatMap(({ screen }) => screen.withheldRules)
-    ],
-    withheld: nameScreen.withheldRules.length > 0
-  };
-}
-function screenPersistStrings(values, enabled, profile = "default") {
-  const screen = withholdScreenedStrings(values, enabled, profile);
-  return {
-    kept: screen.kept,
-    ...screen.withheldRules.length > 0 ? { warning: `injection screen withheld ${values.length - screen.kept.length} candidate(s) [${screen.withheldRules.join(", ")}]` } : {}
-  };
-}
-
-// src/orchestration/extraction-envelope.ts
-function composeSalvagedExtractionEnvelope(input, ctx) {
-  const envelope = composeMemoryEnvelope(input, ctx, { salvage: true });
-  if (envelope.salvageNotes.length > 0) {
-    log.warn(`extraction write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
-  }
-  return envelope;
-}
-function withReservedMarkerTag(sourceTags, marker) {
-  const usable = sourceTags.filter(
-    (tag) => typeof tag !== "string" || tag.trim().length <= TAG_LIMITS.maxTagLength
-  );
-  const normalized = normalizeTags(usable) ?? [];
-  const budget = TAG_LIMITS.maxTags - 1;
-  if (normalized.length > budget) {
-    log.warn(
-      `extraction tags exceed ${budget}+marker cap; keeping the first ${budget} of ${normalized.length} and the ${JSON.stringify(marker)} marker`
-    );
-  }
-  const capped = normalized.length > budget ? normalized.slice(0, budget) : normalized;
-  return [...capped, marker];
-}
-function probeSalvageSurvivingFields(input) {
-  try {
-    const probe = composeSalvagedExtractionEnvelope(
-      {
-        content: input.content,
-        category: input.category,
-        structuredAttributes: input.structuredAttributes,
-        entityRef: input.entityRef
-      },
-      { source: "bitemporal-backfill-probe" }
-    );
-    return {
-      entityRef: probe.entityRef,
-      structuredAttributes: probe.rawStructuredAttributes ? { ...probe.rawStructuredAttributes } : void 0
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/dedup/semantic.ts
-var DEFAULT_SEMANTIC_THRESHOLD = 0.92;
-var DEFAULT_SEMANTIC_CANDIDATES = 5;
-function normalizeSemanticThreshold(value) {
-  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : DEFAULT_SEMANTIC_THRESHOLD;
-}
-function normalizeSemanticCandidates(value) {
-  if (!Number.isFinite(value) || value < 0) {
-    return DEFAULT_SEMANTIC_CANDIDATES;
-  }
-  const normalized = Math.floor(value);
-  return value > 0 && normalized === 0 ? 1 : normalized;
-}
-async function decideSemanticDedup(content, lookup, options) {
-  if (!options.enabled) {
-    return { action: "keep", reason: "disabled" };
-  }
-  const threshold = normalizeSemanticThreshold(options.threshold);
-  const candidates = normalizeSemanticCandidates(options.candidates);
-  if (candidates === 0) {
-    return { action: "keep", reason: "disabled" };
-  }
-  const trimmed = typeof content === "string" ? content.trim() : "";
-  if (!trimmed) {
-    return { action: "keep", reason: "no_near_duplicate" };
-  }
-  let hits = [];
-  try {
-    hits = await lookup(trimmed, candidates);
-  } catch {
-    return { action: "keep", reason: "backend_unavailable" };
-  }
-  if (!Array.isArray(hits) || hits.length === 0) {
-    return { action: "keep", reason: "no_candidates" };
-  }
-  const candidateConnector = normalizeConnectorScope(options.sourceConnector);
-  let top;
-  let sameConnectorTop;
-  for (const hit of hits) {
-    if (!hit || typeof hit.id !== "string" || hit.id.trim().length === 0 || typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
-      continue;
-    }
-    if (!top || hit.score > top.score) {
-      top = hit;
-    }
-    if (candidateConnector !== void 0 && connectorMatchesScope(hit.sourceConnector, candidateConnector) && (!sameConnectorTop || hit.score > sameConnectorTop.score)) {
-      sameConnectorTop = hit;
-    }
-  }
-  if (!top) {
-    return { action: "keep", reason: "no_near_duplicate" };
-  }
-  if (top.score >= threshold) {
-    if (candidateConnector !== void 0) {
-      const match = sameConnectorTop !== void 0 && sameConnectorTop.score >= threshold ? sameConnectorTop : void 0;
-      if (match) {
-        return {
-          action: "skip",
-          reason: "near_duplicate",
-          topScore: match.score,
-          topId: match.id,
-          topPath: match.path
-        };
-      }
-      return {
-        action: "keep",
-        reason: "connector_mismatch",
-        topScore: top.score,
-        topId: top.id
-      };
-    }
-    return {
-      action: "skip",
-      reason: "near_duplicate",
-      topScore: top.score,
-      topId: top.id,
-      topPath: top.path
-    };
-  }
-  return {
-    action: "keep",
-    reason: "no_near_duplicate",
-    topScore: top.score,
-    topId: top.id
-  };
-}
-
 // src/orchestration/semantic-merge-promotion-payload.ts
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
@@ -5717,6 +5502,356 @@ async function retireStaleMergedTargetPromotionCopies(args) {
   return retired;
 }
 
+// src/orchestration/promotion-dedup-window.ts
+async function findPromotionRaceDuplicate(args) {
+  try {
+    const allMems = await readActiveMemoriesBothTiers(args.storage);
+    const nc = args.connector?.trim() || void 0;
+    const incomingNormalized = ContentHashIndex.normalizeContent(args.dedupContent);
+    return allMems.find((m) => {
+      if (m.frontmatter.category !== args.category) return false;
+      if ((m.frontmatter.status ?? "active") !== "active") return false;
+      if (normalizeStoredHashSource(m.content ?? "", args.citationEnabled, args.citationTemplate) !== incomingNormalized)
+        return false;
+      if (args.entityKeyNorm !== void 0) {
+        if (!m.frontmatter.entityRef) return false;
+        if (normalizeSupersessionKey(m.frontmatter.entityRef) !== args.entityKeyNorm) return false;
+      }
+      return (m.frontmatter.sourceConnector?.trim() || void 0) === nc;
+    });
+  } catch (err) {
+    log.warn(
+      `promotion race recheck scan failed for ${args.storage.dir}; writing fail-open: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+}
+async function confirmPromotionRaceDuplicate(args) {
+  try {
+    if (await args.storage.isFactContentHashAuthoritative()) {
+      if (!await args.storage.hasFactContentHash(args.dedupContent)) return false;
+    }
+  } catch (probeErr) {
+    log.warn(
+      `promotion race recheck authoritative probe failed for ${args.storage.dir}; confirming against corpus: ${probeErr instanceof Error ? probeErr.message : String(probeErr)}`
+    );
+  }
+  return await findPromotionRaceDuplicate(args) !== void 0;
+}
+function buildPromotionWriteOptions(args) {
+  const { promotion } = args;
+  const writeOptions = {
+    importance: promotion.importance,
+    lineage: [promotion.sourceMemoryId],
+    sourceMemoryId: promotion.sourceMemoryId,
+    intentGoal: promotion.intentGoal,
+    intentActionType: promotion.intentActionType,
+    intentEntityTypes: promotion.intentEntityTypes,
+    memoryKind: promotion.memoryKind,
+    contentHashSource: promotion.category === "fact" ? args.dedupContent : args.rawContent
+  };
+  if (promotion.invalidAt) writeOptions.invalidAt = promotion.invalidAt;
+  if (promotion.observedAt) writeOptions.observedAt = promotion.observedAt;
+  if (promotion.eventTimeSource) writeOptions.eventTimeSource = promotion.eventTimeSource;
+  if (promotion.sources && promotion.sources.length > 0) writeOptions.sources = promotion.sources;
+  if (promotion.provenance) writeOptions.provenance = promotion.provenance;
+  if (args.toolScoped) writeOptions.toolScoped = true;
+  return writeOptions;
+}
+async function writePromotionUnderFactDedupWindow(args) {
+  const { destination, envelope, promotion } = args;
+  if (promotion.category !== "fact") {
+    return {
+      suppressed: false,
+      result: await destination.writeSealedMemory(envelope, buildPromotionWriteOptions(args))
+    };
+  }
+  const entityKeyNorm = args.sameEntityGuardEnabled && envelope.entityRef && args.survivingAttrs && Object.keys(args.survivingAttrs).length > 0 ? normalizeSupersessionKey(envelope.entityRef) : void 0;
+  const outcome = await persistUnderFactDedupWindow(
+    destination.dir,
+    () => promotion.category === "fact" ? confirmPromotionRaceDuplicate({
+      storage: destination,
+      dedupContent: args.dedupContent,
+      category: promotion.category,
+      connector: args.connector,
+      citationEnabled: args.citationEnabled,
+      citationTemplate: args.citationTemplate,
+      entityKeyNorm
+    }) : Promise.resolve(false),
+    () => destination.writeSealedMemory(envelope, buildPromotionWriteOptions(args))
+  );
+  if (outcome.suppressed) {
+    log.info(`dedup: raced promotion duplicate suppressed in fact-dedup window for ${destination.dir}`);
+    if (promotion.invalidAt || promotion.validAt) {
+      await args.backfillTemporalBoundsOnDedupHit(
+        destination,
+        args.dedupContent,
+        {
+          invalidAt: promotion.invalidAt,
+          // #1707 thread 2 — carry the corrected start bound.
+          validFrom: promotion.validAt,
+          observedAt: promotion.observedAt,
+          eventTimeSource: promotion.eventTimeSource
+        },
+        envelope.entityRef,
+        args.connector
+      );
+    }
+    if (args.supersession?.supersessionEnabled && promotion.category === "fact" && envelope.entityRef && args.survivingAttrs && Object.keys(args.survivingAttrs).length > 0) {
+      try {
+        const winning = await findPromotionRaceDuplicate({
+          storage: destination,
+          dedupContent: args.dedupContent,
+          category: promotion.category,
+          connector: args.connector,
+          citationEnabled: args.citationEnabled,
+          citationTemplate: args.citationTemplate,
+          // PRRT_kwDORJXyws6z2o11: the winner ANCHORS the pass, so the lookup
+          // is always entity-guarded — without it (profile path) it could
+          // match another entity's equal-content fact and combine that fact's
+          // id with the incoming entity's attributes (PR #402 Uybg hazard).
+          entityKeyNorm: normalizeSupersessionKey(envelope.entityRef)
+        });
+        if (winning) {
+          await applyTemporalSupersession({
+            storage: destination,
+            newMemoryId: winning.frontmatter.id,
+            entityRef: envelope.entityRef,
+            structuredAttributes: { ...args.survivingAttrs },
+            // Ordering anchor mirrors the gate's supersessionOrderingAt: an
+            // incoming event date orders the pass, wall clock otherwise.
+            createdAt: promotion.validAt && promotion.validAt.length > 0 ? promotion.validAt : (/* @__PURE__ */ new Date()).toISOString(),
+            useCallerTimestamp: true,
+            enabled: !(promotion.eventTimeSource === "extracted" && !promotion.validAt),
+            namespaceScope: args.supersession.namespaceScope,
+            dependencyPropagationDelivery: args.supersession.dependencyPropagationDelivery
+          });
+        }
+      } catch (supersessionErr) {
+        log.warn(
+          `promotion window supersession failed open for ${destination.dir}: ${supersessionErr instanceof Error ? supersessionErr.message : String(supersessionErr)}`
+        );
+      }
+    }
+  }
+  return outcome;
+}
+
+// src/orchestration/extraction-injection-gate.ts
+function serializeInjectionScreenCandidate(candidate) {
+  const body = candidate.category === "procedure" ? buildProcedurePersistBody(candidate.content, candidate.procedureSteps) : candidate.content;
+  const attrs = Object.fromEntries(
+    Object.entries(candidate.structuredAttributes ?? {}).flatMap(([key, value]) => {
+      if (typeof value === "string") return [[key, value]];
+      if (typeof value === "number" || typeof value === "boolean") return [[key, String(value)]];
+      return [];
+    })
+  );
+  return Object.keys(attrs).length > 0 ? `${body}
+[Attributes: ${normalizeAttributePairs(attrs)}]` : body;
+}
+function evaluateInjectionScreen(candidate, enabled, profile = "default") {
+  if (!enabled) return { tags: [] };
+  const content = typeof candidate === "string" ? candidate : serializeInjectionScreenCandidate(candidate);
+  const result = screenCandidateFact(content, profile);
+  return {
+    status: result.quarantine === true ? "pending_review" : void 0,
+    tags: result.quarantine === true ? result.findings.map((finding) => `injection-screen:${finding.rule}`) : []
+  };
+}
+function withholdScreenedStrings(values, enabled, profile = "default") {
+  const kept = [];
+  const withheldRules = [];
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    if (!enabled) {
+      kept.push(value);
+      continue;
+    }
+    const screened = screenCandidateFact(value, profile);
+    if (screened.quarantine) {
+      withheldRules.push(...screened.findings.map((finding) => `injection-screen:${finding.rule}`));
+    } else {
+      kept.push(value);
+    }
+  }
+  return { kept, withheldRules };
+}
+function screenEntityForIndex(entity, enabled, profile = "default") {
+  const record = entity;
+  const name = record?.name;
+  const type = record?.type;
+  if (typeof name !== "string" || !name.trim() || typeof type !== "string" || !type.trim()) return null;
+  const nameScreen = withholdScreenedStrings([name], enabled, profile);
+  const factScreen = withholdScreenedStrings(Array.isArray(record?.facts) ? record.facts : [], enabled, profile);
+  const rawSections = Array.isArray(record?.structuredSections) ? record.structuredSections : void 0;
+  const sectionScreens = enabled && rawSections ? rawSections.map((section) => ({ section, screen: withholdScreenedStrings(section?.facts ?? [], true, profile) })) : void 0;
+  return {
+    name,
+    type,
+    source: typeof record?.source === "string" ? record.source : "extraction",
+    facts: factScreen.kept,
+    ...sectionScreens ? {
+      structuredSections: sectionScreens.map(({ section, screen }) => {
+        let nextFactIndex = 0;
+        const factOrigins = screen.kept.map((fact) => {
+          const factIndex = section.facts.indexOf(fact, nextFactIndex);
+          nextFactIndex = factIndex + 1;
+          const origin = section.factOrigins?.[factIndex];
+          return origin === void 0 ? void 0 : parseOriginClass(origin);
+        });
+        return {
+          ...section,
+          facts: screen.kept,
+          ...factOrigins.some((origin) => origin !== void 0) ? { factOrigins } : {}
+        };
+      })
+    } : rawSections ? { structuredSections: rawSections } : {},
+    withheldRules: [
+      ...nameScreen.withheldRules,
+      ...factScreen.withheldRules,
+      ...(sectionScreens ?? []).flatMap(({ screen }) => screen.withheldRules)
+    ],
+    withheld: nameScreen.withheldRules.length > 0
+  };
+}
+function screenPersistStrings(values, enabled, profile = "default") {
+  const screen = withholdScreenedStrings(values, enabled, profile);
+  return {
+    kept: screen.kept,
+    ...screen.withheldRules.length > 0 ? { warning: `injection screen withheld ${values.length - screen.kept.length} candidate(s) [${screen.withheldRules.join(", ")}]` } : {}
+  };
+}
+
+// src/orchestration/extraction-envelope.ts
+function composeSalvagedExtractionEnvelope(input, ctx) {
+  const envelope = composeMemoryEnvelope(input, ctx, { salvage: true });
+  if (envelope.salvageNotes.length > 0) {
+    log.warn(`extraction write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
+  }
+  return envelope;
+}
+function withReservedMarkerTag(sourceTags, marker) {
+  const usable = sourceTags.filter(
+    (tag) => typeof tag !== "string" || tag.trim().length <= TAG_LIMITS.maxTagLength
+  );
+  const normalized = normalizeTags(usable) ?? [];
+  const budget = TAG_LIMITS.maxTags - 1;
+  if (normalized.length > budget) {
+    log.warn(
+      `extraction tags exceed ${budget}+marker cap; keeping the first ${budget} of ${normalized.length} and the ${JSON.stringify(marker)} marker`
+    );
+  }
+  const capped = normalized.length > budget ? normalized.slice(0, budget) : normalized;
+  return [...capped, marker];
+}
+function probeSalvageSurvivingFields(input) {
+  try {
+    const probe = composeSalvagedExtractionEnvelope(
+      {
+        content: input.content,
+        category: input.category,
+        structuredAttributes: input.structuredAttributes,
+        entityRef: input.entityRef
+      },
+      { source: "bitemporal-backfill-probe" }
+    );
+    return {
+      entityRef: probe.entityRef,
+      structuredAttributes: probe.rawStructuredAttributes ? { ...probe.rawStructuredAttributes } : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/dedup/semantic.ts
+var DEFAULT_SEMANTIC_THRESHOLD = 0.92;
+var DEFAULT_SEMANTIC_CANDIDATES = 5;
+function normalizeSemanticThreshold(value) {
+  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : DEFAULT_SEMANTIC_THRESHOLD;
+}
+function normalizeSemanticCandidates(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return DEFAULT_SEMANTIC_CANDIDATES;
+  }
+  const normalized = Math.floor(value);
+  return value > 0 && normalized === 0 ? 1 : normalized;
+}
+async function decideSemanticDedup(content, lookup, options) {
+  if (!options.enabled) {
+    return { action: "keep", reason: "disabled" };
+  }
+  const threshold = normalizeSemanticThreshold(options.threshold);
+  const candidates = normalizeSemanticCandidates(options.candidates);
+  if (candidates === 0) {
+    return { action: "keep", reason: "disabled" };
+  }
+  const trimmed = typeof content === "string" ? content.trim() : "";
+  if (!trimmed) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  let hits = [];
+  try {
+    hits = await lookup(trimmed, candidates);
+  } catch {
+    return { action: "keep", reason: "backend_unavailable" };
+  }
+  if (!Array.isArray(hits) || hits.length === 0) {
+    return { action: "keep", reason: "no_candidates" };
+  }
+  const candidateConnector = normalizeConnectorScope(options.sourceConnector);
+  let top;
+  let sameConnectorTop;
+  for (const hit of hits) {
+    if (!hit || typeof hit.id !== "string" || hit.id.trim().length === 0 || typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
+      continue;
+    }
+    if (!top || hit.score > top.score) {
+      top = hit;
+    }
+    if (candidateConnector !== void 0 && connectorMatchesScope(hit.sourceConnector, candidateConnector) && (!sameConnectorTop || hit.score > sameConnectorTop.score)) {
+      sameConnectorTop = hit;
+    }
+  }
+  if (!top) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  if (top.score >= threshold) {
+    if (candidateConnector !== void 0) {
+      const match = sameConnectorTop !== void 0 && sameConnectorTop.score >= threshold ? sameConnectorTop : void 0;
+      if (match) {
+        return {
+          action: "skip",
+          reason: "near_duplicate",
+          topScore: match.score,
+          topId: match.id,
+          topPath: match.path
+        };
+      }
+      return {
+        action: "keep",
+        reason: "connector_mismatch",
+        topScore: top.score,
+        topId: top.id
+      };
+    }
+    return {
+      action: "skip",
+      reason: "near_duplicate",
+      topScore: top.score,
+      topId: top.id,
+      topPath: top.path
+    };
+  }
+  return {
+    action: "keep",
+    reason: "no_near_duplicate",
+    topScore: top.score,
+    topId: top.id
+  };
+}
+
 // src/orchestration/semantic-merge-persist.ts
 import path6 from "path";
 
@@ -6736,23 +6871,23 @@ var ExtractionPersistCoordinator = class {
               continue;
             }
           }
-          const targetPromotion = await targetStorage.writeSealedMemory(targetPromotionEnvelope, {
-            importance: options.importance,
-            lineage: [options.sourceMemoryId],
-            sourceMemoryId: options.sourceMemoryId,
-            intentGoal: options.intentGoal,
-            intentActionType: options.intentActionType,
-            intentEntityTypes: options.intentEntityTypes,
-            memoryKind: options.memoryKind,
-            // #1578 — forward bi-temporal bounds + ingestion provenance.
-            ...options.invalidAt ? { invalidAt: options.invalidAt } : {},
-            ...options.observedAt ? { observedAt: options.observedAt } : {},
-            ...options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {},
-            contentHashSource: options.category === "fact" ? dedupContent : rawContent,
-            ...options.sources && options.sources.length > 0 ? { sources: options.sources } : {},
-            ...options.provenance ? { provenance: options.provenance } : {},
-            ...options.toolScoped ? { toolScoped: true } : {}
+          const promotionWrite = await writePromotionUnderFactDedupWindow({
+            destination: targetStorage,
+            envelope: targetPromotionEnvelope,
+            promotion: options,
+            dedupContent,
+            rawContent,
+            toolScoped: options.toolScoped === true,
+            connector: sourceContext?.sourceConnector,
+            citationEnabled,
+            citationTemplate,
+            sameEntityGuardEnabled: false,
+            survivingAttrs: targetSurvivingAttrs,
+            supersession: { supersessionEnabled: lifecycleCaps.temporalSupersession, dependencyPropagationDelivery: this.dependencyPropagationDelivery, namespaceScope: this.deps.storageDirNamespace(targetStorage.dir) },
+            backfillTemporalBoundsOnDedupHit: this.deps.backfillTemporalBoundsOnDedupHit
           });
+          if (promotionWrite.suppressed) continue;
+          const targetPromotion = promotionWrite.result;
           const promotedId = targetPromotion.id;
           if (!targetPromotion.tombstoneBlocked && lifecycleCaps.temporalSupersession && options.category === "fact" && targetPromotionEnvelope.entityRef && targetSurvivingAttrs && Object.keys(targetSurvivingAttrs).length > 0) {
             try {
@@ -6956,24 +7091,23 @@ var ExtractionPersistCoordinator = class {
             }
           }
         }
-        const sharedPromotion = await sharedStorage.writeSealedMemory(sharedPromotionEnvelope, {
-          importance: options.importance,
-          lineage: [options.sourceMemoryId],
-          sourceMemoryId: options.sourceMemoryId,
-          intentGoal: options.intentGoal,
-          intentActionType: options.intentActionType,
-          intentEntityTypes: options.intentEntityTypes,
-          memoryKind: options.memoryKind,
-          // #1578 — forward bi-temporal bounds + ingestion provenance.
-          ...options.invalidAt ? { invalidAt: options.invalidAt } : {},
-          ...options.observedAt ? { observedAt: options.observedAt } : {},
-          ...options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {},
-          contentHashSource: options.category === "fact" ? dedupContent : rawContent,
-          // Claim-level provenance spans (issue #1575 PR 2).
-          ...options.sources && options.sources.length > 0 ? { sources: options.sources } : {},
-          ...options.provenance ? { provenance: options.provenance } : {},
-          ...toolScoped ? { toolScoped: true } : {}
+        const sharedWrite = await writePromotionUnderFactDedupWindow({
+          destination: sharedStorage,
+          envelope: sharedPromotionEnvelope,
+          promotion: options,
+          dedupContent,
+          rawContent,
+          toolScoped,
+          connector: sourceContext?.sourceConnector,
+          citationEnabled,
+          citationTemplate,
+          sameEntityGuardEnabled: lifecycleCaps.temporalSupersession,
+          survivingAttrs: sharedSurvivingAttrs,
+          supersession: { supersessionEnabled: lifecycleCaps.temporalSupersession, dependencyPropagationDelivery: this.dependencyPropagationDelivery, namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir) },
+          backfillTemporalBoundsOnDedupHit: this.deps.backfillTemporalBoundsOnDedupHit
         });
+        if (sharedWrite.suppressed) return promotedCopyId;
+        const sharedPromotion = sharedWrite.result;
         const promotedId = sharedPromotion.id;
         if (!sharedPromotion.tombstoneBlocked && lifecycleCaps.temporalSupersession && sharedPromotionEnvelope.entityRef && sharedSurvivingAttrs && Object.keys(sharedSurvivingAttrs).length > 0) {
           try {
@@ -8059,30 +8193,40 @@ var ExtractionPersistCoordinator = class {
       const factWriteOutcome = await persistUnderFactDedupWindow(
         targetStorage.dir,
         raceRecheck(targetStorage, contentHashDedupKey),
-        async () => targetStorage.writeSealedMemory(factWriteEnvelope, {
-          importance,
-          supersedes,
-          links: links.length > 0 ? links : void 0,
-          intentGoal: inferredIntent?.goal,
-          intentActionType: inferredIntent?.actionType,
-          intentEntityTypes: inferredIntent?.entityTypes,
-          memoryKind,
-          ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
-          contentHashSource: writeCategory === "fact" ? fact.content : void 0,
-          // Faithfulness gate (issue #1576).
-          ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
-          ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
-          // Claim-level provenance spans (issue #1575 PR 2). Carry verified
-          // sources + the coarse strength tag from the extraction validator
-          // through to frontmatter so they survive end-to-end.
-          ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
-          ...fact.provenance ? { provenance: fact.provenance } : {},
-          // PR #2016: never defer inside the commit window (chunked-path
-          // rule): a peer loading an authoritative index after the release
-          // must see this hash, or its recheck misses and duplicates it.
-          deferHashIndexSave: false,
-          ...factToolScoped ? { toolScoped: true } : {}
-        })
+        async () => {
+          const factWrite2 = await targetStorage.writeSealedMemory(factWriteEnvelope, {
+            importance,
+            supersedes,
+            links: links.length > 0 ? links : void 0,
+            intentGoal: inferredIntent?.goal,
+            intentActionType: inferredIntent?.actionType,
+            intentEntityTypes: inferredIntent?.entityTypes,
+            memoryKind,
+            ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
+            contentHashSource: writeCategory === "fact" ? fact.content : void 0,
+            // Faithfulness gate (issue #1576).
+            ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
+            ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
+            // Claim-level provenance spans (issue #1575 PR 2). Carry verified
+            // sources + the coarse strength tag from the extraction validator
+            // through to frontmatter so they survive end-to-end.
+            ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
+            ...fact.provenance ? { provenance: fact.provenance } : {},
+            // PR #2016: never defer inside the commit window (chunked-path
+            // rule): a peer loading an authoritative index after the release
+            // must see this hash, or its recheck misses and duplicates it.
+            deferHashIndexSave: false,
+            ...factToolScoped ? { toolScoped: true } : {}
+          });
+          if (!factWrite2.tombstoneBlocked) {
+            try {
+              await this.deps.addContentHashDedup(targetStorage, contentHashDedupKey);
+            } catch (err) {
+              log.warn(`content-hash dedup registration failed for memory ${factWrite2.id}: ${err}`);
+            }
+          }
+          return factWrite2;
+        }
       ).catch(finalizeOnWindowFailure);
       if (factWriteOutcome.suppressed) {
         await backfillDuplicateTemporalBounds();
@@ -8239,17 +8383,6 @@ var ExtractionPersistCoordinator = class {
             ...factToolScoped ? { toolScoped: true } : {}
           });
         }
-        try {
-          const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-          const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
-          if (!tombstoneBlocked) {
-            await this.deps.addContentHashDedup(targetStorage, hashRegisterKey);
-          }
-        } catch (err) {
-          log.warn(
-            `content-hash dedup registration failed for memory ${memoryId}: ${err}`
-          );
-        }
       } catch (err) {
         await finalizeCommittedWrites(true).catch(
           (finalizeErr) => log.warn(`committed-write finalization after post-write failure failed: ${finalizeErr}`)
@@ -31777,4 +31910,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-LFYEQK45.js.map
+//# sourceMappingURL=chunk-DDBB55L2.js.map