@remnic/plugin-openclaw 9.69.53 → 9.69.54

package/dist/index.js

@@ -17,7 +17,7 @@ import {
 import { loadDaySummaryPrompt } from "@remnic/core/day-summary";
 import OpenAI from "openai";
 import { createRequire } from "module";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { parseConfig } from "@remnic/core/config";
 import { initLogger, log as log8 } from "@remnic/core/logger";
 import {
@@ -31,9 +31,9 @@ import {
 import { beginCodexSubscriptionShutdown, getCodexSubscriptionRunnerForOwner, terminateActiveCodexSubscriptionChildren } from "@remnic/core";
 
 // ../../src/tools.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 import { Type as Type2 } from "@sinclair/typebox";
-import { indexMemoryAsync as indexMemoryAsync2, indexesExistAsync as indexesExistAsync2 } from "@remnic/core/temporal-index";
+import { indexMemoryAsync, indexesExistAsync } from "@remnic/core/temporal-index";
 
 // ../../src/explicit-capture.ts
 import {
@@ -59,105 +59,8 @@ function mergeInlineCaptureDedupeKeys(messageKeys, fallbackDedupeKeys = []) {
 
 // ../../src/tools.ts
 import { log } from "@remnic/core/logger";
-import { composeSalvagedEnvelope as composeSalvagedEnvelope2 } from "@remnic/core/salvage-envelope";
-
-// ../../src/memory-promote.ts
-import { createHash } from "crypto";
 import { composeSalvagedEnvelope } from "@remnic/core/salvage-envelope";
-import {
-  STRUCTURED_ATTRIBUTE_LIMITS,
-  TAG_LIMITS
-} from "@remnic/core/write-envelope";
-import { stripAttributesSuffix } from "@remnic/core/storage";
-import { isSupportPassportPrivateMemory } from "@remnic/core/support-passport";
-import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
-import { isSafeRouteNamespace } from "@remnic/core/routing/engine";
-import { indexMemoryAsync, indexesExistAsync } from "@remnic/core/temporal-index";
-function buildPromotionOrigin(srcNamespace, memoryId) {
-  const memoryIdHash = createHash("sha256").update(memoryId).digest("hex");
-  const fullTag = `promotedFrom:${srcNamespace}:${memoryId}`;
-  return {
-    tag: fullTag.length <= TAG_LIMITS.maxTagLength ? fullTag : `promotedFromHash:${memoryIdHash}`,
-    structuredAttributes: {
-      promotedFromNamespace: srcNamespace,
-      promotedFromMemoryIdHash: memoryIdHash,
-      ...memoryId.length <= STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength ? { promotedFromMemoryId: memoryId } : {}
-    }
-  };
-}
-async function executeMemoryPromote(orchestrator, params) {
-  const { memoryId, fromNamespace, toNamespace, note } = params;
-  if (typeof memoryId !== "string" || memoryId.length === 0) {
-    return `Invalid memoryId: ${JSON.stringify(memoryId)} \u2014 expected a non-empty memory ID.`;
-  }
-  for (const [name, value] of [
-    ["fromNamespace", fromNamespace],
-    ["toNamespace", toNamespace]
-  ]) {
-    if (value !== void 0 && value !== null && (typeof value !== "string" || !isSafeRouteNamespace(value))) {
-      return `Invalid ${name}: ${JSON.stringify(value)} \u2014 expected a path-safe namespace name.`;
-    }
-  }
-  const srcNs = fromNamespace ?? orchestrator.config.defaultNamespace;
-  const dstNs = toNamespace ?? orchestrator.config.sharedNamespace;
-  const src = await orchestrator.getStorage(srcNs);
-  const mem = await src.getMemoryById(memoryId);
-  if (!mem || isSupportPassportPrivateMemory(mem)) {
-    return `Memory not found in ${srcNs}: ${memoryId}`;
-  }
-  const dst = await orchestrator.getStorage(dstNs);
-  const promotionOrigin = buildPromotionOrigin(srcNs, memoryId);
-  const promoteEnvelope = composeSalvagedEnvelope(
-    "promote",
-    {
-      content: mem.frontmatter.structuredAttributes ? stripAttributesSuffix(mem.content) : mem.content,
-      category: mem.frontmatter.category,
-      confidence: mem.frontmatter.confidence,
-      tags: (() => {
-        const promotionTags = [
-          "promoted",
-          promotionOrigin.tag,
-          ...note ? [`note:${note}`] : []
-        ];
-        const sourceTags = mem.frontmatter.tags ?? [];
-        return Array.from(/* @__PURE__ */ new Set([...promotionTags, ...sourceTags])).slice(
-          0,
-          TAG_LIMITS.maxTags
-        );
-      })(),
-      structuredAttributes: promotionOrigin.structuredAttributes,
-      entityRef: mem.frontmatter.entityRef
-    },
-    { source: "promote" }
-  );
-  const { id: newId, tombstoneBlocked } = await dst.writeSealedMemory(
-    promoteEnvelope,
-    {
-      importance: mem.frontmatter.importance,
-      supersedes: mem.frontmatter.supersedes,
-      links: mem.frontmatter.links
-    }
-  );
-  if (tombstoneBlocked) {
-    return `Promotion of ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId} is queued for review (tombstone-blocked): no active promoted copy was created.`;
-  }
-  try {
-    if (orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync(orchestrator.config.memoryDir)) {
-      const promoted = await dst.getMemoryById(newId).catch(() => null);
-      if (promoted?.path && promoted.frontmatter?.created) {
-        await indexMemoryAsync(
-          orchestrator.config.memoryDir,
-          promoted.path,
-          promoted.frontmatter.created,
-          promoted.frontmatter.tags ?? []
-        );
-      }
-    }
-  } catch (err) {
-    return `Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId} (index refresh failed \u2014 recall picks it up on the next maintenance pass: ${displayErrorDetail(err)})`;
-  }
-  return `Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId}`;
-}
+import { executeMemoryPromote } from "@remnic/plugin-openclaw/plugin/memory-promote";
 
 // ../../src/shared-context-tools.ts
 import { Type } from "@sinclair/typebox";
@@ -372,49 +275,11 @@ import { wrapWorkLayerContext } from "@remnic/core/work/boundary";
 import { VALID_MEMORY_CATEGORIES } from "@remnic/core/config";
 import { formatProfileTraceAscii } from "@remnic/core/profiling";
 import { runMemoryGovernance } from "@remnic/core/maintenance/memory-governance";
-
-// ../../src/memory-action-target.ts
-import { isSupportPassportPrivateMemory as isSupportPassportPrivateMemory2 } from "@remnic/core";
-function clampUnitInterval(value, fallback) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-function normalizeEligibilitySource(value) {
-  switch (value) {
-    case "extraction":
-    case "consolidation":
-    case "replay":
-    case "manual":
-      return value;
-    default:
-      return "unknown";
-  }
-}
-function deriveMemoryActionPolicyEligibility(memory) {
-  if (!memory) return void 0;
-  const frontmatter = memory.frontmatter;
-  return {
-    confidence: clampUnitInterval(frontmatter.confidence, 0),
-    lifecycleState: frontmatter.status === "archived" ? "archived" : frontmatter.lifecycleState ?? "candidate",
-    importance: clampUnitInterval(frontmatter.importance?.score, 0),
-    source: normalizeEligibilitySource(frontmatter.source)
-  };
-}
-async function readReferencedMemoryForPolicyEligibility(storage, memoryId) {
-  if (!memoryId) return void 0;
-  const direct = await storage.getMemoryById?.(memoryId);
-  if (direct) return direct;
-  const active = (await storage.readAllMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
-  if (active) return active;
-  return (await storage.readArchivedMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
-}
-function blocksSupportPassportMutation(action, memory) {
-  return (action === "update_note" || action === "discard" || action === "link_graph") && Boolean(memory && isSupportPassportPrivateMemory2(memory));
-}
-
-// ../../src/tools.ts
+import {
+  blocksSupportPassportMutation,
+  deriveMemoryActionPolicyEligibility,
+  readReferencedMemoryForPolicyEligibility
+} from "@remnic/plugin-openclaw/plugin/memory-action-target";
 function toolResult2(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
@@ -599,7 +464,7 @@ function registerTools(api, orchestrator, hostRuntimeAgentId) {
   const actionTypeSet = new Set(actionTypes);
   function promptHashForTelemetry(input) {
     if (typeof input !== "string" || input.trim().length === 0) return void 0;
-    return createHash2("sha256").update(input).digest("hex").slice(0, 16);
+    return createHash("sha256").update(input).digest("hex").slice(0, 16);
   }
   function normalizeMemoryCategory(value, fallback) {
     const normalized = asNonEmptyString(value);
@@ -654,11 +519,11 @@ function registerTools(api, orchestrator, hostRuntimeAgentId) {
 Content: ${candidate.content}`
         );
       }
-      if (!result.duplicateOf && orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync2(orchestrator.config.memoryDir)) {
+      if (!result.duplicateOf && orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync(orchestrator.config.memoryDir)) {
         const storage = await orchestrator.getStorage(candidate.namespace);
         const mem = await storage.getMemoryById(result.id).catch(() => null);
         if (mem?.path && mem.frontmatter?.created) {
-          await indexMemoryAsync2(orchestrator.config.memoryDir, mem.path, mem.frontmatter.created, mem.frontmatter.tags ?? []);
+          await indexMemoryAsync(orchestrator.config.memoryDir, mem.path, mem.frontmatter.created, mem.frontmatter.tags ?? []);
         }
       }
       orchestrator.requestQmdMaintenanceForTool(maintenanceReason);
@@ -1832,7 +1697,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         let queuedForReview = false;
         switch (action) {
           case "store_episode": {
-            const episodeEnvelope = composeSalvagedEnvelope2(
+            const episodeEnvelope = composeSalvagedEnvelope(
               "memory-action",
               { content: contentValue, category: normalizedCategory ?? "fact" },
               { source: "memory_action_apply" }
@@ -1851,7 +1716,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             break;
           }
           case "store_note": {
-            const noteEnvelope = composeSalvagedEnvelope2(
+            const noteEnvelope = composeSalvagedEnvelope(
               "memory-action",
               { content: contentValue, category: normalizedCategory ?? "fact" },
               { source: "memory_action_apply" }
@@ -1909,7 +1774,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             break;
           }
           case "summarize_node": {
-            const summaryEnvelope = composeSalvagedEnvelope2(
+            const summaryEnvelope = composeSalvagedEnvelope(
               "memory-action",
               { content: contentValue, category: normalizedCategory ?? "fact" },
               { source: "memory_action_apply" }
@@ -3165,7 +3030,7 @@ import path11 from "path";
 import os from "os";
 import { createOpikExporter } from "@remnic/core/opik-exporter";
 import { readEnvVar, resolveHomeDir as resolveHomeDir3 } from "@remnic/core/runtime/env";
-import { displayErrorDetail as displayErrorDetail2 } from "@remnic/core/runtime/better-sqlite";
+import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
 import { migrateFromEngram } from "@remnic/core/migrate/from-engram";
 
 // ../../src/user-message-cleaning.ts
@@ -3434,7 +3299,7 @@ function buildMemorySearchTool(orchestrator, options = {}) {
 }
 
 // src/runtime-surfaces.ts
-import { composeSalvagedEnvelope as composeSalvagedEnvelope3 } from "@remnic/core/salvage-envelope";
+import { composeSalvagedEnvelope as composeSalvagedEnvelope2 } from "@remnic/core/salvage-envelope";
 import {
   gatewayTaskChainOptions
 } from "@remnic/core/fallback-llm";
@@ -3647,7 +3512,7 @@ async function syncDreamSurfaceEntries(params) {
     const existing = findSurfaceMemoryByAttribute(memories, DREAM_ENTRY_ID_KEY, entry.id);
     if (!existing) {
       const { id: memoryId } = await storage.writeSealedMemory(
-        composeSalvagedEnvelope3(
+        composeSalvagedEnvelope2(
           "dreams-surface",
           { content, category: "moment", confidence: 0.85, tags, structuredAttributes },
           { source: "dreams.md" }
@@ -3707,7 +3572,7 @@ async function syncHeartbeatSurfaceEntries(params) {
     const existing = findSurfaceMemoryByAttribute(memories, HEARTBEAT_ENTRY_ID_KEY, entry.id) ?? findUniqueSurfaceMemoryBySlug(memories, HEARTBEAT_SURFACE_TYPE, entry.slug);
     if (!existing) {
       const { id: memoryId } = await storage.writeSealedMemory(
-        composeSalvagedEnvelope3(
+        composeSalvagedEnvelope2(
           "heartbeat-surface",
           { content, category: "principle", confidence: 0.95, tags, structuredAttributes },
           { source: "heartbeat.md" }
@@ -4213,7 +4078,7 @@ function validateSlotSelection(ctx) {
 
 // ../../src/openclaw-flush-plan-lifecycle.ts
 import path2 from "path";
-import { createHash as createHash3, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import {
   lstat as lstat2,
   mkdir,
@@ -4346,7 +4211,7 @@ function isPathInsideOrEqual(parentPath, childPath) {
   return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 function hashContent(content) {
-  return createHash3("sha256").update(content, "utf8").digest("hex");
+  return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function utf8PrefixByByteLength(content, byteLength) {
   const buffer = Buffer.from(content, "utf8");
@@ -8913,7 +8778,7 @@ function buildTurnFingerprint(input) {
 import { planRecallMode } from "@remnic/core/intent";
 import {
   expandTildePath as expandTildePath3,
-  isSupportPassportPrivateMemory as isSupportPassportPrivateMemory3,
+  isSupportPassportPrivateMemory,
   renderMemoryContextPrompt as renderSharedMemoryContextPrompt,
   resolveAgentAccessAuthToken,
   resolvePrincipal,
@@ -9633,7 +9498,7 @@ function stableOpenClawConfigSignature(value, seen = /* @__PURE__ */ new WeakSet
   return JSON.stringify(String(value));
 }
 function openClawHostEmbeddingConfigSignature(cfg, apiConfig, workspaceDir) {
-  return `sha256:${createHash4("sha256").update(JSON.stringify({
+  return `sha256:${createHash3("sha256").update(JSON.stringify({
     enabled: cfg.hostEmbeddingProviderEnabled !== false,
     memoryDir: cfg.memoryDir,
     providerId: cfg.hostEmbeddingProviderId ?? "",
@@ -10031,7 +9896,7 @@ var pluginDefinition = {
           );
         }
       } catch (error) {
-        const detail = displayErrorDetail2(error) || "unknown error";
+        const detail = displayErrorDetail(error) || "unknown error";
         log8.warn(`OpenClaw flush-plan processing failed: ${detail}`);
       }
     }
@@ -12174,7 +12039,7 @@ Keep the reflection grounded in the evidence below.
             const resolved = await readMemoryByLookup(lookup, agentSessionKey);
             if (!resolved) return null;
             const { memory, displayPath } = resolved;
-            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path) || isSupportPassportPrivateMemory3(memory)) {
+            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path) || isSupportPassportPrivateMemory(memory)) {
               return null;
             }
             const allLines = memory.content.split(/\r?\n/);
@@ -12569,7 +12434,7 @@ function buildOpenClawInboundContentFingerprint(content, message, event, ctx, se
     normalizeThreadId(message.threadId) ?? normalizeThreadId(event.threadId) ?? normalizeThreadId(ctx.threadId) ?? "",
     512
   );
-  const contentHash = createHash4("sha256").update(normalizedContent).digest("hex");
+  const contentHash = createHash3("sha256").update(normalizedContent).digest("hex");
   return [
     sessionPart,
     "content",
@@ -12583,7 +12448,7 @@ function buildOpenClawSparseInboundContentFingerprint(content, sessionKey) {
   const normalizedContent = content.trim();
   if (!normalizedContent) return null;
   const sessionPart = truncateMetadataValue(sessionKey || "default", 512);
-  const contentHash = createHash4("sha256").update(normalizedContent).digest("hex");
+  const contentHash = createHash3("sha256").update(normalizedContent).digest("hex");
   return `${sessionPart}\0sparse-content\0${contentHash}`;
 }
 function withReplyExtractionHint(content, metadata) {

package/dist/plugin/memory-action-target.d.ts

@@ -0,0 +1,11 @@
+import { MemoryActionType, MemoryFile, MemoryActionEligibilityContext } from '@remnic/core/types';
+
+declare function deriveMemoryActionPolicyEligibility(memory: Pick<MemoryFile, "frontmatter"> | null | undefined): MemoryActionEligibilityContext | undefined;
+declare function readReferencedMemoryForPolicyEligibility(storage: {
+    getMemoryById?: (id: string) => Promise<MemoryFile | null>;
+    readAllMemories?: () => Promise<MemoryFile[]>;
+    readArchivedMemories?: () => Promise<MemoryFile[]>;
+}, memoryId: string | undefined): Promise<MemoryFile | null | undefined>;
+declare function blocksSupportPassportMutation(action: MemoryActionType, memory: Pick<MemoryFile, "frontmatter"> | null | undefined): boolean;
+
+export { blocksSupportPassportMutation, deriveMemoryActionPolicyEligibility, readReferencedMemoryForPolicyEligibility };

package/dist/plugin/memory-action-target.js

@@ -0,0 +1,47 @@
+import "../chunk-I2KLQ2HA.js";
+
+// src/plugin/memory-action-target.ts
+import { isSupportPassportPrivateMemory } from "@remnic/core";
+function clampUnitInterval(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function normalizeEligibilitySource(value) {
+  switch (value) {
+    case "extraction":
+    case "consolidation":
+    case "replay":
+    case "manual":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function deriveMemoryActionPolicyEligibility(memory) {
+  if (!memory) return void 0;
+  const frontmatter = memory.frontmatter;
+  return {
+    confidence: clampUnitInterval(frontmatter.confidence, 0),
+    lifecycleState: frontmatter.status === "archived" ? "archived" : frontmatter.lifecycleState ?? "candidate",
+    importance: clampUnitInterval(frontmatter.importance?.score, 0),
+    source: normalizeEligibilitySource(frontmatter.source)
+  };
+}
+async function readReferencedMemoryForPolicyEligibility(storage, memoryId) {
+  if (!memoryId) return void 0;
+  const direct = await storage.getMemoryById?.(memoryId);
+  if (direct) return direct;
+  const active = (await storage.readAllMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
+  if (active) return active;
+  return (await storage.readArchivedMemories?.())?.find((memory) => memory.frontmatter.id === memoryId);
+}
+function blocksSupportPassportMutation(action, memory) {
+  return (action === "update_note" || action === "discard" || action === "link_graph") && Boolean(memory && isSupportPassportPrivateMemory(memory));
+}
+export {
+  blocksSupportPassportMutation,
+  deriveMemoryActionPolicyEligibility,
+  readReferencedMemoryForPolicyEligibility
+};

package/dist/plugin/memory-promote.d.ts

@@ -0,0 +1,10 @@
+import { Orchestrator } from '@remnic/core/orchestrator';
+
+declare function executeMemoryPromote(orchestrator: Orchestrator, params: {
+    memoryId: string;
+    fromNamespace?: string;
+    toNamespace?: string;
+    note?: string;
+}): Promise<string>;
+
+export { executeMemoryPromote };

package/dist/plugin/memory-promote.js

@@ -0,0 +1,102 @@
+import "../chunk-I2KLQ2HA.js";
+
+// src/plugin/memory-promote.ts
+import { createHash } from "crypto";
+import { composeSalvagedEnvelope } from "@remnic/core/salvage-envelope";
+import {
+  STRUCTURED_ATTRIBUTE_LIMITS,
+  TAG_LIMITS
+} from "@remnic/core/write-envelope";
+import { stripAttributesSuffix } from "@remnic/core/storage";
+import { isSupportPassportPrivateMemory } from "@remnic/core/support-passport";
+import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
+import { isSafeRouteNamespace } from "@remnic/core/routing/engine";
+import { indexMemoryAsync, indexesExistAsync } from "@remnic/core/temporal-index";
+function buildPromotionOrigin(srcNamespace, memoryId) {
+  const memoryIdHash = createHash("sha256").update(memoryId).digest("hex");
+  const fullTag = `promotedFrom:${srcNamespace}:${memoryId}`;
+  return {
+    tag: fullTag.length <= TAG_LIMITS.maxTagLength ? fullTag : `promotedFromHash:${memoryIdHash}`,
+    structuredAttributes: {
+      promotedFromNamespace: srcNamespace,
+      promotedFromMemoryIdHash: memoryIdHash,
+      ...memoryId.length <= STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength ? { promotedFromMemoryId: memoryId } : {}
+    }
+  };
+}
+async function executeMemoryPromote(orchestrator, params) {
+  const { memoryId, fromNamespace, toNamespace, note } = params;
+  if (typeof memoryId !== "string" || memoryId.length === 0) {
+    return `Invalid memoryId: ${JSON.stringify(memoryId)} \u2014 expected a non-empty memory ID.`;
+  }
+  for (const [name, value] of [
+    ["fromNamespace", fromNamespace],
+    ["toNamespace", toNamespace]
+  ]) {
+    if (value !== void 0 && value !== null && (typeof value !== "string" || !isSafeRouteNamespace(value))) {
+      return `Invalid ${name}: ${JSON.stringify(value)} \u2014 expected a path-safe namespace name.`;
+    }
+  }
+  const srcNs = fromNamespace ?? orchestrator.config.defaultNamespace;
+  const dstNs = toNamespace ?? orchestrator.config.sharedNamespace;
+  const src = await orchestrator.getStorage(srcNs);
+  const mem = await src.getMemoryById(memoryId);
+  if (!mem || isSupportPassportPrivateMemory(mem)) {
+    return `Memory not found in ${srcNs}: ${memoryId}`;
+  }
+  const dst = await orchestrator.getStorage(dstNs);
+  const promotionOrigin = buildPromotionOrigin(srcNs, memoryId);
+  const promoteEnvelope = composeSalvagedEnvelope(
+    "promote",
+    {
+      content: mem.frontmatter.structuredAttributes ? stripAttributesSuffix(mem.content) : mem.content,
+      category: mem.frontmatter.category,
+      confidence: mem.frontmatter.confidence,
+      tags: (() => {
+        const promotionTags = [
+          "promoted",
+          promotionOrigin.tag,
+          ...note ? [`note:${note}`] : []
+        ];
+        const sourceTags = mem.frontmatter.tags ?? [];
+        return Array.from(/* @__PURE__ */ new Set([...promotionTags, ...sourceTags])).slice(
+          0,
+          TAG_LIMITS.maxTags
+        );
+      })(),
+      structuredAttributes: promotionOrigin.structuredAttributes,
+      entityRef: mem.frontmatter.entityRef
+    },
+    { source: "promote" }
+  );
+  const { id: newId, tombstoneBlocked } = await dst.writeSealedMemory(
+    promoteEnvelope,
+    {
+      importance: mem.frontmatter.importance,
+      supersedes: mem.frontmatter.supersedes,
+      links: mem.frontmatter.links
+    }
+  );
+  if (tombstoneBlocked) {
+    return `Promotion of ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId} is queued for review (tombstone-blocked): no active promoted copy was created.`;
+  }
+  try {
+    if (orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync(orchestrator.config.memoryDir)) {
+      const promoted = await dst.getMemoryById(newId).catch(() => null);
+      if (promoted?.path && promoted.frontmatter?.created) {
+        await indexMemoryAsync(
+          orchestrator.config.memoryDir,
+          promoted.path,
+          promoted.frontmatter.created,
+          promoted.frontmatter.tags ?? []
+        );
+      }
+    }
+  } catch (err) {
+    return `Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId} (index refresh failed \u2014 recall picks it up on the next maintenance pass: ${displayErrorDetail(err)})`;
+  }
+  return `Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId}`;
+}
+export {
+  executeMemoryPromote
+};