@remnic/plugin-openclaw 1.0.10 → 1.0.12

package/dist/kdf-H5B23ZM2.js

@@ -0,0 +1,25 @@
+import {
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  KDF_KEY_LENGTH,
+  KDF_SALT_LENGTH,
+  constantTimeEqual,
+  deriveKey,
+  deriveKeyArgon2id,
+  deriveKeyScrypt,
+  validateArgon2idParams,
+  validateScryptParams
+} from "./chunk-6IWEAUN6.js";
+import "./chunk-MLKGABMK.js";
+export {
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  KDF_KEY_LENGTH,
+  KDF_SALT_LENGTH,
+  constantTimeEqual,
+  deriveKey,
+  deriveKeyArgon2id,
+  deriveKeyScrypt,
+  validateArgon2idParams,
+  validateScryptParams
+};

package/dist/memory-governance-SJ5DGRB3.js

@@ -0,0 +1,25 @@
+import {
+  buildProposedActions,
+  buildQualityScore,
+  groupActionsByStatus,
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact,
+  restoreMemoryGovernanceRun,
+  runMemoryGovernance
+} from "./chunk-CDAZGIGT.js";
+import "./chunk-4G2XCSD2.js";
+import "./chunk-7UZNLMW5.js";
+import "./chunk-6OJAU466.js";
+import "./chunk-RKR6PTPA.js";
+import "./chunk-UFU5GGGA.js";
+import "./chunk-YGGGUTG3.js";
+import "./chunk-MLKGABMK.js";
+export {
+  buildProposedActions,
+  buildQualityScore,
+  groupActionsByStatus,
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact,
+  restoreMemoryGovernanceRun,
+  runMemoryGovernance
+};

package/dist/metadata-JAGIWHEA.js

@@ -0,0 +1,20 @@
+import {
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  buildMetadata,
+  decodeMetadataSalt,
+  parseMetadata,
+  serializeMetadata,
+  validateMetadata
+} from "./chunk-JZBOXOUC.js";
+import "./chunk-6IWEAUN6.js";
+import "./chunk-MLKGABMK.js";
+export {
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  buildMetadata,
+  decodeMetadataSalt,
+  parseMetadata,
+  serializeMetadata,
+  validateMetadata
+};

package/dist/migrate-from-identity-anchor-N3354WMP.js

@@ -0,0 +1,7 @@
+import {
+  migrateFromIdentityAnchor
+} from "./chunk-TLVIQLB4.js";
+import "./chunk-MLKGABMK.js";
+export {
+  migrateFromIdentityAnchor
+};

package/dist/path-5LCUBAAZ.js

@@ -0,0 +1,8 @@
+import {
+  expandTildePath
+} from "./chunk-OEI7GLV2.js";
+import "./chunk-I6B2W2IY.js";
+import "./chunk-MLKGABMK.js";
+export {
+  expandTildePath
+};

package/dist/peers-JF2I6RCR.js

@@ -0,0 +1,43 @@
+import {
+  buildPeerProfileReasonerPrompt,
+  parsePeerProfileReasonerResponse,
+  runPeerProfileReasoner
+} from "./chunk-HRGFO6AW.js";
+import {
+  PEERS_DIR_NAME,
+  PEER_ID_MAX_LENGTH,
+  PEER_ID_PATTERN,
+  appendInteractionLog,
+  assertValidPeerId,
+  deletePeer,
+  forgetPeer,
+  listPeers,
+  migrateFromIdentityAnchor,
+  readInteractionLogRaw,
+  readPeer,
+  readPeerInteractionLog,
+  readPeerProfile,
+  writePeer,
+  writePeerProfile
+} from "./chunk-TLVIQLB4.js";
+import "./chunk-MLKGABMK.js";
+export {
+  PEERS_DIR_NAME,
+  PEER_ID_MAX_LENGTH,
+  PEER_ID_PATTERN,
+  appendInteractionLog,
+  assertValidPeerId,
+  buildPeerProfileReasonerPrompt,
+  deletePeer,
+  forgetPeer,
+  listPeers,
+  migrateFromIdentityAnchor,
+  parsePeerProfileReasonerResponse,
+  readInteractionLogRaw,
+  readPeer,
+  readPeerInteractionLog,
+  readPeerProfile,
+  runPeerProfileReasoner,
+  writePeer,
+  writePeerProfile
+};

package/dist/purge-XN2VSPZ2.js

@@ -0,0 +1,204 @@
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/maintenance/purge.ts
+import path from "path";
+import { appendFile, mkdir, unlink } from "fs/promises";
+function hasErrorCode(err, code) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === code;
+}
+function resolveTimestamp(memory) {
+  const fm = memory.frontmatter;
+  const updated = typeof fm.updated === "string" ? fm.updated : "";
+  const created = typeof fm.created === "string" ? fm.created : "";
+  return updated.length > 0 ? updated : created;
+}
+async function logPurgeAudit(storage, candidates, now, event = "PURGE_HARD_DELETE") {
+  if (candidates.length === 0) return;
+  const ledgerDir = path.join(storage.dir, "state", "observation-ledger");
+  await mkdir(ledgerDir, { recursive: true });
+  const ledgerPath = path.join(ledgerDir, "purge-audit.jsonl");
+  const entries = candidates.map(
+    (c) => JSON.stringify({
+      event,
+      timestamp: now.toISOString(),
+      memoryId: c.id,
+      path: c.path,
+      tier: c.tier,
+      status: c.status,
+      updatedOrCreated: c.updatedOrCreated
+    })
+  );
+  if (entries.length > 0) {
+    await appendFile(ledgerPath, `${entries.join("\n")}
+`, "utf-8");
+  }
+}
+async function purgeMemories(options) {
+  const {
+    storage,
+    olderThanMs,
+    tier = "cold",
+    forgottenOnly = false,
+    dryRun = true,
+    qmd,
+    hotCollection = "openclaw-engram",
+    coldCollection = "openclaw-engram-cold"
+  } = options;
+  if (!Number.isFinite(olderThanMs) || olderThanMs <= 0) {
+    throw new Error("olderThanMs must be a finite positive number");
+  }
+  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+  const nowMs = now.getTime();
+  const [hotMemories, coldMemories, archivedMemories] = await Promise.all([
+    tier === "all" ? storage.readAllMemories() : Promise.resolve([]),
+    storage.readAllColdMemories(),
+    tier === "all" ? storage.readArchivedMemories() : Promise.resolve([])
+  ]);
+  const poolEntries = [];
+  if (tier === "all") {
+    for (const m of hotMemories) {
+      poolEntries.push({ memory: m, resolvedTier: "hot" });
+    }
+    for (const m of archivedMemories) {
+      poolEntries.push({ memory: m, resolvedTier: "archive" });
+    }
+  }
+  for (const m of coldMemories) {
+    poolEntries.push({ memory: m, resolvedTier: "cold" });
+  }
+  const candidates = [];
+  const candidateMemoriesById = /* @__PURE__ */ new Map();
+  for (const { memory, resolvedTier } of poolEntries) {
+    const ts = resolveTimestamp(memory);
+    if (ts.length === 0) continue;
+    const tsMs = Date.parse(ts);
+    if (!Number.isFinite(tsMs)) continue;
+    const ageMs = nowMs - tsMs;
+    if (ageMs < olderThanMs) continue;
+    const fm = memory.frontmatter;
+    const status = typeof fm.status === "string" ? fm.status : "active";
+    if (forgottenOnly && status !== "forgotten") continue;
+    candidates.push({
+      id: memory.frontmatter.id,
+      path: memory.path,
+      tier: resolvedTier,
+      status,
+      updatedOrCreated: ts,
+      ageMs
+    });
+    candidateMemoriesById.set(memory.frontmatter.id, memory);
+  }
+  if (dryRun) {
+    return {
+      dryRun: true,
+      tier,
+      olderThanMs,
+      candidates,
+      purgedCount: 0,
+      alreadyAbsentCount: 0,
+      errorCount: 0,
+      errors: []
+    };
+  }
+  const errors = [];
+  try {
+    await logPurgeAudit(storage, candidates, now, "PURGE_DELETE_INTENT");
+  } catch (auditErr) {
+    errors.push({
+      id: "(purge-audit)",
+      path: path.join(storage.dir, "state", "observation-ledger", "purge-audit.jsonl"),
+      error: auditErr instanceof Error ? auditErr.message : String(auditErr)
+    });
+  }
+  const actuallyPurged = [];
+  const alreadyAbsent = [];
+  const collectionsToUpdate = /* @__PURE__ */ new Set();
+  const addCollectionForCandidate = (candidate) => {
+    if (candidate.tier === "cold") {
+      collectionsToUpdate.add(coldCollection);
+    } else if (candidate.tier === "hot") {
+      collectionsToUpdate.add(hotCollection);
+    }
+  };
+  for (const candidate of candidates) {
+    try {
+      await unlink(candidate.path);
+      actuallyPurged.push(candidate);
+      addCollectionForCandidate(candidate);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (hasErrorCode(err, "ENOENT")) {
+        alreadyAbsent.push(candidate);
+        addCollectionForCandidate(candidate);
+      } else {
+        errors.push({ id: candidate.id, path: candidate.path, error: message });
+      }
+    }
+  }
+  const recordPostDeleteAudit = async (purgedCandidates, event) => {
+    try {
+      await logPurgeAudit(storage, purgedCandidates, now, event);
+    } catch (auditErr) {
+      errors.push({
+        id: "(purge-audit)",
+        path: path.join(storage.dir, "state", "observation-ledger", "purge-audit.jsonl"),
+        error: auditErr instanceof Error ? auditErr.message : String(auditErr)
+      });
+    }
+  };
+  await recordPostDeleteAudit(actuallyPurged, "PURGE_HARD_DELETE");
+  await recordPostDeleteAudit(alreadyAbsent, "PURGE_ALREADY_ABSENT");
+  const resolvedPurges = [...actuallyPurged, ...alreadyAbsent];
+  const invalidateTierCaches = storage.invalidateMemoryCachesForTiers;
+  if (typeof invalidateTierCaches === "function") {
+    invalidateTierCaches.call(storage, new Set(resolvedPurges.map((candidate) => candidate.tier)));
+  } else if (typeof storage.invalidateAllMemoriesCacheForDir === "function") {
+    storage.invalidateAllMemoriesCacheForDir();
+  }
+  if (qmd) {
+    for (const collection of collectionsToUpdate) {
+      try {
+        if (typeof qmd.updateCollectionStrict === "function") {
+          await qmd.updateCollectionStrict(collection, { signal: options.signal });
+        } else {
+          await qmd.updateCollection(collection, { signal: options.signal });
+        }
+      } catch (indexErr) {
+        errors.push({
+          id: "(qmd-update)",
+          path: collection,
+          error: indexErr instanceof Error ? indexErr.message : String(indexErr)
+        });
+      }
+    }
+  }
+  const purgedFactMemories = resolvedPurges.map((candidate) => candidateMemoriesById.get(candidate.id)).filter((memory) => memory?.frontmatter.category === "fact");
+  if (purgedFactMemories.length > 0) {
+    const removeFactHashes = storage.removeFactContentHashesForMemories;
+    if (typeof removeFactHashes === "function") {
+      try {
+        await removeFactHashes.call(storage, purgedFactMemories);
+        await options.afterFactHashRemoval?.();
+      } catch (hashErr) {
+        errors.push({
+          id: "(fact-hash-index)",
+          path: path.join(storage.dir, "state", "fact-hashes.txt"),
+          error: hashErr instanceof Error ? hashErr.message : String(hashErr)
+        });
+      }
+    }
+  }
+  return {
+    dryRun: false,
+    tier,
+    olderThanMs,
+    candidates,
+    purgedCount: actuallyPurged.length,
+    alreadyAbsentCount: alreadyAbsent.length,
+    errorCount: errors.length,
+    errors
+  };
+}
+export {
+  purgeMemories
+};

package/dist/secure-store-A4NGCNXV.js

@@ -0,0 +1,155 @@
+import {
+  MIN_PASSPHRASE_LENGTH,
+  createPassphraseReader,
+  renderDisableReport,
+  renderInitReport,
+  renderLockReport,
+  renderMigrateReport,
+  renderStatusReport,
+  renderUnlockReport,
+  runSecureStoreDisable,
+  runSecureStoreInit,
+  runSecureStoreLock,
+  runSecureStoreMigrate,
+  runSecureStoreStatus,
+  runSecureStoreUnlock
+} from "./chunk-6F6EKSVP.js";
+import {
+  HEADER_FILENAME,
+  HEADER_FORMAT,
+  HEADER_FORMAT_VERSION,
+  SECURE_STORE_DIR_NAME,
+  buildHeader,
+  buildHeaderFromPassphrase,
+  deriveKeyFromHeader,
+  headerPath,
+  keyring_exports,
+  parseHeader,
+  readHeader,
+  secureStoreDir,
+  serializeHeader,
+  validateHeader,
+  verifyKey,
+  writeHeader
+} from "./chunk-CXM7EBAO.js";
+import {
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  buildMetadata,
+  decodeMetadataSalt,
+  parseMetadata,
+  serializeMetadata,
+  validateMetadata
+} from "./chunk-JZBOXOUC.js";
+import {
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  KDF_KEY_LENGTH,
+  KDF_SALT_LENGTH,
+  constantTimeEqual,
+  deriveKey,
+  deriveKeyScrypt,
+  validateScryptParams
+} from "./chunk-6IWEAUN6.js";
+import {
+  FILE_FORMAT_FLAGS,
+  FILE_FORMAT_VERSION,
+  MAGIC_BYTES,
+  MAGIC_HEADER_SIZE,
+  SecureStoreDecryptError,
+  SecureStoreLockedError,
+  decryptFileBody,
+  decryptMemoryDirToPlaintext,
+  encryptFileBody,
+  filePathAad,
+  isEncryptedFile,
+  migrateMemoryDirToEncrypted,
+  readMaybeEncryptedFile,
+  writeMaybeEncryptedFile
+} from "./chunk-RKR6PTPA.js";
+import {
+  AES_KEY_LENGTH,
+  AUTH_TAG_LENGTH,
+  ENVELOPE_HEADER_SIZE,
+  ENVELOPE_LAYOUT,
+  ENVELOPE_SALT_LENGTH,
+  ENVELOPE_VERSION,
+  IV_LENGTH,
+  generateSalt,
+  open,
+  parseEnvelope,
+  seal
+} from "./chunk-YGGGUTG3.js";
+import "./chunk-MLKGABMK.js";
+export {
+  AES_KEY_LENGTH,
+  AUTH_TAG_LENGTH,
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  ENVELOPE_HEADER_SIZE,
+  ENVELOPE_LAYOUT,
+  ENVELOPE_SALT_LENGTH,
+  ENVELOPE_VERSION,
+  FILE_FORMAT_FLAGS,
+  FILE_FORMAT_VERSION,
+  HEADER_FILENAME,
+  HEADER_FORMAT,
+  HEADER_FORMAT_VERSION,
+  IV_LENGTH,
+  KDF_KEY_LENGTH,
+  KDF_SALT_LENGTH,
+  MAGIC_BYTES,
+  MAGIC_HEADER_SIZE,
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  MIN_PASSPHRASE_LENGTH,
+  SECURE_STORE_DIR_NAME,
+  SecureStoreDecryptError,
+  SecureStoreLockedError,
+  buildHeader,
+  buildHeaderFromPassphrase,
+  buildMetadata,
+  constantTimeEqual,
+  createPassphraseReader,
+  decodeMetadataSalt,
+  decryptFileBody,
+  decryptMemoryDirToPlaintext,
+  deriveKey,
+  deriveKeyFromHeader,
+  deriveKeyScrypt,
+  encryptFileBody,
+  filePathAad,
+  generateSalt,
+  headerPath,
+  isEncryptedFile,
+  keyring_exports as keyring,
+  migrateMemoryDirToEncrypted,
+  open,
+  parseEnvelope,
+  parseHeader,
+  parseMetadata,
+  readHeader,
+  readMaybeEncryptedFile,
+  renderDisableReport,
+  renderInitReport,
+  renderLockReport,
+  renderMigrateReport,
+  renderStatusReport,
+  renderUnlockReport,
+  runSecureStoreDisable,
+  runSecureStoreInit,
+  runSecureStoreLock,
+  runSecureStoreMigrate,
+  runSecureStoreStatus,
+  runSecureStoreUnlock,
+  seal,
+  secureStoreDir,
+  serializeHeader,
+  serializeMetadata,
+  validateHeader,
+  validateMetadata,
+  validateScryptParams,
+  verifyKey,
+  writeHeader,
+  writeMaybeEncryptedFile
+};

package/dist/state-PVISYXRH.js

@@ -0,0 +1,7 @@
+import {
+  gatherConsoleState
+} from "./chunk-MBIFE6SA.js";
+import "./chunk-MLKGABMK.js";
+export {
+  gatherConsoleState
+};

package/dist/state-store-LP5BO6SF.js

@@ -0,0 +1,15 @@
+import {
+  _connectorStatePathForTest,
+  listConnectorStates,
+  readConnectorState,
+  writeConnectorState
+} from "./chunk-37NKFWSO.js";
+import "./chunk-OEI7GLV2.js";
+import "./chunk-I6B2W2IY.js";
+import "./chunk-MLKGABMK.js";
+export {
+  _connectorStatePathForTest,
+  listConnectorStates,
+  readConnectorState,
+  writeConnectorState
+};

package/dist/{storage-DM4ZGOCN.js → storage-PTQ2H2YJ.js}

@@ -8,9 +8,11 @@ import {
   normalizeEntityName,
   parseEntityFile,
   serializeEntityFile
-} from "./chunk-JJSNPSCD.js";
+} from "./chunk-7UZNLMW5.js";
 import "./chunk-6OJAU466.js";
+import "./chunk-RKR6PTPA.js";
 import "./chunk-UFU5GGGA.js";
+import "./chunk-YGGGUTG3.js";
 import "./chunk-MLKGABMK.js";
 export {
   ContentHashIndex,

package/dist/tier-stats-IZNW66NC.js

@@ -0,0 +1,147 @@
+import {
+  applyUtilityPromotionRuntimePolicy,
+  computeTierValueScore,
+  decideTierTransition,
+  loadUtilityRuntimeValues
+} from "./chunk-7OQEPGQF.js";
+import {
+  computeLifecycleValueInputs
+} from "./chunk-4G2XCSD2.js";
+import "./chunk-3G7FAF6S.js";
+import "./chunk-5LE4HTVL.js";
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/maintenance/tier-stats.ts
+async function readTierVisibleMemories(storage) {
+  const [hotMemories, coldMemories] = await Promise.all([
+    storage.readAllMemories(),
+    storage.readAllColdMemories()
+  ]);
+  return [
+    ...hotMemories.map((memory) => ({ memory, tier: "hot" })),
+    ...coldMemories.map((memory) => ({ memory, tier: "cold" }))
+  ];
+}
+async function tierRoutingPolicyFromConfig(config) {
+  const basePolicy = {
+    enabled: config.qmdTierMigrationEnabled,
+    demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
+    demotionValueThreshold: config.qmdTierDemotionValueThreshold,
+    promotionValueThreshold: config.qmdTierPromotionValueThreshold
+  };
+  const runtime = await loadUtilityRuntimeValues({
+    memoryDir: config.memoryDir,
+    memoryUtilityLearningEnabled: config.memoryUtilityLearningEnabled,
+    promotionByOutcomeEnabled: config.promotionByOutcomeEnabled
+  });
+  return applyUtilityPromotionRuntimePolicy(basePolicy, runtime);
+}
+async function summarizeTiers(storage) {
+  const all = await readTierVisibleMemories(storage);
+  const summary = {
+    total: all.length,
+    byTier: { hot: 0, cold: 0 },
+    byStatus: {},
+    forgottenCount: 0,
+    byCategory: {}
+  };
+  for (const { memory: m, tier } of all) {
+    summary.byTier[tier] += 1;
+    const status = m.frontmatter.status ?? "active";
+    summary.byStatus[status] = (summary.byStatus[status] ?? 0) + 1;
+    if (status === "forgotten") summary.forgottenCount += 1;
+    const cat = m.frontmatter.category ?? "(uncategorized)";
+    summary.byCategory[cat] = (summary.byCategory[cat] ?? 0) + 1;
+  }
+  return summary;
+}
+async function explainTierForMemory(storage, id, config) {
+  const trimmed = typeof id === "string" ? id.trim() : "";
+  if (trimmed.length === 0) {
+    throw new Error("tier explain: memory id is required and must be non-empty");
+  }
+  const all = await readTierVisibleMemories(storage);
+  const entry = all.find(({ memory: m }) => m.frontmatter.id === trimmed);
+  if (!entry) {
+    throw new Error(`tier explain: memory not found: ${trimmed}`);
+  }
+  const { memory, tier: currentTier } = entry;
+  const now = /* @__PURE__ */ new Date();
+  const valueInputs = computeLifecycleValueInputs(memory, now);
+  const valueScore = computeTierValueScore(memory, now);
+  const policy = await tierRoutingPolicyFromConfig(config);
+  const decision = decideTierTransition(memory, currentTier, policy, now);
+  const fm = memory.frontmatter;
+  return {
+    id: trimmed,
+    path: memory.path,
+    currentTier,
+    status: typeof fm.status === "string" ? fm.status : "active",
+    category: typeof fm.category === "string" ? fm.category : "",
+    valueScore,
+    decision,
+    signals: {
+      confidence: valueInputs.confidence,
+      accessCount: typeof fm.accessCount === "number" ? fm.accessCount : 0,
+      lastAccessed: typeof fm.lastAccessed === "string" ? fm.lastAccessed : null,
+      created: typeof fm.created === "string" ? fm.created : "",
+      updated: typeof fm.updated === "string" ? fm.updated : "",
+      importance: valueInputs.importance,
+      feedback: valueInputs.feedback
+    }
+  };
+}
+function formatTierSummaryText(summary) {
+  const lines = [];
+  lines.push("=== Memory Tier Distribution ===");
+  lines.push(`Total memories: ${summary.total}`);
+  lines.push("");
+  lines.push("Tier:");
+  lines.push(`  hot:  ${summary.byTier.hot}`);
+  lines.push(`  cold: ${summary.byTier.cold}`);
+  lines.push("");
+  lines.push("Status:");
+  const statusEntries = Object.entries(summary.byStatus).sort(
+    (a, b) => b[1] - a[1] || a[0].localeCompare(b[0])
+  );
+  for (const [status, count] of statusEntries) {
+    lines.push(`  ${status}: ${count}`);
+  }
+  lines.push("");
+  lines.push("Top categories:");
+  const categoryEntries = Object.entries(summary.byCategory).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 8);
+  for (const [cat, count] of categoryEntries) {
+    lines.push(`  ${cat}: ${count}`);
+  }
+  return lines.join("\n");
+}
+function formatTierExplainText(explain) {
+  const lines = [];
+  lines.push(`=== Tier Explain: ${explain.id} ===`);
+  lines.push(`path:          ${explain.path}`);
+  lines.push(`current tier:  ${explain.currentTier}`);
+  lines.push(`status:        ${explain.status}`);
+  lines.push(`category:      ${explain.category}`);
+  lines.push(`value score:   ${explain.valueScore.toFixed(3)}`);
+  lines.push("");
+  lines.push("Tier-transition decision:");
+  lines.push(`  next tier: ${explain.decision.nextTier}`);
+  lines.push(`  changed:   ${explain.decision.changed}`);
+  lines.push(`  reason:    ${explain.decision.reason}`);
+  lines.push("");
+  lines.push("Signals:");
+  lines.push(`  confidence:   ${explain.signals.confidence}`);
+  lines.push(`  accessCount:  ${explain.signals.accessCount}`);
+  lines.push(`  lastAccessed: ${explain.signals.lastAccessed ?? "(never)"}`);
+  lines.push(`  created:      ${explain.signals.created}`);
+  lines.push(`  updated:      ${explain.signals.updated}`);
+  lines.push(`  importance:   ${explain.signals.importance}`);
+  lines.push(`  feedback:     ${explain.signals.feedback}`);
+  return lines.join("\n");
+}
+export {
+  explainTierForMemory,
+  formatTierExplainText,
+  formatTierSummaryText,
+  summarizeTiers
+};